1 /************************************************************** 2 * 3 * Licensed to the Apache Software Foundation (ASF) under one 4 * or more contributor license agreements. See the NOTICE file 5 * distributed with this work for additional information 6 * regarding copyright ownership. The ASF licenses this file 7 * to you under the Apache License, Version 2.0 (the 8 * "License"); you may not use this file except in compliance 9 * with the License. You may obtain a copy of the License at 10 * 11 * http://www.apache.org/licenses/LICENSE-2.0 12 * 13 * Unless required by applicable law or agreed to in writing, 14 * software distributed under the License is distributed on an 15 * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY 16 * KIND, either express or implied. See the License for the 17 * specific language governing permissions and limitations 18 * under the License. 19 * 20 *************************************************************/ 21 22 23 24 // MARKER(update_precomp.py): autogen include statement, do not remove 25 #include "precompiled_connectivity.hxx" 26 #include "java/sql/DatabaseMetaData.hxx" 27 #include "java/sql/Connection.hxx" 28 #include "java/sql/ResultSet.hxx" 29 #include "java/tools.hxx" 30 #include "java/lang/String.hxx" 31 #include "connectivity/CommonTools.hxx" 32 #include "FDatabaseMetaDataResultSet.hxx" 33 #include <comphelper/types.hxx> 34 #include "TPrivilegesResultSet.hxx" 35 #include "diagnose_ex.h" 36 #include "resource/jdbc_log.hrc" 37 38 using namespace ::comphelper; 39 40 using namespace connectivity; 41 using namespace ::com::sun::star::uno; 42 using namespace ::com::sun::star::beans; 43 using namespace ::com::sun::star::sdbc; 44 using namespace ::com::sun::star::container; 45 using namespace ::com::sun::star::lang; 46 47 //************************************************************** 48 //************ Class: java.sql.DatabaseMetaData 49 //************************************************************** 50 51 jclass java_sql_DatabaseMetaData::theClass = 0; 52 53 java_sql_DatabaseMetaData::~java_sql_DatabaseMetaData() 54 { 55 SDBThreadAttach::releaseRef(); 56 } 57 58 jclass java_sql_DatabaseMetaData::getMyClass() const 59 { 60 // die Klasse muss nur einmal geholt werden, daher statisch 61 if( !theClass ) 62 theClass = findMyClass("java/sql/DatabaseMetaData"); 63 return theClass; 64 } 65 // ----------------------------------------------------------------------------- 66 java_sql_DatabaseMetaData::java_sql_DatabaseMetaData( JNIEnv * pEnv, jobject myObj, java_sql_Connection& _rConnection ) 67 :ODatabaseMetaDataBase( &_rConnection,_rConnection.getConnectionInfo() ) 68 ,java_lang_Object( pEnv, myObj ) 69 ,m_pConnection( &_rConnection ) 70 ,m_aLogger( _rConnection.getLogger() ) 71 { 72 SDBThreadAttach::addRef(); 73 } 74 75 // ------------------------------------------------------------------------- 76 Reference< XResultSet > java_sql_DatabaseMetaData::impl_getTypeInfo_throw( ) 77 { 78 static jmethodID mID(NULL); 79 return impl_callResultSetMethod( "getTypeInfo", mID ); 80 } 81 // ------------------------------------------------------------------------- 82 Reference< XResultSet > SAL_CALL java_sql_DatabaseMetaData::getCatalogs( ) throw(SQLException, RuntimeException) 83 { 84 static jmethodID mID(NULL); 85 return impl_callResultSetMethod( "getCatalogs", mID ); 86 } 87 // ------------------------------------------------------------------------- 88 ::rtl::OUString java_sql_DatabaseMetaData::impl_getCatalogSeparator_throw( ) 89 { 90 static jmethodID mID(NULL); 91 return impl_callStringMethod( "getCatalogSeparator", mID ); 92 } 93 // ------------------------------------------------------------------------- 94 Reference< XResultSet > SAL_CALL java_sql_DatabaseMetaData::getSchemas( ) throw(SQLException, RuntimeException) 95 { 96 static jmethodID mID(NULL); 97 return impl_callResultSetMethod( "getSchemas", mID ); 98 } 99 // ------------------------------------------------------------------------- 100 Reference< XResultSet > SAL_CALL java_sql_DatabaseMetaData::getColumnPrivileges( 101 const Any& catalog, const ::rtl::OUString& schema, const ::rtl::OUString& table, const ::rtl::OUString& columnNamePattern ) throw(SQLException, RuntimeException) 102 { 103 static jmethodID mID(NULL); 104 return impl_callResultSetMethodWithStrings( "getColumnPrivileges", mID, catalog, schema, table, &columnNamePattern ); 105 } 106 // ------------------------------------------------------------------------- 107 Reference< XResultSet > SAL_CALL java_sql_DatabaseMetaData::getColumns( 108 const Any& catalog, const ::rtl::OUString& schemaPattern, const ::rtl::OUString& tableNamePattern, const ::rtl::OUString& columnNamePattern ) throw(SQLException, RuntimeException) 109 { 110 static jmethodID mID(NULL); 111 return impl_callResultSetMethodWithStrings( "getColumns", mID, catalog, schemaPattern, tableNamePattern, &columnNamePattern ); 112 } 113 114 // ------------------------------------------------------------------------- 115 Reference< XResultSet > SAL_CALL java_sql_DatabaseMetaData::getTables( 116 const Any& catalog, const ::rtl::OUString& schemaPattern, const ::rtl::OUString& tableNamePattern, const Sequence< ::rtl::OUString >& _types ) throw(SQLException, RuntimeException) 117 { 118 static const char * cSignature = "(Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;[Ljava/lang/String;)Ljava/sql/ResultSet;"; 119 static const char * cMethodName = "getTables"; 120 121 m_aLogger.log( LogLevel::FINEST, STR_LOG_META_DATA_METHOD, cMethodName ); 122 123 jobject out(0); 124 SDBThreadAttach t; OSL_ENSURE(t.pEnv,"Java Enviroment geloescht worden!"); 125 126 { 127 // Java-Call absetzen 128 static jmethodID mID(NULL); 129 obtainMethodId(t.pEnv, cMethodName,cSignature, mID); 130 OSL_VERIFY_RES( !isExceptionOccured(t.pEnv,sal_True),"Exception occured!"); 131 jvalue args[4]; 132 133 args[3].l = 0; 134 sal_Int32 typeFilterCount = _types.getLength(); 135 if ( typeFilterCount ) 136 { 137 jobjectArray pObjArray = static_cast< jobjectArray >( t.pEnv->NewObjectArray( (jsize)typeFilterCount, java_lang_String::st_getMyClass(), 0 ) ); 138 OSL_VERIFY_RES( !isExceptionOccured( t.pEnv, sal_True ), "Exception occured!" ); 139 const ::rtl::OUString* typeFilter = _types.getConstArray(); 140 bool bIncludeAllTypes = false; 141 for ( sal_Int32 i=0; i<typeFilterCount; ++i, ++typeFilter ) 142 { 143 if ( typeFilter->equalsAsciiL( "%", 1 ) ) 144 { 145 bIncludeAllTypes = true; 146 break; 147 } 148 jstring aT = convertwchar_tToJavaString( t.pEnv, *typeFilter ); 149 t.pEnv->SetObjectArrayElement( pObjArray, (jsize)i, aT ); 150 OSL_VERIFY_RES( !isExceptionOccured( t.pEnv, sal_True ), "Exception occured!" ); 151 } 152 153 if ( bIncludeAllTypes ) 154 { 155 // the SDBC API allows to pass "%" as table type filter, but in JDBC, "all table types" 156 // is represented by the table type being <null/> 157 t.pEnv->DeleteLocalRef( pObjArray ); 158 OSL_VERIFY_RES( !isExceptionOccured( t.pEnv, sal_True ), "Exception occured!" ); 159 } 160 else 161 { 162 args[3].l = pObjArray; 163 } 164 } 165 // if we are to display "all catalogs", then respect m_aCatalogRestriction 166 Any aCatalogFilter( catalog ); 167 if ( !aCatalogFilter.hasValue() ) 168 aCatalogFilter = m_pConnection->getCatalogRestriction(); 169 // similar for schema 170 Any aSchemaFilter; 171 if ( schemaPattern.equalsAsciiL( "%", 1 ) ) 172 aSchemaFilter = m_pConnection->getSchemaRestriction(); 173 else 174 aSchemaFilter <<= schemaPattern; 175 176 args[0].l = aCatalogFilter.hasValue() ? convertwchar_tToJavaString( t.pEnv, ::comphelper::getString( aCatalogFilter ) ) : NULL; 177 args[1].l = aSchemaFilter.hasValue() ? convertwchar_tToJavaString( t.pEnv, ::comphelper::getString( aSchemaFilter ) ) : NULL; 178 args[2].l = convertwchar_tToJavaString(t.pEnv,tableNamePattern); 179 out = t.pEnv->CallObjectMethod( object, mID, args[0].l, args[1].l,args[2].l,args[3].l); 180 jthrowable jThrow = t.pEnv->ExceptionOccurred(); 181 if ( jThrow ) 182 t.pEnv->ExceptionClear();// we have to clear the exception here because we want to handle it below 183 if ( aCatalogFilter.hasValue() ) 184 { 185 t.pEnv->DeleteLocalRef((jstring)args[0].l); 186 OSL_VERIFY_RES( !isExceptionOccured( t.pEnv, sal_True ), "Exception occured!" ); 187 } 188 if(args[1].l) 189 { 190 t.pEnv->DeleteLocalRef((jstring)args[1].l); 191 OSL_VERIFY_RES( !isExceptionOccured( t.pEnv, sal_True ), "Exception occured!" ); 192 } 193 if(tableNamePattern.getLength()) 194 { 195 t.pEnv->DeleteLocalRef((jstring)args[2].l); 196 OSL_VERIFY_RES( !isExceptionOccured( t.pEnv, sal_True ), "Exception occured!" ); 197 } 198 //for(INT16 i=0;i<len;i++) 199 if ( args[3].l ) 200 { 201 t.pEnv->DeleteLocalRef( (jobjectArray)args[3].l ); 202 OSL_VERIFY_RES( !isExceptionOccured( t.pEnv, sal_True ), "Exception occured!" ); 203 } 204 205 if ( jThrow ) 206 { 207 if ( t.pEnv->IsInstanceOf( jThrow,java_sql_SQLException_BASE::st_getMyClass() ) ) 208 { 209 java_sql_SQLException_BASE* pException = new java_sql_SQLException_BASE( t.pEnv, jThrow ); 210 SQLException e( pException->getMessage(), 211 *this, 212 pException->getSQLState(), 213 pException->getErrorCode(), 214 Any() 215 ); 216 delete pException; 217 throw e; 218 } 219 } 220 } 221 222 if ( !out ) 223 return NULL; 224 225 m_aLogger.log( LogLevel::FINEST, STR_LOG_META_DATA_SUCCESS, cMethodName ); 226 return new java_sql_ResultSet( t.pEnv, out, m_aLogger,*m_pConnection); 227 } 228 // ------------------------------------------------------------------------- 229 Reference< XResultSet > SAL_CALL java_sql_DatabaseMetaData::getProcedureColumns( 230 const Any& catalog, const ::rtl::OUString& schemaPattern, const ::rtl::OUString& procedureNamePattern, const ::rtl::OUString& columnNamePattern ) throw(SQLException, RuntimeException) 231 { 232 static jmethodID mID(NULL); 233 return impl_callResultSetMethodWithStrings( "getProcedureColumns", mID, catalog, schemaPattern, procedureNamePattern, &columnNamePattern ); 234 } 235 // ------------------------------------------------------------------------- 236 Reference< XResultSet > SAL_CALL java_sql_DatabaseMetaData::getProcedures( const Any& 237 catalog, const ::rtl::OUString& schemaPattern, const ::rtl::OUString& procedureNamePattern ) throw(SQLException, RuntimeException) 238 { 239 static jmethodID mID(NULL); 240 return impl_callResultSetMethodWithStrings( "getProcedures", mID, catalog, schemaPattern, procedureNamePattern ); 241 } 242 // ------------------------------------------------------------------------- 243 Reference< XResultSet > SAL_CALL java_sql_DatabaseMetaData::getVersionColumns( 244 const Any& catalog, const ::rtl::OUString& schema, const ::rtl::OUString& table ) throw(SQLException, RuntimeException) 245 { 246 static jmethodID mID(NULL); 247 return impl_callResultSetMethodWithStrings( "getVersionColumns", mID, catalog, schema, table ); 248 } 249 // ------------------------------------------------------------------------- 250 sal_Int32 SAL_CALL java_sql_DatabaseMetaData::getMaxBinaryLiteralLength( ) throw(SQLException, RuntimeException) 251 { 252 static jmethodID mID(NULL); 253 return impl_callIntMethod( "getMaxBinaryLiteralLength", mID ); 254 } 255 // ------------------------------------------------------------------------- 256 sal_Int32 SAL_CALL java_sql_DatabaseMetaData::getMaxRowSize( ) throw(SQLException, RuntimeException) 257 { 258 static jmethodID mID(NULL); 259 return impl_callIntMethod( "getMaxRowSize", mID ); 260 } 261 // ------------------------------------------------------------------------- 262 sal_Int32 SAL_CALL java_sql_DatabaseMetaData::getMaxCatalogNameLength( ) throw(SQLException, RuntimeException) 263 { 264 static jmethodID mID(NULL); 265 return impl_callIntMethod( "getMaxCatalogNameLength", mID ); 266 } 267 // ------------------------------------------------------------------------- 268 sal_Int32 SAL_CALL java_sql_DatabaseMetaData::getMaxCharLiteralLength( ) throw(SQLException, RuntimeException) 269 { 270 static jmethodID mID(NULL); 271 return impl_callIntMethod( "getMaxCharLiteralLength", mID ); 272 } 273 // ------------------------------------------------------------------------- 274 sal_Int32 SAL_CALL java_sql_DatabaseMetaData::getMaxColumnNameLength( ) throw(SQLException, RuntimeException) 275 { 276 static jmethodID mID(NULL); 277 return impl_callIntMethod( "getMaxColumnNameLength", mID ); 278 } 279 // ------------------------------------------------------------------------- 280 sal_Int32 SAL_CALL java_sql_DatabaseMetaData::getMaxColumnsInIndex( ) throw(SQLException, RuntimeException) 281 { 282 static jmethodID mID(NULL); 283 return impl_callIntMethod( "getMaxColumnsInIndex", mID ); 284 } 285 // ------------------------------------------------------------------------- 286 sal_Int32 SAL_CALL java_sql_DatabaseMetaData::getMaxCursorNameLength( ) throw(SQLException, RuntimeException) 287 { 288 static jmethodID mID(NULL); 289 return impl_callIntMethod( "getMaxCursorNameLength", mID ); 290 } 291 // ------------------------------------------------------------------------- 292 sal_Int32 SAL_CALL java_sql_DatabaseMetaData::getMaxConnections( ) throw(SQLException, RuntimeException) 293 { 294 static jmethodID mID(NULL); 295 return impl_callIntMethod( "getMaxConnections", mID ); 296 } 297 // ------------------------------------------------------------------------- 298 sal_Int32 SAL_CALL java_sql_DatabaseMetaData::getMaxColumnsInTable( ) throw(SQLException, RuntimeException) 299 { 300 static jmethodID mID(NULL); 301 return impl_callIntMethod( "getMaxColumnsInTable", mID ); 302 } 303 // ------------------------------------------------------------------------- 304 sal_Int32 SAL_CALL java_sql_DatabaseMetaData::getMaxStatementLength( ) throw(SQLException, RuntimeException) 305 { 306 static jmethodID mID(NULL); 307 return impl_callIntMethod( "getMaxStatementLength", mID ); 308 } 309 // ------------------------------------------------------------------------- 310 sal_Int32 SAL_CALL java_sql_DatabaseMetaData::getMaxTableNameLength( ) throw(SQLException, RuntimeException) 311 { 312 static jmethodID mID(NULL); 313 return impl_callIntMethod( "getMaxTableNameLength", mID ); 314 } 315 // ------------------------------------------------------------------------- 316 sal_Int32 java_sql_DatabaseMetaData::impl_getMaxTablesInSelect_throw( ) 317 { 318 static jmethodID mID(NULL); 319 return impl_callIntMethod( "getMaxTablesInSelect", mID ); 320 } 321 // ------------------------------------------------------------------------- 322 Reference< XResultSet > SAL_CALL java_sql_DatabaseMetaData::getExportedKeys( 323 const Any& catalog, const ::rtl::OUString& schema, const ::rtl::OUString& table ) throw(SQLException, RuntimeException) 324 { 325 static jmethodID mID(NULL); 326 return impl_callResultSetMethodWithStrings( "getExportedKeys", mID, catalog, schema, table ); 327 } 328 // ------------------------------------------------------------------------- 329 Reference< XResultSet > SAL_CALL java_sql_DatabaseMetaData::getImportedKeys( 330 const Any& catalog, const ::rtl::OUString& schema, const ::rtl::OUString& table ) throw(SQLException, RuntimeException) 331 { 332 static jmethodID mID(NULL); 333 return impl_callResultSetMethodWithStrings( "getImportedKeys", mID, catalog, schema, table ); 334 } 335 // ------------------------------------------------------------------------- 336 Reference< XResultSet > SAL_CALL java_sql_DatabaseMetaData::getPrimaryKeys( 337 const Any& catalog, const ::rtl::OUString& schema, const ::rtl::OUString& table ) throw(SQLException, RuntimeException) 338 { 339 static jmethodID mID(NULL); 340 return impl_callResultSetMethodWithStrings( "getPrimaryKeys", mID, catalog, schema, table ); 341 } 342 // ------------------------------------------------------------------------- 343 Reference< XResultSet > SAL_CALL java_sql_DatabaseMetaData::getIndexInfo( 344 const Any& catalog, const ::rtl::OUString& schema, const ::rtl::OUString& table, 345 sal_Bool unique, sal_Bool approximate ) throw(SQLException, RuntimeException) 346 { 347 static const char * cSignature = "(Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;ZZ)Ljava/sql/ResultSet;"; 348 static const char * cMethodName = "getIndexInfo"; 349 350 m_aLogger.log( LogLevel::FINEST, STR_LOG_META_DATA_METHOD, cMethodName ); 351 352 jobject out(0); 353 SDBThreadAttach t; OSL_ENSURE(t.pEnv,"Java Enviroment geloescht worden!"); 354 355 { 356 // Java-Call absetzen 357 static jmethodID mID(NULL); 358 obtainMethodId(t.pEnv, cMethodName,cSignature, mID); 359 jvalue args[5]; 360 // Parameter konvertieren 361 args[0].l = catalog.hasValue() ? convertwchar_tToJavaString(t.pEnv,comphelper::getString(catalog)) : 0; 362 args[1].l = schema.toChar() == '%' ? NULL : convertwchar_tToJavaString(t.pEnv,schema); 363 args[2].l = convertwchar_tToJavaString(t.pEnv,table); 364 args[3].z = unique; 365 args[4].z = approximate; 366 out = t.pEnv->CallObjectMethod( object, mID, args[0].l,args[1].l,args[2].l,args[3].z,args[4].z ); 367 368 // und aufraeumen 369 if(catalog.hasValue()) 370 t.pEnv->DeleteLocalRef((jstring)args[0].l); 371 if(args[1].l) 372 t.pEnv->DeleteLocalRef((jstring)args[1].l); 373 if(table.getLength()) 374 t.pEnv->DeleteLocalRef((jstring)args[2].l); 375 ThrowLoggedSQLException( m_aLogger, t.pEnv, *this ); 376 } 377 if ( !out ) 378 return NULL; 379 380 m_aLogger.log( LogLevel::FINEST, STR_LOG_META_DATA_SUCCESS, cMethodName ); 381 return new java_sql_ResultSet( t.pEnv, out, m_aLogger,*m_pConnection); 382 } 383 // ------------------------------------------------------------------------- 384 Reference< XResultSet > SAL_CALL java_sql_DatabaseMetaData::getBestRowIdentifier( 385 const Any& catalog, const ::rtl::OUString& schema, const ::rtl::OUString& table, sal_Int32 scope, 386 sal_Bool nullable ) throw(SQLException, RuntimeException) 387 { 388 static const char * cSignature = "(Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;IZ)Ljava/sql/ResultSet;"; 389 static const char * cMethodName = "getBestRowIdentifier"; 390 391 m_aLogger.log( LogLevel::FINEST, STR_LOG_META_DATA_METHOD, cMethodName ); 392 393 jobject out(0); 394 SDBThreadAttach t; OSL_ENSURE(t.pEnv,"Java Enviroment geloescht worden!"); 395 396 { 397 // Java-Call absetzen 398 static jmethodID mID(NULL); 399 obtainMethodId(t.pEnv, cMethodName,cSignature, mID); 400 jvalue args[3]; 401 // Parameter konvertieren 402 args[0].l = catalog.hasValue() ? convertwchar_tToJavaString(t.pEnv,comphelper::getString(catalog)) : 0; 403 args[1].l = schema.toChar() == '%' ? NULL : convertwchar_tToJavaString(t.pEnv,schema); 404 args[2].l = convertwchar_tToJavaString(t.pEnv,table); 405 out = t.pEnv->CallObjectMethod( object, mID, args[0].l,args[1].l,args[2].l,scope,nullable); 406 407 // und aufraeumen 408 if(catalog.hasValue()) 409 t.pEnv->DeleteLocalRef((jstring)args[0].l); 410 if(args[1].l) 411 t.pEnv->DeleteLocalRef((jstring)args[1].l); 412 if(table.getLength()) 413 t.pEnv->DeleteLocalRef((jstring)args[2].l); 414 ThrowLoggedSQLException( m_aLogger, t.pEnv, *this ); 415 } 416 417 if ( !out ) 418 return NULL; 419 420 m_aLogger.log( LogLevel::FINEST, STR_LOG_META_DATA_SUCCESS, cMethodName ); 421 return new java_sql_ResultSet( t.pEnv, out, m_aLogger,*m_pConnection); 422 } 423 // ------------------------------------------------------------------------- 424 Reference< XResultSet > SAL_CALL java_sql_DatabaseMetaData::getTablePrivileges( 425 const Any& catalog, const ::rtl::OUString& schemaPattern, const ::rtl::OUString& tableNamePattern ) throw(SQLException, RuntimeException) 426 { 427 if ( m_pConnection->isIgnoreDriverPrivilegesEnabled() ) 428 return new OResultSetPrivileges(this,catalog,schemaPattern,tableNamePattern); 429 430 static jmethodID mID(NULL); 431 Reference< XResultSet > xReturn( impl_callResultSetMethodWithStrings( "getTablePrivileges", mID, catalog, schemaPattern, tableNamePattern ) ); 432 433 if ( xReturn.is() ) 434 { 435 // we have to check the result columns for the tables privleges 436 // #106324# 437 Reference< XResultSetMetaDataSupplier > xMetaSup(xReturn,UNO_QUERY); 438 if ( xMetaSup.is() ) 439 { 440 Reference< XResultSetMetaData> xMeta = xMetaSup->getMetaData(); 441 if ( xMeta.is() && xMeta->getColumnCount() != 7 ) 442 { 443 // here we know that the count of column doesn't match 444 ::std::map<sal_Int32,sal_Int32> aColumnMatching; 445 static const ::rtl::OUString sPrivs[] = { 446 ::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("TABLE_CAT")), 447 ::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("TABLE_SCHEM")), 448 ::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("TABLE_NAME")), 449 ::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("GRANTOR")), 450 ::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("GRANTEE")), 451 ::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("PRIVILEGE")), 452 ::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("IS_GRANTABLE")) 453 }; 454 455 ::rtl::OUString sColumnName; 456 sal_Int32 nCount = xMeta->getColumnCount(); 457 for (sal_Int32 i = 1 ; i <= nCount ; ++i) 458 { 459 sColumnName = xMeta->getColumnName(i); 460 for (sal_uInt32 j = 0 ; j < sizeof(sPrivs)/sizeof(sPrivs[0]); ++j) 461 { 462 if ( sPrivs[j] == sColumnName ) 463 { 464 aColumnMatching.insert( ::std::map<sal_Int32,sal_Int32>::value_type(i,j+1) ); 465 break; 466 } 467 } 468 469 } 470 // fill our own resultset 471 ODatabaseMetaDataResultSet* pNewPrivRes = new ODatabaseMetaDataResultSet( ODatabaseMetaDataResultSet::eTablePrivileges ); 472 Reference< XResultSet > xTemp = xReturn; 473 xReturn = pNewPrivRes; 474 ODatabaseMetaDataResultSet::ORows aRows; 475 Reference< XRow > xRow(xTemp,UNO_QUERY); 476 ::rtl::OUString sValue; 477 478 ODatabaseMetaDataResultSet::ORow aRow(8); 479 while ( xRow.is() && xTemp->next() ) 480 { 481 ::std::map<sal_Int32,sal_Int32>::iterator aIter = aColumnMatching.begin(); 482 ::std::map<sal_Int32,sal_Int32>::iterator aEnd = aColumnMatching.end(); 483 for (;aIter != aEnd ; ++aIter) 484 { 485 sValue = xRow->getString(aIter->first); 486 if ( xRow->wasNull() ) 487 aRow[aIter->second] = ODatabaseMetaDataResultSet::getEmptyValue(); 488 else 489 aRow[aIter->second] = new ORowSetValueDecorator(sValue); 490 } 491 492 aRows.push_back(aRow); 493 } 494 pNewPrivRes->setRows(aRows); 495 } 496 } 497 } 498 return xReturn; 499 } 500 // ------------------------------------------------------------------------- 501 Reference< XResultSet > SAL_CALL java_sql_DatabaseMetaData::getCrossReference( 502 const Any& primaryCatalog, const ::rtl::OUString& primarySchema, 503 const ::rtl::OUString& primaryTable, const Any& foreignCatalog, 504 const ::rtl::OUString& foreignSchema, const ::rtl::OUString& foreignTable ) throw(SQLException, RuntimeException) 505 { 506 static const char * cSignature = "(Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;)Ljava/sql/ResultSet;"; 507 static const char * cMethodName = "getCrossReference"; 508 m_aLogger.log( LogLevel::FINEST, STR_LOG_META_DATA_METHOD, cMethodName ); 509 510 jobject out(0); 511 SDBThreadAttach t; OSL_ENSURE(t.pEnv,"Java Enviroment geloescht worden!"); 512 { 513 514 // Java-Call absetzen 515 static jmethodID mID(NULL); 516 obtainMethodId(t.pEnv, cMethodName,cSignature, mID); 517 jvalue args[6]; 518 // Parameter konvertieren 519 args[0].l = primaryCatalog.hasValue() ? convertwchar_tToJavaString(t.pEnv,comphelper::getString(primaryCatalog)) : 0; 520 args[1].l = primarySchema.toChar() == '%' ? NULL : convertwchar_tToJavaString(t.pEnv,primarySchema); 521 args[2].l = convertwchar_tToJavaString(t.pEnv,primaryTable); 522 args[3].l = foreignCatalog.hasValue() ? convertwchar_tToJavaString(t.pEnv,comphelper::getString(foreignCatalog)) : 0; 523 args[4].l = foreignSchema.toChar() == '%' ? NULL : convertwchar_tToJavaString(t.pEnv,foreignSchema); 524 args[5].l = convertwchar_tToJavaString(t.pEnv,foreignTable); 525 out = t.pEnv->CallObjectMethod( object, mID, args[0].l,args[2].l,args[2].l,args[3].l,args[4].l,args[5].l ); 526 527 // und aufraeumen 528 if(primaryCatalog.hasValue()) 529 t.pEnv->DeleteLocalRef((jstring)args[0].l); 530 if(args[1].l) 531 t.pEnv->DeleteLocalRef((jstring)args[1].l); 532 if(primaryTable.getLength()) 533 t.pEnv->DeleteLocalRef((jstring)args[2].l); 534 if(foreignCatalog.hasValue()) 535 t.pEnv->DeleteLocalRef((jstring)args[3].l); 536 if(args[4].l) 537 t.pEnv->DeleteLocalRef((jstring)args[4].l); 538 if(foreignTable.getLength()) 539 t.pEnv->DeleteLocalRef((jstring)args[5].l); 540 ThrowLoggedSQLException( m_aLogger, t.pEnv, *this ); 541 } 542 543 if ( !out ) 544 return NULL; 545 546 m_aLogger.log( LogLevel::FINEST, STR_LOG_META_DATA_SUCCESS, cMethodName ); 547 return new java_sql_ResultSet( t.pEnv, out, m_aLogger,*m_pConnection); 548 } 549 550 // ------------------------------------------------------------------------- 551 sal_Bool java_sql_DatabaseMetaData::impl_callBooleanMethod( const char* _pMethodName, jmethodID& _inout_MethodID ) 552 { 553 m_aLogger.log( LogLevel::FINEST, STR_LOG_META_DATA_METHOD, _pMethodName ); 554 jboolean out( java_lang_Object::callBooleanMethod(_pMethodName,_inout_MethodID) ); 555 m_aLogger.log< const sal_Char*, sal_Int16>( LogLevel::FINEST, STR_LOG_META_DATA_RESULT, _pMethodName, out ); 556 return out; 557 } 558 559 // ------------------------------------------------------------------------- 560 ::rtl::OUString java_sql_DatabaseMetaData::impl_callStringMethod( const char* _pMethodName, jmethodID& _inout_MethodID ) 561 { 562 m_aLogger.log( LogLevel::FINEST, STR_LOG_META_DATA_METHOD, _pMethodName ); 563 564 const ::rtl::OUString sReturn( callStringMethod(_pMethodName,_inout_MethodID) ); 565 if ( m_aLogger.isLoggable( LogLevel::FINEST ) ) 566 { 567 ::rtl::OUString sLoggedResult( sReturn ); 568 if ( !sLoggedResult.getLength() ) 569 sLoggedResult = ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "<empty string>" ) ); 570 m_aLogger.log( LogLevel::FINEST, STR_LOG_META_DATA_RESULT, _pMethodName, sLoggedResult ); 571 } 572 573 return sReturn; 574 } 575 576 // ------------------------------------------------------------------------- 577 sal_Int32 java_sql_DatabaseMetaData::impl_callIntMethod( const char* _pMethodName, jmethodID& _inout_MethodID ) 578 { 579 m_aLogger.log( LogLevel::FINEST, STR_LOG_META_DATA_METHOD, _pMethodName ); 580 sal_Int32 out( (sal_Int32)callIntMethod(_pMethodName,_inout_MethodID) ); 581 m_aLogger.log( LogLevel::FINEST, STR_LOG_META_DATA_RESULT, _pMethodName, (sal_Int32)out ); 582 return out; 583 } 584 585 // ------------------------------------------------------------------------- 586 sal_Bool java_sql_DatabaseMetaData::impl_callBooleanMethodWithIntArg( const char* _pMethodName, jmethodID& _inout_MethodID, sal_Int32 _nArgument ) 587 { 588 m_aLogger.log( LogLevel::FINEST, STR_LOG_META_DATA_METHOD_ARG1, _pMethodName, _nArgument ); 589 590 jboolean out( callBooleanMethodWithIntArg(_pMethodName,_inout_MethodID,_nArgument) ); 591 592 m_aLogger.log< const sal_Char*, sal_Int16 >( LogLevel::FINEST, STR_LOG_META_DATA_RESULT, _pMethodName, out ); 593 return out; 594 } 595 596 // ------------------------------------------------------------------------- 597 Reference< XResultSet > java_sql_DatabaseMetaData::impl_callResultSetMethod( const char* _pMethodName, jmethodID& _inout_MethodID ) 598 { 599 SDBThreadAttach t; 600 m_aLogger.log( LogLevel::FINEST, STR_LOG_META_DATA_METHOD, _pMethodName ); 601 jobject out(callResultSetMethod(t.env(),_pMethodName,_inout_MethodID)); 602 m_aLogger.log( LogLevel::FINEST, STR_LOG_META_DATA_SUCCESS, _pMethodName ); 603 return new java_sql_ResultSet( t.pEnv, out, m_aLogger,*m_pConnection); 604 } 605 606 // ------------------------------------------------------------------------- 607 Reference< XResultSet > java_sql_DatabaseMetaData::impl_callResultSetMethodWithStrings( const char* _pMethodName, jmethodID& _inout_MethodID, 608 const Any& _rCatalog, const ::rtl::OUString& _rSchemaPattern, const ::rtl::OUString& _rLeastPattern, 609 const ::rtl::OUString* _pOptionalAdditionalString ) 610 { 611 bool bCatalog = _rCatalog.hasValue(); 612 ::rtl::OUString sCatalog; 613 _rCatalog >>= sCatalog; 614 615 bool bSchema = _rSchemaPattern.toChar() != '%'; 616 617 // log the call 618 if ( m_aLogger.isLoggable( LogLevel::FINEST ) ) 619 { 620 ::rtl::OUString sCatalogLog = bCatalog ? sCatalog : ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "null" ) ); 621 ::rtl::OUString sSchemaLog = bSchema ? _rSchemaPattern : ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "null" ) ); 622 if ( _pOptionalAdditionalString ) 623 m_aLogger.log( LogLevel::FINEST, STR_LOG_META_DATA_METHOD_ARG4, _pMethodName, sCatalogLog, sSchemaLog, _rLeastPattern, *_pOptionalAdditionalString ); 624 else 625 m_aLogger.log( LogLevel::FINEST, STR_LOG_META_DATA_METHOD_ARG3, _pMethodName, sCatalogLog, sSchemaLog, _rLeastPattern ); 626 } 627 628 jobject out(0); 629 630 SDBThreadAttach t; 631 OSL_ENSURE( t.pEnv, "java_sql_DatabaseMetaData::impl_callResultSetMethodWithStrings: no Java enviroment anymore!" ); 632 633 { 634 const char* pSignature = _pOptionalAdditionalString 635 ? "(Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;)Ljava/sql/ResultSet;" 636 : "(Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;)Ljava/sql/ResultSet;"; 637 // obtain method ID 638 obtainMethodId(t.pEnv, _pMethodName,pSignature, _inout_MethodID); 639 640 // call method 641 642 { 643 jvalue args[4]; 644 // convert parameters 645 args[0].l = bCatalog ? convertwchar_tToJavaString( t.pEnv, sCatalog ) : NULL; 646 args[1].l = bSchema ? convertwchar_tToJavaString( t.pEnv, _rSchemaPattern ) : NULL; 647 args[2].l = convertwchar_tToJavaString( t.pEnv, _rLeastPattern ); 648 args[3].l = _pOptionalAdditionalString ? convertwchar_tToJavaString( t.pEnv, *_pOptionalAdditionalString ) : NULL; 649 650 // actually do the call 651 if ( _pOptionalAdditionalString ) 652 out = t.pEnv->CallObjectMethod( object, _inout_MethodID, args[0].l, args[1].l, args[2].l, args[3].l ); 653 else 654 out = t.pEnv->CallObjectMethod( object, _inout_MethodID, args[0].l, args[1].l, args[2].l ); 655 656 // clean up 657 if ( args[0].l ) 658 t.pEnv->DeleteLocalRef( (jstring)args[0].l ); 659 if ( args[1].l ) 660 t.pEnv->DeleteLocalRef( (jstring)args[1].l ); 661 if ( args[2].l ) 662 t.pEnv->DeleteLocalRef( (jstring)args[2].l ); 663 if ( args[3].l ) 664 t.pEnv->DeleteLocalRef( (jstring)args[3].l ); 665 666 ThrowLoggedSQLException( m_aLogger, t.pEnv, *this ); 667 } 668 } 669 670 if ( !out ) 671 return NULL; 672 673 m_aLogger.log( LogLevel::FINEST, STR_LOG_META_DATA_SUCCESS, _pMethodName ); 674 return new java_sql_ResultSet( t.pEnv, out, m_aLogger,*m_pConnection); 675 } 676 677 // ------------------------------------------------------------------------- 678 sal_Bool SAL_CALL java_sql_DatabaseMetaData::doesMaxRowSizeIncludeBlobs( ) throw(SQLException, RuntimeException) 679 { 680 static jmethodID mID(NULL); 681 return impl_callBooleanMethod( "doesMaxRowSizeIncludeBlobs", mID ); 682 } 683 // ------------------------------------------------------------------------- 684 sal_Bool SAL_CALL java_sql_DatabaseMetaData::storesLowerCaseQuotedIdentifiers( ) throw(SQLException, RuntimeException) 685 { 686 static jmethodID mID(NULL); 687 return impl_callBooleanMethod( "storesLowerCaseQuotedIdentifiers", mID ); 688 } 689 // ------------------------------------------------------------------------- 690 sal_Bool SAL_CALL java_sql_DatabaseMetaData::storesLowerCaseIdentifiers( ) throw(SQLException, RuntimeException) 691 { 692 static jmethodID mID(NULL); 693 return impl_callBooleanMethod( "storesLowerCaseIdentifiers", mID ); 694 } 695 // ------------------------------------------------------------------------- 696 sal_Bool java_sql_DatabaseMetaData::impl_storesMixedCaseQuotedIdentifiers_throw( ) 697 { 698 static jmethodID mID(NULL); 699 return impl_callBooleanMethod( "storesMixedCaseQuotedIdentifiers", mID ); 700 } 701 // ------------------------------------------------------------------------- 702 sal_Bool SAL_CALL java_sql_DatabaseMetaData::storesMixedCaseIdentifiers( ) throw(SQLException, RuntimeException) 703 { 704 static jmethodID mID(NULL); 705 return impl_callBooleanMethod( "storesMixedCaseIdentifiers", mID ); 706 } 707 // ------------------------------------------------------------------------- 708 sal_Bool SAL_CALL java_sql_DatabaseMetaData::storesUpperCaseQuotedIdentifiers( ) throw(SQLException, RuntimeException) 709 { 710 static jmethodID mID(NULL); 711 return impl_callBooleanMethod( "storesUpperCaseQuotedIdentifiers", mID ); 712 } 713 // ------------------------------------------------------------------------- 714 sal_Bool SAL_CALL java_sql_DatabaseMetaData::storesUpperCaseIdentifiers( ) throw(SQLException, RuntimeException) 715 { 716 static jmethodID mID(NULL); 717 return impl_callBooleanMethod( "storesUpperCaseIdentifiers", mID ); 718 } 719 // ------------------------------------------------------------------------- 720 sal_Bool java_sql_DatabaseMetaData::impl_supportsAlterTableWithAddColumn_throw( ) 721 { 722 static jmethodID mID(NULL); 723 return impl_callBooleanMethod( "supportsAlterTableWithAddColumn", mID ); 724 } 725 // ------------------------------------------------------------------------- 726 sal_Bool java_sql_DatabaseMetaData::impl_supportsAlterTableWithDropColumn_throw( ) 727 { 728 static jmethodID mID(NULL); 729 return impl_callBooleanMethod( "supportsAlterTableWithDropColumn", mID ); 730 } 731 // ------------------------------------------------------------------------- 732 sal_Int32 SAL_CALL java_sql_DatabaseMetaData::getMaxIndexLength( ) throw(SQLException, RuntimeException) 733 { 734 static jmethodID mID(NULL); 735 return impl_callIntMethod( "getMaxIndexLength", mID ); 736 } 737 // ------------------------------------------------------------------------- 738 sal_Bool SAL_CALL java_sql_DatabaseMetaData::supportsNonNullableColumns( ) throw(SQLException, RuntimeException) 739 { 740 static jmethodID mID(NULL); 741 return impl_callBooleanMethod( "supportsNonNullableColumns", mID ); 742 } 743 // ------------------------------------------------------------------------- 744 ::rtl::OUString SAL_CALL java_sql_DatabaseMetaData::getCatalogTerm( ) throw(SQLException, RuntimeException) 745 { 746 static jmethodID mID(NULL); 747 return impl_callStringMethod( "getCatalogTerm", mID ); 748 } 749 // ------------------------------------------------------------------------- 750 ::rtl::OUString java_sql_DatabaseMetaData::impl_getIdentifierQuoteString_throw( ) 751 { 752 static jmethodID mID(NULL); 753 return impl_callStringMethod( "getIdentifierQuoteString", mID ); 754 } 755 // ------------------------------------------------------------------------- 756 ::rtl::OUString SAL_CALL java_sql_DatabaseMetaData::getExtraNameCharacters( ) throw(SQLException, RuntimeException) 757 { 758 static jmethodID mID(NULL); 759 return impl_callStringMethod( "getExtraNameCharacters", mID ); 760 } 761 // ------------------------------------------------------------------------- 762 sal_Bool SAL_CALL java_sql_DatabaseMetaData::supportsDifferentTableCorrelationNames( ) throw(SQLException, RuntimeException) 763 { 764 static jmethodID mID(NULL); 765 return impl_callBooleanMethod( "supportsDifferentTableCorrelationNames", mID ); 766 } 767 // ------------------------------------------------------------------------- 768 sal_Bool java_sql_DatabaseMetaData::impl_isCatalogAtStart_throw( ) 769 { 770 static jmethodID mID(NULL); 771 return impl_callBooleanMethod( "isCatalogAtStart", mID ); 772 } 773 // ------------------------------------------------------------------------- 774 sal_Bool SAL_CALL java_sql_DatabaseMetaData::dataDefinitionIgnoredInTransactions( ) throw(SQLException, RuntimeException) 775 { 776 static jmethodID mID(NULL); 777 return impl_callBooleanMethod( "dataDefinitionIgnoredInTransactions", mID ); 778 } 779 // ------------------------------------------------------------------------- 780 sal_Bool SAL_CALL java_sql_DatabaseMetaData::dataDefinitionCausesTransactionCommit( ) throw(SQLException, RuntimeException) 781 { 782 static jmethodID mID(NULL); 783 return impl_callBooleanMethod( "dataDefinitionCausesTransactionCommit", mID ); 784 } 785 // ------------------------------------------------------------------------- 786 sal_Bool SAL_CALL java_sql_DatabaseMetaData::supportsDataManipulationTransactionsOnly( ) throw(SQLException, RuntimeException) 787 { 788 static jmethodID mID(NULL); 789 return impl_callBooleanMethod( "supportsDataManipulationTransactionsOnly", mID ); 790 } 791 // ------------------------------------------------------------------------- 792 sal_Bool SAL_CALL java_sql_DatabaseMetaData::supportsDataDefinitionAndDataManipulationTransactions( ) throw(SQLException, RuntimeException) 793 { 794 static jmethodID mID(NULL); 795 return impl_callBooleanMethod( "supportsDataDefinitionAndDataManipulationTransactions", mID ); 796 } 797 // ------------------------------------------------------------------------- 798 sal_Bool SAL_CALL java_sql_DatabaseMetaData::supportsPositionedDelete( ) throw(SQLException, RuntimeException) 799 { 800 static jmethodID mID(NULL); 801 return impl_callBooleanMethod( "supportsPositionedDelete", mID ); 802 } 803 // ------------------------------------------------------------------------- 804 sal_Bool SAL_CALL java_sql_DatabaseMetaData::supportsPositionedUpdate( ) throw(SQLException, RuntimeException) 805 { 806 static jmethodID mID(NULL); 807 return impl_callBooleanMethod( "supportsPositionedUpdate", mID ); 808 } 809 // ------------------------------------------------------------------------- 810 sal_Bool SAL_CALL java_sql_DatabaseMetaData::supportsOpenStatementsAcrossRollback( ) throw(SQLException, RuntimeException) 811 { 812 static jmethodID mID(NULL); 813 return impl_callBooleanMethod( "supportsOpenStatementsAcrossRollback", mID ); 814 } 815 // ------------------------------------------------------------------------- 816 sal_Bool SAL_CALL java_sql_DatabaseMetaData::supportsOpenStatementsAcrossCommit( ) throw(SQLException, RuntimeException) 817 { 818 static jmethodID mID(NULL); 819 return impl_callBooleanMethod( "supportsOpenStatementsAcrossCommit", mID ); 820 } 821 // ------------------------------------------------------------------------- 822 sal_Bool SAL_CALL java_sql_DatabaseMetaData::supportsOpenCursorsAcrossCommit( ) throw(SQLException, RuntimeException) 823 { 824 static jmethodID mID(NULL); 825 return impl_callBooleanMethod( "supportsOpenCursorsAcrossCommit", mID ); 826 } 827 // ------------------------------------------------------------------------- 828 sal_Bool SAL_CALL java_sql_DatabaseMetaData::supportsOpenCursorsAcrossRollback( ) throw(SQLException, RuntimeException) 829 { 830 static jmethodID mID(NULL); 831 return impl_callBooleanMethod( "supportsOpenCursorsAcrossRollback", mID ); 832 } 833 // ------------------------------------------------------------------------- 834 sal_Bool SAL_CALL java_sql_DatabaseMetaData::supportsTransactionIsolationLevel( sal_Int32 level ) throw(SQLException, RuntimeException) 835 { 836 static jmethodID mID(NULL); 837 return impl_callBooleanMethodWithIntArg( "supportsTransactionIsolationLevel", mID, level ); 838 } 839 // ------------------------------------------------------------------------- 840 sal_Bool java_sql_DatabaseMetaData::impl_supportsSchemasInDataManipulation_throw( ) 841 { 842 static jmethodID mID(NULL); 843 return impl_callBooleanMethod( "supportsSchemasInDataManipulation", mID ); 844 } 845 // ------------------------------------------------------------------------- 846 sal_Bool SAL_CALL java_sql_DatabaseMetaData::supportsANSI92FullSQL( ) throw(SQLException, RuntimeException) 847 { 848 static jmethodID mID(NULL); 849 return impl_callBooleanMethod( "supportsANSI92FullSQL", mID ); 850 } 851 // ------------------------------------------------------------------------- 852 sal_Bool SAL_CALL java_sql_DatabaseMetaData::supportsANSI92EntryLevelSQL( ) throw(SQLException, RuntimeException) 853 { 854 static jmethodID mID(NULL); 855 return impl_callBooleanMethod( "supportsANSI92EntryLevelSQL", mID ); 856 } 857 // ------------------------------------------------------------------------- 858 sal_Bool SAL_CALL java_sql_DatabaseMetaData::supportsIntegrityEnhancementFacility( ) throw(SQLException, RuntimeException) 859 { 860 static jmethodID mID(NULL); 861 return impl_callBooleanMethod( "supportsIntegrityEnhancementFacility", mID ); 862 } 863 // ------------------------------------------------------------------------- 864 sal_Bool SAL_CALL java_sql_DatabaseMetaData::supportsSchemasInIndexDefinitions( ) throw(SQLException, RuntimeException) 865 { 866 static jmethodID mID(NULL); 867 return impl_callBooleanMethod( "supportsSchemasInIndexDefinitions", mID ); 868 } 869 // ------------------------------------------------------------------------- 870 sal_Bool java_sql_DatabaseMetaData::impl_supportsSchemasInTableDefinitions_throw( ) 871 { 872 static jmethodID mID(NULL); 873 return impl_callBooleanMethod( "supportsSchemasInTableDefinitions", mID ); 874 } 875 // ------------------------------------------------------------------------- 876 sal_Bool java_sql_DatabaseMetaData::impl_supportsCatalogsInTableDefinitions_throw( ) 877 { 878 static jmethodID mID(NULL); 879 return impl_callBooleanMethod( "supportsCatalogsInTableDefinitions", mID ); 880 } 881 // ------------------------------------------------------------------------- 882 sal_Bool SAL_CALL java_sql_DatabaseMetaData::supportsCatalogsInIndexDefinitions( ) throw(SQLException, RuntimeException) 883 { 884 static jmethodID mID(NULL); 885 return impl_callBooleanMethod( "supportsCatalogsInIndexDefinitions", mID ); 886 } 887 // ------------------------------------------------------------------------- 888 sal_Bool java_sql_DatabaseMetaData::impl_supportsCatalogsInDataManipulation_throw( ) 889 { 890 static jmethodID mID(NULL); 891 return impl_callBooleanMethod( "supportsCatalogsInDataManipulation", mID ); 892 } 893 // ------------------------------------------------------------------------- 894 sal_Bool SAL_CALL java_sql_DatabaseMetaData::supportsOuterJoins( ) throw(SQLException, RuntimeException) 895 { 896 static jmethodID mID(NULL); 897 return impl_callBooleanMethod( "supportsOuterJoins", mID ); 898 } 899 // ------------------------------------------------------------------------- 900 Reference< XResultSet > SAL_CALL java_sql_DatabaseMetaData::getTableTypes( ) throw(SQLException, RuntimeException) 901 { 902 static jmethodID mID(NULL); 903 return impl_callResultSetMethod( "getTableTypes", mID ); 904 } 905 // ------------------------------------------------------------------------- 906 sal_Int32 java_sql_DatabaseMetaData::impl_getMaxStatements_throw( ) 907 { 908 static jmethodID mID(NULL); 909 return impl_callIntMethod( "getMaxStatements", mID ); 910 } 911 // ------------------------------------------------------------------------- 912 sal_Int32 SAL_CALL java_sql_DatabaseMetaData::getMaxProcedureNameLength( ) throw(SQLException, RuntimeException) 913 { 914 static jmethodID mID(NULL); 915 return impl_callIntMethod( "getMaxProcedureNameLength", mID ); 916 } 917 // ------------------------------------------------------------------------- 918 sal_Int32 SAL_CALL java_sql_DatabaseMetaData::getMaxSchemaNameLength( ) throw(SQLException, RuntimeException) 919 { 920 static jmethodID mID(NULL); 921 return impl_callIntMethod( "getMaxSchemaNameLength", mID ); 922 } 923 // ------------------------------------------------------------------------- 924 sal_Bool SAL_CALL java_sql_DatabaseMetaData::supportsTransactions( ) throw(SQLException, RuntimeException) 925 { 926 static jmethodID mID(NULL); 927 return impl_callBooleanMethod( "supportsTransactions", mID ); 928 } 929 930 // ------------------------------------------------------------------------- 931 sal_Bool SAL_CALL java_sql_DatabaseMetaData::allProceduresAreCallable( ) throw(SQLException, RuntimeException) 932 { 933 static jmethodID mID(NULL); 934 return impl_callBooleanMethod( "allProceduresAreCallable", mID ); 935 } 936 // ------------------------------------------------------------------------- 937 sal_Bool SAL_CALL java_sql_DatabaseMetaData::supportsStoredProcedures( ) throw(SQLException, RuntimeException) 938 { 939 static jmethodID mID(NULL); 940 return impl_callBooleanMethod( "supportsStoredProcedures", mID ); 941 } 942 // ------------------------------------------------------------------------- 943 sal_Bool SAL_CALL java_sql_DatabaseMetaData::supportsSelectForUpdate( ) throw(SQLException, RuntimeException) 944 { 945 static jmethodID mID(NULL); 946 return impl_callBooleanMethod( "supportsSelectForUpdate", mID ); 947 } 948 // ------------------------------------------------------------------------- 949 sal_Bool SAL_CALL java_sql_DatabaseMetaData::allTablesAreSelectable( ) throw(SQLException, RuntimeException) 950 { 951 static jmethodID mID(NULL); 952 return impl_callBooleanMethod( "allTablesAreSelectable", mID ); 953 } 954 // ------------------------------------------------------------------------- 955 sal_Bool SAL_CALL java_sql_DatabaseMetaData::isReadOnly( ) throw(SQLException, RuntimeException) 956 { 957 static jmethodID mID(NULL); 958 return impl_callBooleanMethod( "isReadOnly", mID ); 959 } 960 // ------------------------------------------------------------------------- 961 sal_Bool SAL_CALL java_sql_DatabaseMetaData::usesLocalFiles( ) throw(SQLException, RuntimeException) 962 { 963 static jmethodID mID(NULL); 964 return impl_callBooleanMethod( "usesLocalFiles", mID ); 965 } 966 // ------------------------------------------------------------------------- 967 sal_Bool SAL_CALL java_sql_DatabaseMetaData::usesLocalFilePerTable( ) throw(SQLException, RuntimeException) 968 { 969 static jmethodID mID(NULL); 970 return impl_callBooleanMethod( "usesLocalFilePerTable", mID ); 971 } 972 // ------------------------------------------------------------------------- 973 sal_Bool SAL_CALL java_sql_DatabaseMetaData::supportsTypeConversion( ) throw(SQLException, RuntimeException) 974 { 975 static jmethodID mID(NULL); 976 return impl_callBooleanMethod( "supportsTypeConversion", mID ); 977 } 978 // ------------------------------------------------------------------------- 979 sal_Bool SAL_CALL java_sql_DatabaseMetaData::nullPlusNonNullIsNull( ) throw(SQLException, RuntimeException) 980 { 981 static jmethodID mID(NULL); 982 return impl_callBooleanMethod( "nullPlusNonNullIsNull", mID ); 983 } 984 // ------------------------------------------------------------------------- 985 sal_Bool SAL_CALL java_sql_DatabaseMetaData::supportsColumnAliasing( ) throw(SQLException, RuntimeException) 986 { 987 static jmethodID mID(NULL); 988 return impl_callBooleanMethod( "supportsColumnAliasing", mID ); 989 } 990 // ------------------------------------------------------------------------- 991 sal_Bool SAL_CALL java_sql_DatabaseMetaData::supportsTableCorrelationNames( ) throw(SQLException, RuntimeException) 992 { 993 static jmethodID mID(NULL); 994 return impl_callBooleanMethod( "supportsTableCorrelationNames", mID ); 995 } 996 // ------------------------------------------------------------------------- 997 sal_Bool SAL_CALL java_sql_DatabaseMetaData::supportsConvert( sal_Int32 fromType, sal_Int32 toType ) throw(SQLException, RuntimeException) 998 { 999 static const char* pMethodName = "supportsConvert"; 1000 m_aLogger.log( LogLevel::FINEST, STR_LOG_META_DATA_METHOD_ARG2, pMethodName, fromType, toType ); 1001 1002 jboolean out( sal_False ); 1003 SDBThreadAttach t; 1004 1005 { 1006 static jmethodID mID(NULL); 1007 obtainMethodId(t.pEnv, pMethodName,"(II)Z", mID); 1008 out = t.pEnv->CallBooleanMethod( object, mID, fromType, toType ); 1009 ThrowLoggedSQLException( m_aLogger, t.pEnv, *this ); 1010 } 1011 1012 m_aLogger.log< const sal_Char*, sal_Int16 >( LogLevel::FINEST, STR_LOG_META_DATA_RESULT, pMethodName, out ); 1013 return out; 1014 } 1015 // ------------------------------------------------------------------------- 1016 sal_Bool SAL_CALL java_sql_DatabaseMetaData::supportsExpressionsInOrderBy( ) throw(SQLException, RuntimeException) 1017 { 1018 static jmethodID mID(NULL); 1019 return impl_callBooleanMethod( "supportsExpressionsInOrderBy", mID ); 1020 } 1021 // ------------------------------------------------------------------------- 1022 sal_Bool SAL_CALL java_sql_DatabaseMetaData::supportsGroupBy( ) throw(SQLException, RuntimeException) 1023 { 1024 static jmethodID mID(NULL); 1025 return impl_callBooleanMethod( "supportsGroupBy", mID ); 1026 } 1027 // ------------------------------------------------------------------------- 1028 sal_Bool SAL_CALL java_sql_DatabaseMetaData::supportsGroupByBeyondSelect( ) throw(SQLException, RuntimeException) 1029 { 1030 static jmethodID mID(NULL); 1031 return impl_callBooleanMethod( "supportsGroupByBeyondSelect", mID ); 1032 } 1033 // ------------------------------------------------------------------------- 1034 sal_Bool SAL_CALL java_sql_DatabaseMetaData::supportsGroupByUnrelated( ) throw(SQLException, RuntimeException) 1035 { 1036 static jmethodID mID(NULL); 1037 return impl_callBooleanMethod( "supportsGroupByUnrelated", mID ); 1038 } 1039 // ------------------------------------------------------------------------- 1040 sal_Bool SAL_CALL java_sql_DatabaseMetaData::supportsMultipleTransactions( ) throw(SQLException, RuntimeException) 1041 { 1042 static jmethodID mID(NULL); 1043 return impl_callBooleanMethod( "supportsMultipleTransactions", mID ); 1044 } 1045 // ------------------------------------------------------------------------- 1046 sal_Bool SAL_CALL java_sql_DatabaseMetaData::supportsMultipleResultSets( ) throw(SQLException, RuntimeException) 1047 { 1048 static jmethodID mID(NULL); 1049 return impl_callBooleanMethod( "supportsMultipleResultSets", mID ); 1050 } 1051 // ------------------------------------------------------------------------- 1052 sal_Bool SAL_CALL java_sql_DatabaseMetaData::supportsLikeEscapeClause( ) throw(SQLException, RuntimeException) 1053 { 1054 static jmethodID mID(NULL); 1055 return impl_callBooleanMethod( "supportsLikeEscapeClause", mID ); 1056 } 1057 // ------------------------------------------------------------------------- 1058 sal_Bool SAL_CALL java_sql_DatabaseMetaData::supportsOrderByUnrelated( ) throw(SQLException, RuntimeException) 1059 { 1060 static jmethodID mID(NULL); 1061 return impl_callBooleanMethod( "supportsOrderByUnrelated", mID ); 1062 } 1063 // ------------------------------------------------------------------------- 1064 sal_Bool SAL_CALL java_sql_DatabaseMetaData::supportsUnion( ) throw(SQLException, RuntimeException) 1065 { 1066 static jmethodID mID(NULL); 1067 return impl_callBooleanMethod( "supportsUnion", mID ); 1068 } 1069 // ------------------------------------------------------------------------- 1070 sal_Bool SAL_CALL java_sql_DatabaseMetaData::supportsUnionAll( ) throw(SQLException, RuntimeException) 1071 { 1072 static jmethodID mID(NULL); 1073 return impl_callBooleanMethod( "supportsUnionAll", mID ); 1074 } 1075 // ------------------------------------------------------------------------- 1076 sal_Bool SAL_CALL java_sql_DatabaseMetaData::supportsMixedCaseIdentifiers( ) throw(SQLException, RuntimeException) 1077 { 1078 static jmethodID mID(NULL); 1079 return impl_callBooleanMethod( "supportsMixedCaseIdentifiers", mID ); 1080 } 1081 // ------------------------------------------------------------------------- 1082 sal_Bool java_sql_DatabaseMetaData::impl_supportsMixedCaseQuotedIdentifiers_throw( ) 1083 { 1084 static jmethodID mID(NULL); 1085 return impl_callBooleanMethod( "supportsMixedCaseQuotedIdentifiers", mID ); 1086 } 1087 // ------------------------------------------------------------------------- 1088 sal_Bool SAL_CALL java_sql_DatabaseMetaData::nullsAreSortedAtEnd( ) throw(SQLException, RuntimeException) 1089 { 1090 static jmethodID mID(NULL); 1091 return impl_callBooleanMethod( "nullsAreSortedAtEnd", mID ); 1092 } 1093 // ------------------------------------------------------------------------- 1094 sal_Bool SAL_CALL java_sql_DatabaseMetaData::nullsAreSortedAtStart( ) throw(SQLException, RuntimeException) 1095 { 1096 static jmethodID mID(NULL); 1097 return impl_callBooleanMethod( "nullsAreSortedAtStart", mID ); 1098 } 1099 // ------------------------------------------------------------------------- 1100 sal_Bool SAL_CALL java_sql_DatabaseMetaData::nullsAreSortedHigh( ) throw(SQLException, RuntimeException) 1101 { 1102 static jmethodID mID(NULL); 1103 return impl_callBooleanMethod( "nullsAreSortedHigh", mID ); 1104 } 1105 // ------------------------------------------------------------------------- 1106 sal_Bool SAL_CALL java_sql_DatabaseMetaData::nullsAreSortedLow( ) throw(SQLException, RuntimeException) 1107 { 1108 static jmethodID mID(NULL); 1109 return impl_callBooleanMethod( "nullsAreSortedLow", mID ); 1110 } 1111 // ------------------------------------------------------------------------- 1112 sal_Bool SAL_CALL java_sql_DatabaseMetaData::supportsSchemasInProcedureCalls( ) throw(SQLException, RuntimeException) 1113 { 1114 static jmethodID mID(NULL); 1115 return impl_callBooleanMethod( "supportsSchemasInProcedureCalls", mID ); 1116 } 1117 // ------------------------------------------------------------------------- 1118 sal_Bool SAL_CALL java_sql_DatabaseMetaData::supportsSchemasInPrivilegeDefinitions( ) throw(SQLException, RuntimeException) 1119 { 1120 static jmethodID mID(NULL); 1121 return impl_callBooleanMethod( "supportsSchemasInPrivilegeDefinitions", mID ); 1122 } 1123 // ------------------------------------------------------------------------- 1124 sal_Bool SAL_CALL java_sql_DatabaseMetaData::supportsCatalogsInProcedureCalls( ) throw(SQLException, RuntimeException) 1125 { 1126 static jmethodID mID(NULL); 1127 return impl_callBooleanMethod( "supportsCatalogsInProcedureCalls", mID ); 1128 } 1129 // ------------------------------------------------------------------------- 1130 sal_Bool SAL_CALL java_sql_DatabaseMetaData::supportsCatalogsInPrivilegeDefinitions( ) throw(SQLException, RuntimeException) 1131 { 1132 static jmethodID mID(NULL); 1133 return impl_callBooleanMethod( "supportsCatalogsInPrivilegeDefinitions", mID ); 1134 } 1135 // ------------------------------------------------------------------------- 1136 sal_Bool SAL_CALL java_sql_DatabaseMetaData::supportsCorrelatedSubqueries( ) throw(SQLException, RuntimeException) 1137 { 1138 static jmethodID mID(NULL); 1139 return impl_callBooleanMethod( "supportsCorrelatedSubqueries", mID ); 1140 } 1141 // ------------------------------------------------------------------------- 1142 sal_Bool SAL_CALL java_sql_DatabaseMetaData::supportsSubqueriesInComparisons( ) throw(SQLException, RuntimeException) 1143 { 1144 static jmethodID mID(NULL); 1145 return impl_callBooleanMethod( "supportsSubqueriesInComparisons", mID ); 1146 } 1147 // ------------------------------------------------------------------------- 1148 sal_Bool SAL_CALL java_sql_DatabaseMetaData::supportsSubqueriesInExists( ) throw(SQLException, RuntimeException) 1149 { 1150 static jmethodID mID(NULL); 1151 return impl_callBooleanMethod( "supportsSubqueriesInExists", mID ); 1152 } 1153 // ------------------------------------------------------------------------- 1154 sal_Bool SAL_CALL java_sql_DatabaseMetaData::supportsSubqueriesInIns( ) throw(SQLException, RuntimeException) 1155 { 1156 static jmethodID mID(NULL); 1157 return impl_callBooleanMethod( "supportsSubqueriesInIns", mID ); 1158 } 1159 // ------------------------------------------------------------------------- 1160 sal_Bool SAL_CALL java_sql_DatabaseMetaData::supportsSubqueriesInQuantifieds( ) throw(SQLException, RuntimeException) 1161 { 1162 static jmethodID mID(NULL); 1163 return impl_callBooleanMethod( "supportsSubqueriesInQuantifieds", mID ); 1164 } 1165 // ------------------------------------------------------------------------- 1166 sal_Bool SAL_CALL java_sql_DatabaseMetaData::supportsANSI92IntermediateSQL( ) throw(SQLException, RuntimeException) 1167 { 1168 static jmethodID mID(NULL); 1169 return impl_callBooleanMethod( "supportsANSI92IntermediateSQL", mID ); 1170 } 1171 // ------------------------------------------------------------------------- 1172 ::rtl::OUString SAL_CALL java_sql_DatabaseMetaData::getURL( ) throw(SQLException, RuntimeException) 1173 { 1174 ::rtl::OUString sURL = m_pConnection->getURL(); 1175 if ( !sURL.getLength() ) 1176 { 1177 static jmethodID mID(NULL); 1178 sURL = impl_callStringMethod( "getURL", mID ); 1179 } 1180 return sURL; 1181 } 1182 // ------------------------------------------------------------------------- 1183 ::rtl::OUString SAL_CALL java_sql_DatabaseMetaData::getUserName( ) throw(SQLException, RuntimeException) 1184 { 1185 static jmethodID mID(NULL); 1186 return impl_callStringMethod( "getUserName", mID ); 1187 } 1188 // ------------------------------------------------------------------------- 1189 ::rtl::OUString SAL_CALL java_sql_DatabaseMetaData::getDriverName( ) throw(SQLException, RuntimeException) 1190 { 1191 static jmethodID mID(NULL); 1192 return impl_callStringMethod( "getDriverName", mID ); 1193 } 1194 // ------------------------------------------------------------------------- 1195 ::rtl::OUString SAL_CALL java_sql_DatabaseMetaData::getDriverVersion( ) throw(SQLException, RuntimeException) 1196 { 1197 static jmethodID mID(NULL); 1198 return impl_callStringMethod( "getDriverVersion", mID ); 1199 } 1200 // ------------------------------------------------------------------------- 1201 ::rtl::OUString SAL_CALL java_sql_DatabaseMetaData::getDatabaseProductVersion( ) throw(SQLException, RuntimeException) 1202 { 1203 static jmethodID mID(NULL); 1204 return impl_callStringMethod( "getDatabaseProductVersion", mID ); 1205 } 1206 // ------------------------------------------------------------------------- 1207 ::rtl::OUString SAL_CALL java_sql_DatabaseMetaData::getDatabaseProductName( ) throw(SQLException, RuntimeException) 1208 { 1209 static jmethodID mID(NULL); 1210 return impl_callStringMethod( "getDatabaseProductName", mID ); 1211 } 1212 // ------------------------------------------------------------------------- 1213 ::rtl::OUString SAL_CALL java_sql_DatabaseMetaData::getProcedureTerm( ) throw(SQLException, RuntimeException) 1214 { 1215 static jmethodID mID(NULL); 1216 return impl_callStringMethod( "getProcedureTerm", mID ); 1217 } 1218 // ------------------------------------------------------------------------- 1219 ::rtl::OUString SAL_CALL java_sql_DatabaseMetaData::getSchemaTerm( ) throw(SQLException, RuntimeException) 1220 { 1221 static jmethodID mID(NULL); 1222 return impl_callStringMethod( "getSchemaTerm", mID ); 1223 } 1224 // ------------------------------------------------------------------------- 1225 sal_Int32 SAL_CALL java_sql_DatabaseMetaData::getDriverMajorVersion( ) throw(RuntimeException) 1226 { 1227 static jmethodID mID(NULL); 1228 return impl_callIntMethod( "getDriverMajorVersion", mID ); 1229 } 1230 // ------------------------------------------------------------------------- 1231 sal_Int32 SAL_CALL java_sql_DatabaseMetaData::getDefaultTransactionIsolation( ) throw(SQLException, RuntimeException) 1232 { 1233 static jmethodID mID(NULL); 1234 return impl_callIntMethod( "getDefaultTransactionIsolation", mID ); 1235 } 1236 // ------------------------------------------------------------------------- 1237 sal_Int32 SAL_CALL java_sql_DatabaseMetaData::getDriverMinorVersion( ) throw(RuntimeException) 1238 { 1239 static jmethodID mID(NULL); 1240 return impl_callIntMethod( "getDriverMinorVersion", mID ); 1241 } 1242 // ------------------------------------------------------------------------- 1243 ::rtl::OUString SAL_CALL java_sql_DatabaseMetaData::getSQLKeywords( ) throw(SQLException, RuntimeException) 1244 { 1245 static jmethodID mID(NULL); 1246 return impl_callStringMethod( "getSQLKeywords", mID ); 1247 } 1248 // ------------------------------------------------------------------------- 1249 ::rtl::OUString SAL_CALL java_sql_DatabaseMetaData::getSearchStringEscape( ) throw(SQLException, RuntimeException) 1250 { 1251 static jmethodID mID(NULL); 1252 return impl_callStringMethod( "getSearchStringEscape", mID ); 1253 } 1254 // ------------------------------------------------------------------------- 1255 ::rtl::OUString SAL_CALL java_sql_DatabaseMetaData::getStringFunctions( ) throw(SQLException, RuntimeException) 1256 { 1257 static jmethodID mID(NULL); 1258 return impl_callStringMethod( "getStringFunctions", mID ); 1259 } 1260 // ------------------------------------------------------------------------- 1261 ::rtl::OUString SAL_CALL java_sql_DatabaseMetaData::getTimeDateFunctions( ) throw(SQLException, RuntimeException) 1262 { 1263 static jmethodID mID(NULL); 1264 return impl_callStringMethod( "getTimeDateFunctions", mID ); 1265 } 1266 // ------------------------------------------------------------------------- 1267 ::rtl::OUString SAL_CALL java_sql_DatabaseMetaData::getSystemFunctions( ) throw(SQLException, RuntimeException) 1268 { 1269 static jmethodID mID(NULL); 1270 return impl_callStringMethod( "getSystemFunctions", mID ); 1271 } 1272 // ------------------------------------------------------------------------- 1273 ::rtl::OUString SAL_CALL java_sql_DatabaseMetaData::getNumericFunctions( ) throw(SQLException, RuntimeException) 1274 { 1275 static jmethodID mID(NULL); 1276 return impl_callStringMethod( "getNumericFunctions", mID ); 1277 } 1278 // ------------------------------------------------------------------------- 1279 sal_Bool SAL_CALL java_sql_DatabaseMetaData::supportsExtendedSQLGrammar( ) throw(SQLException, RuntimeException) 1280 { 1281 static jmethodID mID(NULL); 1282 return impl_callBooleanMethod( "supportsExtendedSQLGrammar", mID ); 1283 } 1284 // ------------------------------------------------------------------------- 1285 sal_Bool SAL_CALL java_sql_DatabaseMetaData::supportsCoreSQLGrammar( ) throw(SQLException, RuntimeException) 1286 { 1287 static jmethodID mID(NULL); 1288 return impl_callBooleanMethod( "supportsCoreSQLGrammar", mID ); 1289 } 1290 // ------------------------------------------------------------------------- 1291 sal_Bool SAL_CALL java_sql_DatabaseMetaData::supportsMinimumSQLGrammar( ) throw(SQLException, RuntimeException) 1292 { 1293 static jmethodID mID(NULL); 1294 return impl_callBooleanMethod( "supportsMinimumSQLGrammar", mID ); 1295 } 1296 // ------------------------------------------------------------------------- 1297 sal_Bool SAL_CALL java_sql_DatabaseMetaData::supportsFullOuterJoins( ) throw(SQLException, RuntimeException) 1298 { 1299 static jmethodID mID(NULL); 1300 return impl_callBooleanMethod( "supportsFullOuterJoins", mID ); 1301 } 1302 // ------------------------------------------------------------------------- 1303 sal_Bool SAL_CALL java_sql_DatabaseMetaData::supportsLimitedOuterJoins( ) throw(SQLException, RuntimeException) 1304 { 1305 static jmethodID mID(NULL); 1306 return impl_callBooleanMethod( "supportsLimitedOuterJoins", mID ); 1307 } 1308 // ------------------------------------------------------------------------- 1309 sal_Int32 SAL_CALL java_sql_DatabaseMetaData::getMaxColumnsInGroupBy( ) throw(SQLException, RuntimeException) 1310 { 1311 static jmethodID mID(NULL); 1312 return impl_callIntMethod( "getMaxColumnsInGroupBy", mID ); 1313 } 1314 // ------------------------------------------------------------------------- 1315 sal_Int32 SAL_CALL java_sql_DatabaseMetaData::getMaxColumnsInOrderBy( ) throw(SQLException, RuntimeException) 1316 { 1317 static jmethodID mID(NULL); 1318 return impl_callIntMethod( "getMaxColumnsInOrderBy", mID ); 1319 } 1320 // ------------------------------------------------------------------------- 1321 sal_Int32 SAL_CALL java_sql_DatabaseMetaData::getMaxColumnsInSelect( ) throw(SQLException, RuntimeException) 1322 { 1323 static jmethodID mID(NULL); 1324 return impl_callIntMethod( "getMaxColumnsInSelect", mID ); 1325 } 1326 // ------------------------------------------------------------------------- 1327 sal_Int32 SAL_CALL java_sql_DatabaseMetaData::getMaxUserNameLength( ) throw(SQLException, RuntimeException) 1328 { 1329 static jmethodID mID(NULL); 1330 return impl_callIntMethod( "getMaxUserNameLength", mID ); 1331 } 1332 // ------------------------------------------------------------------------- 1333 sal_Bool SAL_CALL java_sql_DatabaseMetaData::supportsResultSetType( sal_Int32 setType ) throw(SQLException, RuntimeException) 1334 { 1335 static jmethodID mID(NULL); 1336 return impl_callBooleanMethodWithIntArg( "supportsResultSetType", mID, setType ); 1337 } 1338 // ------------------------------------------------------------------------- 1339 sal_Bool SAL_CALL java_sql_DatabaseMetaData::supportsResultSetConcurrency( sal_Int32 setType, sal_Int32 concurrency ) throw(SQLException, RuntimeException) 1340 { 1341 static const char* pMethodName = "supportsResultSetConcurrency"; 1342 m_aLogger.log( LogLevel::FINEST, STR_LOG_META_DATA_METHOD_ARG2, pMethodName, setType, concurrency ); 1343 1344 jboolean out( sal_False ); 1345 SDBThreadAttach t; 1346 1347 { 1348 static jmethodID mID(NULL); 1349 obtainMethodId(t.pEnv, pMethodName,"(II)Z", mID); 1350 out = t.pEnv->CallBooleanMethod( object, mID, setType, concurrency); 1351 ThrowLoggedSQLException( m_aLogger, t.pEnv, *this ); 1352 } 1353 1354 m_aLogger.log< const sal_Char*, sal_Int16 >( LogLevel::FINEST, STR_LOG_META_DATA_RESULT, pMethodName, out ); 1355 return out; 1356 } 1357 // ------------------------------------------------------------------------- 1358 sal_Bool SAL_CALL java_sql_DatabaseMetaData::ownUpdatesAreVisible( sal_Int32 setType ) throw(SQLException, RuntimeException) 1359 { 1360 static jmethodID mID(NULL); 1361 return impl_callBooleanMethodWithIntArg( "ownUpdatesAreVisible", mID, setType ); 1362 } 1363 // ------------------------------------------------------------------------- 1364 sal_Bool SAL_CALL java_sql_DatabaseMetaData::ownDeletesAreVisible( sal_Int32 setType ) throw(SQLException, RuntimeException) 1365 { 1366 static jmethodID mID(NULL); 1367 return impl_callBooleanMethodWithIntArg( "ownDeletesAreVisible", mID, setType ); 1368 } 1369 // ------------------------------------------------------------------------- 1370 sal_Bool SAL_CALL java_sql_DatabaseMetaData::ownInsertsAreVisible( sal_Int32 setType ) throw(SQLException, RuntimeException) 1371 { 1372 static jmethodID mID(NULL); 1373 return impl_callBooleanMethodWithIntArg( "ownInsertsAreVisible", mID, setType ); 1374 } 1375 // ------------------------------------------------------------------------- 1376 sal_Bool SAL_CALL java_sql_DatabaseMetaData::othersUpdatesAreVisible( sal_Int32 setType ) throw(SQLException, RuntimeException) 1377 { 1378 static jmethodID mID(NULL); 1379 return impl_callBooleanMethodWithIntArg( "othersUpdatesAreVisible", mID, setType ); 1380 } 1381 // ------------------------------------------------------------------------- 1382 sal_Bool SAL_CALL java_sql_DatabaseMetaData::othersDeletesAreVisible( sal_Int32 setType ) throw(SQLException, RuntimeException) 1383 { 1384 static jmethodID mID(NULL); 1385 return impl_callBooleanMethodWithIntArg( "othersDeletesAreVisible", mID, setType ); 1386 } 1387 // ------------------------------------------------------------------------- 1388 sal_Bool SAL_CALL java_sql_DatabaseMetaData::othersInsertsAreVisible( sal_Int32 setType ) throw(SQLException, RuntimeException) 1389 { 1390 static jmethodID mID(NULL); 1391 return impl_callBooleanMethodWithIntArg( "othersInsertsAreVisible", mID, setType ); 1392 } 1393 // ------------------------------------------------------------------------- 1394 sal_Bool SAL_CALL java_sql_DatabaseMetaData::updatesAreDetected( sal_Int32 setType ) throw(SQLException, RuntimeException) 1395 { 1396 static jmethodID mID(NULL); 1397 return impl_callBooleanMethodWithIntArg( "updatesAreDetected", mID, setType ); 1398 } 1399 // ------------------------------------------------------------------------- 1400 sal_Bool SAL_CALL java_sql_DatabaseMetaData::deletesAreDetected( sal_Int32 setType ) throw(SQLException, RuntimeException) 1401 { 1402 static jmethodID mID(NULL); 1403 return impl_callBooleanMethodWithIntArg( "deletesAreDetected", mID, setType ); 1404 } 1405 // ------------------------------------------------------------------------- 1406 sal_Bool SAL_CALL java_sql_DatabaseMetaData::insertsAreDetected( sal_Int32 setType ) throw(SQLException, RuntimeException) 1407 { 1408 static jmethodID mID(NULL); 1409 return impl_callBooleanMethodWithIntArg( "insertsAreDetected", mID, setType ); 1410 } 1411 // ------------------------------------------------------------------------- 1412 sal_Bool SAL_CALL java_sql_DatabaseMetaData::supportsBatchUpdates( ) throw(SQLException, RuntimeException) 1413 { 1414 static jmethodID mID(NULL); 1415 return impl_callBooleanMethod( "supportsBatchUpdates", mID ); 1416 } 1417 // ------------------------------------------------------------------------- 1418 Reference< XResultSet > SAL_CALL java_sql_DatabaseMetaData::getUDTs( 1419 const Any& catalog, const ::rtl::OUString& schemaPattern, const ::rtl::OUString& typeNamePattern, 1420 const Sequence< sal_Int32 >& types ) throw(SQLException, RuntimeException) 1421 { 1422 jobject out(0); 1423 SDBThreadAttach t; OSL_ENSURE(t.pEnv,"Java Enviroment geloescht worden!"); 1424 { 1425 1426 1427 static const char * cSignature = "(Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;[I)Ljava/sql/ResultSet;"; 1428 static const char * cMethodName = "getUDTs"; 1429 // Java-Call absetzen 1430 static jmethodID mID(NULL); 1431 obtainMethodId(t.pEnv, cMethodName,cSignature, mID); 1432 { 1433 jvalue args[4]; 1434 // temporaere Variable initialisieren 1435 args[0].l = catalog.hasValue() ? convertwchar_tToJavaString(t.pEnv,comphelper::getString(catalog)) : 0; 1436 args[1].l = schemaPattern.toChar() == '%' ? NULL : convertwchar_tToJavaString(t.pEnv,schemaPattern); 1437 args[2].l = convertwchar_tToJavaString(t.pEnv,typeNamePattern); 1438 jintArray pArray = t.pEnv->NewIntArray(types.getLength()); 1439 t.pEnv->SetIntArrayRegion(pArray,0,types.getLength(),(jint*)types.getConstArray()); 1440 args[3].l = pArray; 1441 1442 out = t.pEnv->CallObjectMethod( object, mID, args[0].l, args[1].l,args[2].l,args[3].l); 1443 1444 if(catalog.hasValue()) 1445 t.pEnv->DeleteLocalRef((jstring)args[0].l); 1446 if(schemaPattern.getLength()) 1447 t.pEnv->DeleteLocalRef((jstring)args[1].l); 1448 if(typeNamePattern.getLength()) 1449 t.pEnv->DeleteLocalRef((jstring)args[2].l); 1450 if(args[3].l) 1451 t.pEnv->DeleteLocalRef((jintArray)args[3].l); 1452 ThrowLoggedSQLException( m_aLogger, t.pEnv, *this ); 1453 } 1454 } 1455 1456 return out ? new java_sql_ResultSet( t.pEnv, out, m_aLogger,*m_pConnection ) : 0; 1457 } 1458 // ------------------------------------------------------------------------- 1459