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 
~java_sql_DatabaseMetaData()53 java_sql_DatabaseMetaData::~java_sql_DatabaseMetaData()
54 {
55 	SDBThreadAttach::releaseRef();
56 }
57 
getMyClass() const58 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 // -----------------------------------------------------------------------------
java_sql_DatabaseMetaData(JNIEnv * pEnv,jobject myObj,java_sql_Connection & _rConnection)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 // -------------------------------------------------------------------------
impl_getTypeInfo_throw()76 Reference< XResultSet > java_sql_DatabaseMetaData::impl_getTypeInfo_throw(  )
77 {
78 	static jmethodID mID(NULL);
79     return impl_callResultSetMethod( "getTypeInfo", mID );
80 }
81 // -------------------------------------------------------------------------
getCatalogs()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 // -------------------------------------------------------------------------
impl_getCatalogSeparator_throw()88 ::rtl::OUString java_sql_DatabaseMetaData::impl_getCatalogSeparator_throw(  )
89 {
90 	static jmethodID mID(NULL);
91     return impl_callStringMethod( "getCatalogSeparator", mID );
92 }
93 // -------------------------------------------------------------------------
getSchemas()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 // -------------------------------------------------------------------------
getColumnPrivileges(const Any & catalog,const::rtl::OUString & schema,const::rtl::OUString & table,const::rtl::OUString & columnNamePattern)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 // -------------------------------------------------------------------------
getColumns(const Any & catalog,const::rtl::OUString & schemaPattern,const::rtl::OUString & tableNamePattern,const::rtl::OUString & columnNamePattern)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 // -------------------------------------------------------------------------
getTables(const Any & catalog,const::rtl::OUString & schemaPattern,const::rtl::OUString & tableNamePattern,const Sequence<::rtl::OUString> & _types)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 occurred!");
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 occurred!" );
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 occurred!" );
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 occurred!" );
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 occurred!" );
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 occurred!" );
192         }
193         if(tableNamePattern.getLength())
194         {
195             t.pEnv->DeleteLocalRef((jstring)args[2].l);
196             OSL_VERIFY_RES( !isExceptionOccured( t.pEnv, sal_True ), "Exception occurred!" );
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 occurred!" );
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 // -------------------------------------------------------------------------
getProcedureColumns(const Any & catalog,const::rtl::OUString & schemaPattern,const::rtl::OUString & procedureNamePattern,const::rtl::OUString & columnNamePattern)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 // -------------------------------------------------------------------------
getProcedures(const Any & catalog,const::rtl::OUString & schemaPattern,const::rtl::OUString & procedureNamePattern)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 // -------------------------------------------------------------------------
getVersionColumns(const Any & catalog,const::rtl::OUString & schema,const::rtl::OUString & table)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 // -------------------------------------------------------------------------
getMaxBinaryLiteralLength()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 // -------------------------------------------------------------------------
getMaxRowSize()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 // -------------------------------------------------------------------------
getMaxCatalogNameLength()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 // -------------------------------------------------------------------------
getMaxCharLiteralLength()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 // -------------------------------------------------------------------------
getMaxColumnNameLength()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 // -------------------------------------------------------------------------
getMaxColumnsInIndex()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 // -------------------------------------------------------------------------
getMaxCursorNameLength()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 // -------------------------------------------------------------------------
getMaxConnections()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 // -------------------------------------------------------------------------
getMaxColumnsInTable()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 // -------------------------------------------------------------------------
getMaxStatementLength()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 // -------------------------------------------------------------------------
getMaxTableNameLength()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 // -------------------------------------------------------------------------
impl_getMaxTablesInSelect_throw()316 sal_Int32 java_sql_DatabaseMetaData::impl_getMaxTablesInSelect_throw(  )
317 {
318 	static jmethodID mID(NULL);
319     return impl_callIntMethod( "getMaxTablesInSelect", mID );
320 }
321 // -------------------------------------------------------------------------
getExportedKeys(const Any & catalog,const::rtl::OUString & schema,const::rtl::OUString & table)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 // -------------------------------------------------------------------------
getImportedKeys(const Any & catalog,const::rtl::OUString & schema,const::rtl::OUString & table)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 // -------------------------------------------------------------------------
getPrimaryKeys(const Any & catalog,const::rtl::OUString & schema,const::rtl::OUString & table)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 // -------------------------------------------------------------------------
getIndexInfo(const Any & catalog,const::rtl::OUString & schema,const::rtl::OUString & table,sal_Bool unique,sal_Bool approximate)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 // -------------------------------------------------------------------------
getBestRowIdentifier(const Any & catalog,const::rtl::OUString & schema,const::rtl::OUString & table,sal_Int32 scope,sal_Bool nullable)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 // -------------------------------------------------------------------------
getTablePrivileges(const Any & catalog,const::rtl::OUString & schemaPattern,const::rtl::OUString & tableNamePattern)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 // -------------------------------------------------------------------------
getCrossReference(const Any & primaryCatalog,const::rtl::OUString & primarySchema,const::rtl::OUString & primaryTable,const Any & foreignCatalog,const::rtl::OUString & foreignSchema,const::rtl::OUString & foreignTable)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 // -------------------------------------------------------------------------
impl_callBooleanMethod(const char * _pMethodName,jmethodID & _inout_MethodID)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 // -------------------------------------------------------------------------
impl_callStringMethod(const char * _pMethodName,jmethodID & _inout_MethodID)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 // -------------------------------------------------------------------------
impl_callIntMethod(const char * _pMethodName,jmethodID & _inout_MethodID)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 // -------------------------------------------------------------------------
impl_callBooleanMethodWithIntArg(const char * _pMethodName,jmethodID & _inout_MethodID,sal_Int32 _nArgument)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 // -------------------------------------------------------------------------
impl_callResultSetMethod(const char * _pMethodName,jmethodID & _inout_MethodID)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 // -------------------------------------------------------------------------
impl_callResultSetMethodWithStrings(const char * _pMethodName,jmethodID & _inout_MethodID,const Any & _rCatalog,const::rtl::OUString & _rSchemaPattern,const::rtl::OUString & _rLeastPattern,const::rtl::OUString * _pOptionalAdditionalString)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 // -------------------------------------------------------------------------
doesMaxRowSizeIncludeBlobs()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 // -------------------------------------------------------------------------
storesLowerCaseQuotedIdentifiers()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 // -------------------------------------------------------------------------
storesLowerCaseIdentifiers()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 // -------------------------------------------------------------------------
impl_storesMixedCaseQuotedIdentifiers_throw()696 sal_Bool java_sql_DatabaseMetaData::impl_storesMixedCaseQuotedIdentifiers_throw(  )
697 {
698 	static jmethodID mID(NULL);
699     return impl_callBooleanMethod( "storesMixedCaseQuotedIdentifiers", mID );
700 }
701 // -------------------------------------------------------------------------
storesMixedCaseIdentifiers()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 // -------------------------------------------------------------------------
storesUpperCaseQuotedIdentifiers()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 // -------------------------------------------------------------------------
storesUpperCaseIdentifiers()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 // -------------------------------------------------------------------------
impl_supportsAlterTableWithAddColumn_throw()720 sal_Bool java_sql_DatabaseMetaData::impl_supportsAlterTableWithAddColumn_throw(  )
721 {
722 	static jmethodID mID(NULL);
723     return impl_callBooleanMethod( "supportsAlterTableWithAddColumn", mID );
724 }
725 // -------------------------------------------------------------------------
impl_supportsAlterTableWithDropColumn_throw()726 sal_Bool java_sql_DatabaseMetaData::impl_supportsAlterTableWithDropColumn_throw(  )
727 {
728 	static jmethodID mID(NULL);
729     return impl_callBooleanMethod( "supportsAlterTableWithDropColumn", mID );
730 }
731 // -------------------------------------------------------------------------
getMaxIndexLength()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 // -------------------------------------------------------------------------
supportsNonNullableColumns()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 // -------------------------------------------------------------------------
getCatalogTerm()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 // -------------------------------------------------------------------------
impl_getIdentifierQuoteString_throw()750 ::rtl::OUString java_sql_DatabaseMetaData::impl_getIdentifierQuoteString_throw(  )
751 {
752 	static jmethodID mID(NULL);
753     return impl_callStringMethod( "getIdentifierQuoteString", mID );
754 }
755 // -------------------------------------------------------------------------
getExtraNameCharacters()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 // -------------------------------------------------------------------------
supportsDifferentTableCorrelationNames()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 // -------------------------------------------------------------------------
impl_isCatalogAtStart_throw()768 sal_Bool java_sql_DatabaseMetaData::impl_isCatalogAtStart_throw(  )
769 {
770 	static jmethodID mID(NULL);
771     return impl_callBooleanMethod( "isCatalogAtStart", mID );
772 }
773 // -------------------------------------------------------------------------
dataDefinitionIgnoredInTransactions()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 // -------------------------------------------------------------------------
dataDefinitionCausesTransactionCommit()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 // -------------------------------------------------------------------------
supportsDataManipulationTransactionsOnly()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 // -------------------------------------------------------------------------
supportsDataDefinitionAndDataManipulationTransactions()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 // -------------------------------------------------------------------------
supportsPositionedDelete()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 // -------------------------------------------------------------------------
supportsPositionedUpdate()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 // -------------------------------------------------------------------------
supportsOpenStatementsAcrossRollback()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 // -------------------------------------------------------------------------
supportsOpenStatementsAcrossCommit()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 // -------------------------------------------------------------------------
supportsOpenCursorsAcrossCommit()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 // -------------------------------------------------------------------------
supportsOpenCursorsAcrossRollback()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 // -------------------------------------------------------------------------
supportsTransactionIsolationLevel(sal_Int32 level)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 // -------------------------------------------------------------------------
impl_supportsSchemasInDataManipulation_throw()840 sal_Bool java_sql_DatabaseMetaData::impl_supportsSchemasInDataManipulation_throw(  )
841 {
842 	static jmethodID mID(NULL);
843     return impl_callBooleanMethod( "supportsSchemasInDataManipulation", mID );
844 }
845 // -------------------------------------------------------------------------
supportsANSI92FullSQL()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 // -------------------------------------------------------------------------
supportsANSI92EntryLevelSQL()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 // -------------------------------------------------------------------------
supportsIntegrityEnhancementFacility()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 // -------------------------------------------------------------------------
supportsSchemasInIndexDefinitions()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 // -------------------------------------------------------------------------
impl_supportsSchemasInTableDefinitions_throw()870 sal_Bool java_sql_DatabaseMetaData::impl_supportsSchemasInTableDefinitions_throw(  )
871 {
872 	static jmethodID mID(NULL);
873     return impl_callBooleanMethod( "supportsSchemasInTableDefinitions", mID );
874 }
875 // -------------------------------------------------------------------------
impl_supportsCatalogsInTableDefinitions_throw()876 sal_Bool java_sql_DatabaseMetaData::impl_supportsCatalogsInTableDefinitions_throw(  )
877 {
878 	static jmethodID mID(NULL);
879     return impl_callBooleanMethod( "supportsCatalogsInTableDefinitions", mID );
880 }
881 // -------------------------------------------------------------------------
supportsCatalogsInIndexDefinitions()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 // -------------------------------------------------------------------------
impl_supportsCatalogsInDataManipulation_throw()888 sal_Bool java_sql_DatabaseMetaData::impl_supportsCatalogsInDataManipulation_throw(  )
889 {
890 	static jmethodID mID(NULL);
891     return impl_callBooleanMethod( "supportsCatalogsInDataManipulation", mID );
892 }
893 // -------------------------------------------------------------------------
supportsOuterJoins()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 // -------------------------------------------------------------------------
getTableTypes()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 // -------------------------------------------------------------------------
impl_getMaxStatements_throw()906 sal_Int32 java_sql_DatabaseMetaData::impl_getMaxStatements_throw(  )
907 {
908 	static jmethodID mID(NULL);
909     return impl_callIntMethod( "getMaxStatements", mID );
910 }
911 // -------------------------------------------------------------------------
getMaxProcedureNameLength()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 // -------------------------------------------------------------------------
getMaxSchemaNameLength()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 // -------------------------------------------------------------------------
supportsTransactions()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 // -------------------------------------------------------------------------
allProceduresAreCallable()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 // -------------------------------------------------------------------------
supportsStoredProcedures()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 // -------------------------------------------------------------------------
supportsSelectForUpdate()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 // -------------------------------------------------------------------------
allTablesAreSelectable()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 // -------------------------------------------------------------------------
isReadOnly()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 // -------------------------------------------------------------------------
usesLocalFiles()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 // -------------------------------------------------------------------------
usesLocalFilePerTable()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 // -------------------------------------------------------------------------
supportsTypeConversion()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 // -------------------------------------------------------------------------
nullPlusNonNullIsNull()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 // -------------------------------------------------------------------------
supportsColumnAliasing()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 // -------------------------------------------------------------------------
supportsTableCorrelationNames()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 // -------------------------------------------------------------------------
supportsConvert(sal_Int32 fromType,sal_Int32 toType)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 // -------------------------------------------------------------------------
supportsExpressionsInOrderBy()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 // -------------------------------------------------------------------------
supportsGroupBy()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 // -------------------------------------------------------------------------
supportsGroupByBeyondSelect()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 // -------------------------------------------------------------------------
supportsGroupByUnrelated()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 // -------------------------------------------------------------------------
supportsMultipleTransactions()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 // -------------------------------------------------------------------------
supportsMultipleResultSets()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 // -------------------------------------------------------------------------
supportsLikeEscapeClause()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 // -------------------------------------------------------------------------
supportsOrderByUnrelated()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 // -------------------------------------------------------------------------
supportsUnion()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 // -------------------------------------------------------------------------
supportsUnionAll()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 // -------------------------------------------------------------------------
supportsMixedCaseIdentifiers()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 // -------------------------------------------------------------------------
impl_supportsMixedCaseQuotedIdentifiers_throw()1082 sal_Bool java_sql_DatabaseMetaData::impl_supportsMixedCaseQuotedIdentifiers_throw(  )
1083 {
1084 	static jmethodID mID(NULL);
1085     return impl_callBooleanMethod( "supportsMixedCaseQuotedIdentifiers", mID );
1086 }
1087 // -------------------------------------------------------------------------
nullsAreSortedAtEnd()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 // -------------------------------------------------------------------------
nullsAreSortedAtStart()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 // -------------------------------------------------------------------------
nullsAreSortedHigh()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 // -------------------------------------------------------------------------
nullsAreSortedLow()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 // -------------------------------------------------------------------------
supportsSchemasInProcedureCalls()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 // -------------------------------------------------------------------------
supportsSchemasInPrivilegeDefinitions()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 // -------------------------------------------------------------------------
supportsCatalogsInProcedureCalls()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 // -------------------------------------------------------------------------
supportsCatalogsInPrivilegeDefinitions()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 // -------------------------------------------------------------------------
supportsCorrelatedSubqueries()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 // -------------------------------------------------------------------------
supportsSubqueriesInComparisons()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 // -------------------------------------------------------------------------
supportsSubqueriesInExists()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 // -------------------------------------------------------------------------
supportsSubqueriesInIns()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 // -------------------------------------------------------------------------
supportsSubqueriesInQuantifieds()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 // -------------------------------------------------------------------------
supportsANSI92IntermediateSQL()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 // -------------------------------------------------------------------------
getURL()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 // -------------------------------------------------------------------------
getUserName()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 // -------------------------------------------------------------------------
getDriverName()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 // -------------------------------------------------------------------------
getDriverVersion()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 // -------------------------------------------------------------------------
getDatabaseProductVersion()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 // -------------------------------------------------------------------------
getDatabaseProductName()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 // -------------------------------------------------------------------------
getProcedureTerm()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 // -------------------------------------------------------------------------
getSchemaTerm()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 // -------------------------------------------------------------------------
getDriverMajorVersion()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 // -------------------------------------------------------------------------
getDefaultTransactionIsolation()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 // -------------------------------------------------------------------------
getDriverMinorVersion()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 // -------------------------------------------------------------------------
getSQLKeywords()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 // -------------------------------------------------------------------------
getSearchStringEscape()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 // -------------------------------------------------------------------------
getStringFunctions()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 // -------------------------------------------------------------------------
getTimeDateFunctions()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 // -------------------------------------------------------------------------
getSystemFunctions()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 // -------------------------------------------------------------------------
getNumericFunctions()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 // -------------------------------------------------------------------------
supportsExtendedSQLGrammar()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 // -------------------------------------------------------------------------
supportsCoreSQLGrammar()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 // -------------------------------------------------------------------------
supportsMinimumSQLGrammar()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 // -------------------------------------------------------------------------
supportsFullOuterJoins()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 // -------------------------------------------------------------------------
supportsLimitedOuterJoins()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 // -------------------------------------------------------------------------
getMaxColumnsInGroupBy()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 // -------------------------------------------------------------------------
getMaxColumnsInOrderBy()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 // -------------------------------------------------------------------------
getMaxColumnsInSelect()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 // -------------------------------------------------------------------------
getMaxUserNameLength()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 // -------------------------------------------------------------------------
supportsResultSetType(sal_Int32 setType)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 // -------------------------------------------------------------------------
supportsResultSetConcurrency(sal_Int32 setType,sal_Int32 concurrency)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 // -------------------------------------------------------------------------
ownUpdatesAreVisible(sal_Int32 setType)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 // -------------------------------------------------------------------------
ownDeletesAreVisible(sal_Int32 setType)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 // -------------------------------------------------------------------------
ownInsertsAreVisible(sal_Int32 setType)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 // -------------------------------------------------------------------------
othersUpdatesAreVisible(sal_Int32 setType)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 // -------------------------------------------------------------------------
othersDeletesAreVisible(sal_Int32 setType)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 // -------------------------------------------------------------------------
othersInsertsAreVisible(sal_Int32 setType)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 // -------------------------------------------------------------------------
updatesAreDetected(sal_Int32 setType)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 // -------------------------------------------------------------------------
deletesAreDetected(sal_Int32 setType)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 // -------------------------------------------------------------------------
insertsAreDetected(sal_Int32 setType)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 // -------------------------------------------------------------------------
supportsBatchUpdates()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 // -------------------------------------------------------------------------
getUDTs(const Any & catalog,const::rtl::OUString & schemaPattern,const::rtl::OUString & typeNamePattern,const Sequence<sal_Int32> & types)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