#include <ODBCResultSetMetaData.h>
Inheritance diagram for ODBCResultSetMetaData:
Public Methods | |
| Int_t | GetColumnCount () |
| Bool_t | IsAutoIncrement (Int_t column) |
| Bool_t | IsCaseSensitive (Int_t column) |
| Bool_t | IsSearchable (Int_t column) |
| Bool_t | IsCurrency (Int_t column) |
| Bool_t | IsNullable (Int_t column) |
| Bool_t | IsSigned (Int_t column) |
| Int_t | GetColumnDisplaySize (Int_t column) |
| TString | GetColumnLabel (Int_t column) |
| TString | GetColumnName (Int_t column) |
| TString | GetSchemaName (Int_t column) |
| Int_t | GetPrecision (Int_t column) |
| Int_t | GetScale (Int_t column) |
| TString | GetTableName (Int_t column) |
| TString | GetCatalogName (Int_t column) |
| Int_t | GetColumnType (Int_t column) |
| TString | GetColumnTypeName (Int_t column) |
| Bool_t | IsReadOnly (Int_t column) |
| Bool_t | IsWritable (Int_t column) |
| Bool_t | IsDefinitelyWritable (Int_t column) |
Protected Methods | |
| ODBCResultSetMetaData (TSQLResultSet *rs, void *imp=0) | |
| virtual | ~ODBCResultSetMetaData () |
Friends | |
| class | ODBCResultSet |
|
||||||||||||
|
|
|
|
Definition at line 57 of file ODBCResultSetMetaData.cxx. References TSQL::fImp, TSQLResultSetMetaData::fResultSet, ODBCXX_STRING_CSTR, and TSQL::Throw().
00058 {
00059 // dtor
00060
00061 fResultSet = 0;
00062 // odbc::ResultSetMetaData* imp = (odbc::ResultSetMetaData*)fImp;
00063 fImp = 0;
00064
00065 try {
00066 //
00067 // delete imp; // !!! private dtor, deleted by result set
00068 } catch(odbc::SQLException& e) {
00069 Throw( new TSQLException( ODBCXX_STRING_CSTR(e.getMessage()),
00070 ODBCXX_STRING_CSTR(e.getSQLState()),
00071 e.getErrorCode()) );
00072 }
00073 }
|
|
|
Implements TSQLResultSetMetaData. Definition at line 481 of file ODBCResultSetMetaData.cxx. References TSQL::fImp, odbc::ResultSetMetaData::getCatalogName(), ODBCXX_STRING_CSTR, and TSQL::Throw().
00482 {
00483 // Gets a column's table's catalog name.
00484 //
00485 // Parameters:
00486 // column - the first column is 1, the second is 2, ...
00487 // Returns:
00488 // column name or "" if not applicable.
00489 // Throws:
00490 // TSQLException - if a database access error occurs
00491
00492 TString str;
00493
00494 if(!fImp) { Destroyed(); return str; }
00495 odbc::ResultSetMetaData* imp = (odbc::ResultSetMetaData*)fImp;
00496
00497 try {
00498 str = ODBCXX_STRING_CSTR( imp->getCatalogName(column) );
00499 } catch(odbc::SQLException& e) {
00500 Throw( new TSQLException( ODBCXX_STRING_CSTR(e.getMessage()),
00501 ODBCXX_STRING_CSTR(e.getSQLState()),
00502 e.getErrorCode()) );
00503 return "";
00504 }
00505 return str;
00506 }
|
|
|
Implements TSQLResultSetMetaData. Definition at line 76 of file ODBCResultSetMetaData.cxx. References TSQL::fImp, odbc::ResultSetMetaData::getColumnCount(), ODBCXX_STRING_CSTR, and TSQL::Throw().
00077 {
00078 // Returns the number of columns in this TSQLResultSet
00079 // If there are no columns in the result set, zero is
00080 // returned.
00081 //
00082 // Returns:
00083 // the number of columns
00084 // Throws:
00085 // TSQLException - if a database access error occurs
00086
00087 Int_t return_value = 0;
00088
00089 if(!fImp) { Destroyed(); return return_value; }
00090 odbc::ResultSetMetaData* imp = (odbc::ResultSetMetaData*)fImp;
00091
00092 try {
00093 return_value = imp->getColumnCount();
00094 } catch(odbc::SQLException& e) {
00095 Throw( new TSQLException( ODBCXX_STRING_CSTR(e.getMessage()),
00096 ODBCXX_STRING_CSTR(e.getSQLState()),
00097 e.getErrorCode()) );
00098 return 0;
00099 }
00100 return return_value;
00101 }
|
|
|
Implements TSQLResultSetMetaData. Definition at line 283 of file ODBCResultSetMetaData.cxx. References TSQL::fImp, odbc::ResultSetMetaData::getColumnDisplaySize(), ODBCXX_STRING_CSTR, and TSQL::Throw().
00284 {
00285 // Indicates the column's normal max width in chars.
00286 //
00287 // Parameters:
00288 // column - the first column is 1, the second is 2, ...
00289 // Returns:
00290 // the normal maximum number of characteimp allowed as
00291 // the width of the designated column
00292 // Throws:
00293 // TSQLException - if a database access error occurs
00294
00295 Int_t return_value = 0;
00296
00297 if(!fImp) { Destroyed(); return return_value; }
00298 odbc::ResultSetMetaData* imp = (odbc::ResultSetMetaData*)fImp;
00299
00300 try {
00301 return_value = imp->getColumnDisplaySize(column);
00302 } catch(odbc::SQLException& e) {
00303 Throw( new TSQLException( ODBCXX_STRING_CSTR(e.getMessage()),
00304 ODBCXX_STRING_CSTR(e.getSQLState()),
00305 e.getErrorCode()) );
00306 return 0;
00307 }
00308 return return_value;
00309 }
|
|
|
Implements TSQLResultSetMetaData. Definition at line 312 of file ODBCResultSetMetaData.cxx. References TSQL::fImp, odbc::ResultSetMetaData::getColumnLabel(), ODBCXX_STRING_CSTR, and TSQL::Throw().
00313 {
00314 // Gets the suggested column title for use in printouts
00315 // and displays.
00316 //
00317 // Parameters:
00318 // column - the first column is 1, the second is 2, ...
00319 // Returns:
00320 // the suggested column title
00321 // Throws:
00322 // TSQLException - if a database access error occurs
00323
00324 TString str;
00325
00326 if(!fImp) { Destroyed(); return str; }
00327 odbc::ResultSetMetaData* imp = (odbc::ResultSetMetaData*)fImp;
00328
00329 try {
00330 str = ODBCXX_STRING_CSTR( imp->getColumnLabel(column) );
00331 } catch(odbc::SQLException& e) {
00332 Throw( new TSQLException( ODBCXX_STRING_CSTR(e.getMessage()),
00333 ODBCXX_STRING_CSTR(e.getSQLState()),
00334 e.getErrorCode()) );
00335 return "";
00336 }
00337 return str;
00338 }
|
|
|
Implements TSQLResultSetMetaData. Definition at line 341 of file ODBCResultSetMetaData.cxx. References TSQL::fImp, odbc::ResultSetMetaData::getColumnName(), ODBCXX_STRING_CSTR, and TSQL::Throw().
00342 {
00343 // Gets a column's name.
00344 //
00345 // Parameters:
00346 // column - the first column is 1, the second is 2, ...
00347 // Returns:
00348 // column name
00349 // Throws:
00350 // TSQLException - if a database access error occurs
00351
00352 TString str;
00353
00354 if(!fImp) { Destroyed(); return str; }
00355 odbc::ResultSetMetaData* imp = (odbc::ResultSetMetaData*)fImp;
00356
00357 try {
00358 str = ODBCXX_STRING_CSTR( imp->getColumnName(column) );
00359 } catch(odbc::SQLException& e) {
00360 Throw( new TSQLException( ODBCXX_STRING_CSTR(e.getMessage()),
00361 ODBCXX_STRING_CSTR(e.getSQLState()),
00362 e.getErrorCode()) );
00363 return "";
00364 }
00365 return str;
00366 }
|
|
|
Implements TSQLResultSetMetaData. Definition at line 509 of file ODBCResultSetMetaData.cxx. References TSQL::fImp, odbc::ResultSetMetaData::getColumnType(), ODBCXX_STRING_CSTR, and TSQL::Throw().
00510 {
00511 // Retrieves a column's SQL type.
00512 //
00513 // enum ESQLTypes {
00514 // kBIGINT = -5,
00515 // kBINARY = -2,
00516 // kBIT = -7,
00517 // kCHAR = 1,
00518 // #ifdef ODBC_VER_LESS_30
00519 // kDATE = 9,
00520 // kTIME = 10,
00521 // kTIMESTAMP = 11,
00522 // #endif
00523 // kDATE = 91,
00524 // kTIME = 92,
00525 // kTIMESTAMP = 93,
00526 // kSMALLINT = 5,
00527 // kDECIMAL = 3,
00528 // kDOUBLE = 8,
00529 // kFLOAT = 6,
00530 // kINTEGER = 4,
00531 // kLONGVARBINARY = -4,
00532 // kLONGVARCHAR = -1,
00533 // kNUMERIC = 2,
00534 // kREAL = 7,
00535 // kTINYINT = -6,
00536 // kVARBINARY = -3,
00537 // kVARCHAR = 12
00538 // };
00539 //
00540 // Parameters:
00541 // column - the first column is 1, the second is 2, ...
00542 // Returns:
00543 // SQL type from TSQLTypes
00544 // Throws:
00545 // TSQLException - if a database access error occurs
00546
00547 Int_t return_value = 0;
00548
00549 if(!fImp) { Destroyed(); return return_value; }
00550 odbc::ResultSetMetaData* imp = (odbc::ResultSetMetaData*)fImp;
00551
00552 try {
00553 return_value = imp->getColumnType(column);
00554 } catch(odbc::SQLException& e) {
00555 Throw( new TSQLException( ODBCXX_STRING_CSTR(e.getMessage()),
00556 ODBCXX_STRING_CSTR(e.getSQLState()),
00557 e.getErrorCode()) );
00558 return 0;
00559 }
00560 return return_value;
00561 }
|
|
|
Implements TSQLResultSetMetaData. Definition at line 564 of file ODBCResultSetMetaData.cxx. References TSQL::fImp, odbc::ResultSetMetaData::getColumnTypeName(), ODBCXX_STRING_CSTR, and TSQL::Throw().
00565 {
00566 // Retrieves a column's database-specific type name.
00567 // See TSQLTypes.h
00568 //
00569 // Parameters:
00570 // column - the first column is 1, the second is 2, ...
00571 // Returns:
00572 // type name used by the database. If the column type is
00573 // a user-defined type, then a fully-qualified type name
00574 // is returned.
00575 // Throws:
00576 // TSQLException - if a database access error occurs
00577
00578 TString str;
00579
00580 if(!fImp) { Destroyed(); return str; }
00581 odbc::ResultSetMetaData* imp = (odbc::ResultSetMetaData*)fImp;
00582
00583 try {
00584 str = ODBCXX_STRING_CSTR( imp->getColumnTypeName(column) );
00585 } catch(odbc::SQLException& e) {
00586 Throw( new TSQLException( ODBCXX_STRING_CSTR(e.getMessage()),
00587 ODBCXX_STRING_CSTR(e.getSQLState()),
00588 e.getErrorCode()) );
00589 return "";
00590 }
00591 return str;
00592 }
|
|
|
Implements TSQLResultSetMetaData. Definition at line 397 of file ODBCResultSetMetaData.cxx. References TSQL::fImp, odbc::ResultSetMetaData::getPrecision(), ODBCXX_STRING_CSTR, and TSQL::Throw().
00398 {
00399 // Gets a column's number of decimal digits.
00400 //
00401 // Parameters:
00402 // column - the first column is 1, the second is 2, ...
00403 // Returns:
00404 // precIsion
00405 // Throws:
00406 // TSQLException - if a database access error occurs
00407
00408 Int_t return_value = 0;
00409
00410 if(!fImp) { Destroyed(); return return_value; }
00411 odbc::ResultSetMetaData* imp = (odbc::ResultSetMetaData*)fImp;
00412
00413 try {
00414 return_value = imp->getPrecision(column);
00415 } catch(odbc::SQLException& e) {
00416 Throw( new TSQLException( ODBCXX_STRING_CSTR(e.getMessage()),
00417 ODBCXX_STRING_CSTR(e.getSQLState()),
00418 e.getErrorCode()) );
00419 return 0;
00420 }
00421 return return_value;
00422 }
|
|
|
Implements TSQLResultSetMetaData. Definition at line 425 of file ODBCResultSetMetaData.cxx. References TSQL::fImp, odbc::ResultSetMetaData::getScale(), ODBCXX_STRING_CSTR, and TSQL::Throw().
00426 {
00427 // Gets a column's number of digits to right of the decimal point.
00428 //
00429 // Parameters:
00430 // column - the first column is 1, the second is 2, ...
00431 // Returns:
00432 // scale
00433 // Throws:
00434 // TSQLException - if a database access error occurs
00435
00436 Int_t return_value = 0;
00437
00438 if(!fImp) { Destroyed(); return return_value; }
00439 odbc::ResultSetMetaData* imp = (odbc::ResultSetMetaData*)fImp;
00440
00441 try {
00442 return_value = imp->getScale(column);
00443 } catch(odbc::SQLException& e) {
00444 Throw( new TSQLException( ODBCXX_STRING_CSTR(e.getMessage()),
00445 ODBCXX_STRING_CSTR(e.getSQLState()),
00446 e.getErrorCode()) );
00447 return 0;
00448 }
00449 return return_value;
00450 }
|
|
|
Implements TSQLResultSetMetaData. Definition at line 369 of file ODBCResultSetMetaData.cxx. References TSQL::fImp, odbc::ResultSetMetaData::getSchemaName(), ODBCXX_STRING_CSTR, and TSQL::Throw().
00370 {
00371 // Gets a column's table's schema.
00372 //
00373 // Parameters:
00374 // column - the first column is 1, the second is 2, ...
00375 // Returns:
00376 // schema name or "" if not applicable
00377 // Throws:
00378 // TSQLException - if a database access error occurs
00379
00380 TString str;
00381
00382 if(!fImp) { Destroyed(); return str; }
00383 odbc::ResultSetMetaData* imp = (odbc::ResultSetMetaData*)fImp;
00384
00385 try {
00386 str = ODBCXX_STRING_CSTR( imp->getSchemaName(column) );
00387 } catch(odbc::SQLException& e) {
00388 Throw( new TSQLException( ODBCXX_STRING_CSTR(e.getMessage()),
00389 ODBCXX_STRING_CSTR(e.getSQLState()),
00390 e.getErrorCode()) );
00391 return "";
00392 }
00393 return str;
00394 }
|
|
|
Implements TSQLResultSetMetaData. Definition at line 453 of file ODBCResultSetMetaData.cxx. References TSQL::fImp, odbc::ResultSetMetaData::getTableName(), ODBCXX_STRING_CSTR, and TSQL::Throw().
00454 {
00455 // Gets a column's table name.
00456 //
00457 // Parameters:
00458 // column - the first column is 1, the second is 2, ...
00459 // Returns:
00460 // table name or "" if not applicable
00461 // Throws:
00462 // TSQLException - if a database access error occurs
00463
00464 TString str;
00465
00466 if(!fImp) { Destroyed(); return str; }
00467 odbc::ResultSetMetaData* imp = (odbc::ResultSetMetaData*)fImp;
00468
00469 try {
00470 str = ODBCXX_STRING_CSTR( imp->getTableName(column) );
00471 } catch(odbc::SQLException& e) {
00472 Throw( new TSQLException( ODBCXX_STRING_CSTR(e.getMessage()),
00473 ODBCXX_STRING_CSTR(e.getSQLState()),
00474 e.getErrorCode()) );
00475 return "";
00476 }
00477 return str;
00478 }
|
|
|
Implements TSQLResultSetMetaData. Definition at line 104 of file ODBCResultSetMetaData.cxx. References TSQL::fImp, odbc::ResultSetMetaData::isAutoIncrement(), ODBCXX_STRING_CSTR, and TSQL::Throw().
00105 {
00106 // Indicates whether the column is automatically numbered,
00107 // thus read-only.
00108 //
00109 // Parameters:
00110 // column - the first column is 1, the second is 2, ...
00111 // Returns:
00112 // kTRUE - the column's data type is an auto increment data
00113 // type
00114 // kFALSE - the column's data type is not an auto increment
00115 // data type or the column does not contain numeric
00116 // data
00117 // Throws:
00118 // TSQLException - if a database access error occurs
00119 //
00120 //
00121
00122 Bool_t return_value = kFALSE;
00123
00124 if(!fImp) { Destroyed(); return return_value; }
00125 odbc::ResultSetMetaData* imp = (odbc::ResultSetMetaData*)fImp;
00126
00127 try {
00128 return_value = imp->isAutoIncrement(column);
00129 } catch(odbc::SQLException& e) {
00130 Throw( new TSQLException( ODBCXX_STRING_CSTR(e.getMessage()),
00131 ODBCXX_STRING_CSTR(e.getSQLState()),
00132 e.getErrorCode()) );
00133 return kFALSE;
00134 }
00135 return return_value;
00136 }
|
|
|
Implements TSQLResultSetMetaData. Definition at line 139 of file ODBCResultSetMetaData.cxx. References TSQL::fImp, odbc::ResultSetMetaData::isCaseSensitive(), ODBCXX_STRING_CSTR, and TSQL::Throw().
00140 {
00141 // Indicates whether a column's case sensitive for collations
00142 // and comparisons.
00143 //
00144 // Parameters:
00145 // column - the first column is 1, the second is 2, ...
00146 // Returns:
00147 // kTRUE if so
00148 // Throws:
00149 // TSQLException - if a database access error occurs
00150
00151 Bool_t return_value = kFALSE;
00152
00153 if(!fImp) { Destroyed(); return return_value; }
00154 odbc::ResultSetMetaData* imp = (odbc::ResultSetMetaData*)fImp;
00155
00156 try {
00157 return_value = imp->isCaseSensitive(column);
00158 } catch(odbc::SQLException& e) {
00159 Throw( new TSQLException( ODBCXX_STRING_CSTR(e.getMessage()),
00160 ODBCXX_STRING_CSTR(e.getSQLState()),
00161 e.getErrorCode()) );
00162 return kFALSE;
00163 }
00164 return return_value;
00165 }
|
|
|
Implements TSQLResultSetMetaData. Definition at line 196 of file ODBCResultSetMetaData.cxx. References TSQL::fImp, odbc::ResultSetMetaData::isCurrency(), ODBCXX_STRING_CSTR, and TSQL::Throw().
00197 {
00198 // Indicates whether the column is a cash value ( money data
00199 // type ).
00200 //
00201 // Parameters:
00202 // column - the first column is 1, the second is 2, ...
00203 // Returns:
00204 // kTRUE if so
00205 // Throws:
00206 // TSQLException - if a database access error occurs
00207
00208 Bool_t return_value = kFALSE;
00209
00210 if(!fImp) { Destroyed(); return return_value; }
00211 odbc::ResultSetMetaData* imp = (odbc::ResultSetMetaData*)fImp;
00212
00213 try {
00214 return_value = imp->isCurrency(column);
00215 } catch(odbc::SQLException& e) {
00216 Throw( new TSQLException( ODBCXX_STRING_CSTR(e.getMessage()),
00217 ODBCXX_STRING_CSTR(e.getSQLState()),
00218 e.getErrorCode()) );
00219 return kFALSE;
00220 }
00221 return return_value;
00222 }
|
|
|
Implements TSQLResultSetMetaData. Definition at line 652 of file ODBCResultSetMetaData.cxx. References TSQL::fImp, odbc::ResultSetMetaData::isDefinitelyWritable(), ODBCXX_STRING_CSTR, and TSQL::Throw().
00653 {
00654 // Indicates whether a write on the column will definitely succeed.
00655 //
00656 // Parameters:
00657 // column - the first column is 1, the second is 2, ...
00658 // Returns:
00659 // kTRUE if so
00660 // Throws:
00661 // TSQLException - if a database access error occurs
00662
00663 Bool_t return_value = kFALSE;
00664
00665 if(!fImp) { Destroyed(); return return_value; }
00666 odbc::ResultSetMetaData* imp = (odbc::ResultSetMetaData*)fImp;
00667
00668 try {
00669 return_value = imp->isDefinitelyWritable(column);
00670 } catch(odbc::SQLException& e) {
00671 Throw( new TSQLException( ODBCXX_STRING_CSTR(e.getMessage()),
00672 ODBCXX_STRING_CSTR(e.getSQLState()),
00673 e.getErrorCode()) );
00674 return kFALSE;
00675 }
00676 return return_value;
00677 }
|
|
|
Implements TSQLResultSetMetaData. Definition at line 225 of file ODBCResultSetMetaData.cxx. References TSQL::fImp, odbc::ResultSetMetaData::isNullable(), ODBCXX_STRING_CSTR, and TSQL::Throw().
00226 {
00227 // Indicates the nullability of values in the designated column.
00228 //
00229 // Parameters:
00230 // column - the first column is 1, the second is 2, ...
00231 // Returns:
00232 // the nullability status of the given column;
00233 // one of columnNoNulls, columnNullable or
00234 // columnNullableUnknown
00235 // Throws:
00236 // TSQLException - if a database access error occurs
00237
00238 Bool_t return_value = kFALSE;
00239
00240 if(!fImp) { Destroyed(); return return_value; }
00241 odbc::ResultSetMetaData* imp = (odbc::ResultSetMetaData*)fImp;
00242
00243 try {
00244 return_value = imp->isNullable(column);
00245 } catch(odbc::SQLException& e) {
00246 Throw( new TSQLException( ODBCXX_STRING_CSTR(e.getMessage()),
00247 ODBCXX_STRING_CSTR(e.getSQLState()),
00248 e.getErrorCode()) );
00249 return kFALSE;
00250 }
00251 return return_value;
00252 }
|
|
|
Implements TSQLResultSetMetaData. Definition at line 595 of file ODBCResultSetMetaData.cxx. References TSQL::fImp, odbc::ResultSetMetaData::isReadOnly(), ODBCXX_STRING_CSTR, and TSQL::Throw().
00596 {
00597 // Indicates whether a column Is definitely not writable.
00598 //
00599 // Parameters:
00600 // column - the first column is 1, the second is 2, ...
00601 // Returns:
00602 // kTRUE if so
00603 // Throws:
00604 // TSQLException - if a database access error occurs
00605
00606 Bool_t return_value = kTRUE;
00607
00608 if(!fImp) { Destroyed(); return return_value; }
00609 odbc::ResultSetMetaData* imp = (odbc::ResultSetMetaData*)fImp;
00610
00611 try {
00612 return_value = imp->isReadOnly(column);
00613 } catch(odbc::SQLException& e) {
00614 Throw( new TSQLException( ODBCXX_STRING_CSTR(e.getMessage()),
00615 ODBCXX_STRING_CSTR(e.getSQLState()),
00616 e.getErrorCode()) );
00617 return kTRUE;
00618 }
00619 return return_value;
00620 }
|
|
|
Implements TSQLResultSetMetaData. Definition at line 168 of file ODBCResultSetMetaData.cxx. References TSQL::fImp, odbc::ResultSetMetaData::isSearchable(), ODBCXX_STRING_CSTR, and TSQL::Throw().
00169 {
00170 // Indicates whether the column can be used in a 'WHERE' clause.
00171 //
00172 // Parameters:
00173 // column - the first column is 1, the second is 2, ...
00174 // Returns:
00175 // kTRUE if so
00176 // Throws:
00177 // TSQLException - if a database access error occurs
00178
00179 Bool_t return_value = kFALSE;
00180
00181 if(!fImp) { Destroyed(); return return_value; }
00182 odbc::ResultSetMetaData* imp = (odbc::ResultSetMetaData*)fImp;
00183
00184 try {
00185 return_value = imp->isSearchable(column);
00186 } catch(odbc::SQLException& e) {
00187 Throw( new TSQLException( ODBCXX_STRING_CSTR(e.getMessage()),
00188 ODBCXX_STRING_CSTR(e.getSQLState()),
00189 e.getErrorCode()) );
00190 return kFALSE;
00191 }
00192 return return_value;
00193 }
|
|
|
Implements TSQLResultSetMetaData. Definition at line 255 of file ODBCResultSetMetaData.cxx. References TSQL::fImp, odbc::ResultSetMetaData::isSigned(), ODBCXX_STRING_CSTR, and TSQL::Throw().
00256 {
00257 // Indicates whether values in the column are signed numbers
00258 //
00259 // Parameters:
00260 // column - the first column is 1, the second is 2, ...
00261 // Returns:
00262 // kTRUE if so
00263 // Throws:
00264 // TSQLException - if a database access error occurs
00265
00266 Bool_t return_value = kFALSE;
00267
00268 if(!fImp) { Destroyed(); return return_value; }
00269 odbc::ResultSetMetaData* imp = (odbc::ResultSetMetaData*)fImp;
00270
00271 try {
00272 return_value = imp->isSigned(column);
00273 } catch(odbc::SQLException& e) {
00274 Throw( new TSQLException( ODBCXX_STRING_CSTR(e.getMessage()),
00275 ODBCXX_STRING_CSTR(e.getSQLState()),
00276 e.getErrorCode()) );
00277 return kFALSE;
00278 }
00279 return return_value;
00280 }
|
|
|
Implements TSQLResultSetMetaData. Definition at line 623 of file ODBCResultSetMetaData.cxx. References TSQL::fImp, odbc::ResultSetMetaData::isWritable(), ODBCXX_STRING_CSTR, and TSQL::Throw().
00624 {
00625 // Indicates whether it is possible for a write on the column
00626 // to succeed.
00627 //
00628 // Parameters:
00629 // column - the first column is 1, the second is 2, ...
00630 // Returns:
00631 // kTRUE if so
00632 // Throws:
00633 // TSQLException - if a database access error occurs
00634
00635 Bool_t return_value = kFALSE;
00636
00637 if(!fImp) { Destroyed(); return return_value; }
00638 odbc::ResultSetMetaData* imp = (odbc::ResultSetMetaData*)fImp;
00639
00640 try {
00641 return_value = imp->isWritable(column);
00642 } catch(odbc::SQLException& e) {
00643 Throw( new TSQLException( ODBCXX_STRING_CSTR(e.getMessage()),
00644 ODBCXX_STRING_CSTR(e.getSQLState()),
00645 e.getErrorCode()) );
00646 return kFALSE;
00647 }
00648 return return_value;
00649 }
|
|
|
Definition at line 18 of file ODBCResultSetMetaData.h. |
1.2.16