/************************************************************** * * Licensed to the Apache Software Foundation (ASF) under one * or more contributor license agreements. See the NOTICE file * distributed with this work for additional information * regarding copyright ownership. The ASF licenses this file * to you under the Apache License, Version 2.0 (the * "License"); you may not use this file except in compliance * with the License. You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, * software distributed under the License is distributed on an * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY * KIND, either express or implied. See the License for the * specific language governing permissions and limitations * under the License. * *************************************************************/ // MARKER(update_precomp.py): autogen include statement, do not remove #include "precompiled_dbaccess.hxx" #ifndef _DBACORE_RESULTCOLUMN_HXX_ #include "resultcolumn.hxx" #endif #ifndef _COM_SUN_STAR_LANG_DISPOSEDEXCEPTION_HPP_ #include #endif #ifndef _COM_SUN_STAR_SDBC_XRESULTSETMETADATASUPPLIER_HPP_ #include #endif #ifndef _COM_SUN_STAR_SDBC_DATATYPE_HPP_ #include #endif #ifndef _COM_SUN_STAR_SDBC_COLUMNVALUE_HPP_ #include #endif #ifndef _CPPUHELPER_TYPEPROVIDER_HXX_ #include #endif #ifndef _TOOLS_DEBUG_HXX #include #endif #ifndef TOOLS_DIAGNOSE_EX_H #include #endif #ifndef DBACCESS_SHARED_DBASTRINGS_HRC #include "dbastrings.hrc" #endif #ifndef _DBASHARED_APITOOLS_HXX_ #include "apitools.hxx" #endif #ifndef _COM_SUN_STAR_BEANS_PROPERTYATTRIBUTE_HPP_ #include #endif #ifndef _CPPUHELPER_EXC_HLP_HXX_ #include #endif #ifndef _OSL_THREAD_H_ #include #endif using namespace ::com::sun::star::sdbc; using namespace ::com::sun::star::beans; using namespace ::com::sun::star::uno; using namespace ::com::sun::star::lang; using namespace ::com::sun::star::container; using namespace ::osl; using namespace ::comphelper; using namespace ::cppu; using namespace dbaccess; DBG_NAME(OResultColumn) //-------------------------------------------------------------------------- OResultColumn::OResultColumn( const Reference < XResultSetMetaData >& _xMetaData, sal_Int32 _nPos, const Reference< XDatabaseMetaData >& _rxDBMeta ) :OColumn( true ) ,m_xMetaData( _xMetaData ) ,m_xDBMetaData( _rxDBMeta ) ,m_nPos( _nPos ) { DBG_CTOR(OResultColumn,NULL); } // ----------------------------------------------------------------------------- void OResultColumn::impl_determineIsRowVersion_nothrow() { if ( m_aIsRowVersion.hasValue() ) return; m_aIsRowVersion <<= (sal_Bool)(sal_False); OSL_ENSURE( m_xDBMetaData.is(), "OResultColumn::impl_determineIsRowVersion_nothrow: no DBMetaData!" ); if ( !m_xDBMetaData.is() ) return; try { ::rtl::OUString sCatalog, sSchema, sTable, sColumnName; getPropertyValue( PROPERTY_CATALOGNAME ) >>= sCatalog; getPropertyValue( PROPERTY_SCHEMANAME ) >>= sSchema; getPropertyValue( PROPERTY_TABLENAME ) >>= sTable; getPropertyValue( PROPERTY_NAME ) >>= sColumnName; try { Reference< XResultSet > xVersionColumns = m_xDBMetaData->getVersionColumns( makeAny( sCatalog ), sSchema, sTable ); if ( xVersionColumns.is() ) // allowed to be NULL { Reference< XRow > xResultRow( xVersionColumns, UNO_QUERY_THROW ); while ( xVersionColumns->next() ) { if ( xResultRow->getString( 2 ) == sColumnName ) { m_aIsRowVersion <<= (sal_Bool)(sal_True); break; } } } } catch(const SQLException&) { } } catch( const Exception& ) { DBG_UNHANDLED_EXCEPTION(); } } // ----------------------------------------------------------------------------- OResultColumn::~OResultColumn() { DBG_DTOR(OResultColumn,NULL); } // com::sun::star::lang::XTypeProvider //-------------------------------------------------------------------------- Sequence< sal_Int8 > OResultColumn::getImplementationId() throw (RuntimeException) { static OImplementationId * pId = 0; if (! pId) { MutexGuard aGuard( Mutex::getGlobalMutex() ); if (! pId) { static OImplementationId aId; pId = &aId; } } return pId->getImplementationId(); } // XServiceInfo //------------------------------------------------------------------------------ rtl::OUString OResultColumn::getImplementationName( ) throw(RuntimeException) { return rtl::OUString::createFromAscii("com.sun.star.sdb.OResultColumn"); } //------------------------------------------------------------------------------ Sequence< ::rtl::OUString > OResultColumn::getSupportedServiceNames( ) throw (RuntimeException) { Sequence< ::rtl::OUString > aSNS( 2 ); aSNS[0] = SERVICE_SDBCX_COLUMN; aSNS[1] = SERVICE_SDB_RESULTCOLUMN; return aSNS; } // OComponentHelper //------------------------------------------------------------------------------ void OResultColumn::disposing() { OColumn::disposing(); MutexGuard aGuard(m_aMutex); m_xMetaData = NULL; } // comphelper::OPropertyArrayUsageHelper //------------------------------------------------------------------------------ ::cppu::IPropertyArrayHelper* OResultColumn::createArrayHelper( ) const { BEGIN_PROPERTY_HELPER(21) DECL_PROP1(CATALOGNAME, ::rtl::OUString, READONLY); DECL_PROP1(DISPLAYSIZE, sal_Int32, READONLY); DECL_PROP1_BOOL(ISAUTOINCREMENT, READONLY); DECL_PROP1_BOOL(ISCASESENSITIVE, READONLY); DECL_PROP1_BOOL(ISCURRENCY, READONLY); DECL_PROP1_BOOL(ISDEFINITELYWRITABLE, READONLY); DECL_PROP1(ISNULLABLE, sal_Int32, READONLY); DECL_PROP1_BOOL(ISREADONLY, READONLY); DECL_PROP1_BOOL(ISROWVERSION, READONLY); DECL_PROP1_BOOL(ISSEARCHABLE, READONLY); DECL_PROP1_BOOL(ISSIGNED, READONLY); DECL_PROP1_BOOL(ISWRITABLE, READONLY); DECL_PROP1(LABEL, ::rtl::OUString, READONLY); DECL_PROP1(NAME, ::rtl::OUString, READONLY); DECL_PROP1(PRECISION, sal_Int32, READONLY); DECL_PROP1(SCALE, sal_Int32, READONLY); DECL_PROP1(SCHEMANAME, ::rtl::OUString, READONLY); DECL_PROP1(SERVICENAME, ::rtl::OUString, READONLY); DECL_PROP1(TABLENAME, ::rtl::OUString, READONLY); DECL_PROP1(TYPE, sal_Int32, READONLY); DECL_PROP1(TYPENAME, ::rtl::OUString, READONLY); END_PROPERTY_HELPER(); } // cppu::OPropertySetHelper //------------------------------------------------------------------------------ ::cppu::IPropertyArrayHelper& OResultColumn::getInfoHelper() { return *static_cast< ::comphelper::OPropertyArrayUsageHelper< OResultColumn >* >(this)->getArrayHelper(); } //------------------------------------------------------------------------------ namespace { template< typename TYPE > void obtain( Any& _out_rValue, ::boost::optional< TYPE > _rCache, const sal_Int32 _nPos, const Reference < XResultSetMetaData >& _rxResultMeta, TYPE (SAL_CALL XResultSetMetaData::*Getter)( sal_Int32 ) ) { if ( !_rCache ) _rCache.reset( (_rxResultMeta.get()->*Getter)( _nPos ) ); _out_rValue <<= *_rCache; } } //------------------------------------------------------------------------------ void OResultColumn::getFastPropertyValue( Any& rValue, sal_Int32 nHandle ) const { try { if ( OColumn::isRegisteredProperty( nHandle ) ) { OColumn::getFastPropertyValue( rValue, nHandle ); } else { switch (nHandle) { case PROPERTY_ID_ISROWVERSION: const_cast< OResultColumn* >( this )->impl_determineIsRowVersion_nothrow(); rValue = m_aIsRowVersion; break; case PROPERTY_ID_TABLENAME: rValue <<= m_xMetaData->getTableName(m_nPos); break; case PROPERTY_ID_SCHEMANAME: rValue <<= m_xMetaData->getSchemaName(m_nPos); break; case PROPERTY_ID_CATALOGNAME: rValue <<= m_xMetaData->getCatalogName(m_nPos); break; case PROPERTY_ID_ISSIGNED: obtain( rValue, m_isSigned, m_nPos, m_xMetaData, &XResultSetMetaData::isSigned ); break; case PROPERTY_ID_ISCURRENCY: obtain( rValue, m_isCurrency, m_nPos, m_xMetaData, &XResultSetMetaData::isCurrency ); break; case PROPERTY_ID_ISSEARCHABLE: obtain( rValue, m_bSearchable, m_nPos, m_xMetaData, &XResultSetMetaData::isSearchable ); break; case PROPERTY_ID_ISCASESENSITIVE: obtain( rValue, m_isCaseSensitive, m_nPos, m_xMetaData, &XResultSetMetaData::isCaseSensitive ); break; case PROPERTY_ID_ISREADONLY: obtain( rValue, m_isReadOnly, m_nPos, m_xMetaData, &XResultSetMetaData::isReadOnly ); break; case PROPERTY_ID_ISWRITABLE: obtain( rValue, m_isWritable, m_nPos, m_xMetaData, &XResultSetMetaData::isWritable ); break; case PROPERTY_ID_ISDEFINITELYWRITABLE: obtain( rValue, m_isDefinitelyWritable, m_nPos, m_xMetaData, &XResultSetMetaData::isDefinitelyWritable ); break; case PROPERTY_ID_ISAUTOINCREMENT: obtain( rValue, m_isAutoIncrement, m_nPos, m_xMetaData, &XResultSetMetaData::isAutoIncrement ); break; case PROPERTY_ID_SERVICENAME: rValue <<= m_xMetaData->getColumnServiceName(m_nPos); break; case PROPERTY_ID_LABEL: obtain( rValue, m_sColumnLabel, m_nPos, m_xMetaData, &XResultSetMetaData::getColumnLabel ); break; case PROPERTY_ID_DISPLAYSIZE: obtain( rValue, m_nColumnDisplaySize, m_nPos, m_xMetaData, &XResultSetMetaData::getColumnDisplaySize ); break; case PROPERTY_ID_TYPE: obtain( rValue, m_nColumnType, m_nPos, m_xMetaData, &XResultSetMetaData::getColumnType ); break; case PROPERTY_ID_PRECISION: obtain( rValue, m_nPrecision, m_nPos, m_xMetaData, &XResultSetMetaData::getPrecision ); break; case PROPERTY_ID_SCALE: obtain( rValue, m_nScale, m_nPos, m_xMetaData, &XResultSetMetaData::getScale ); break; case PROPERTY_ID_ISNULLABLE: obtain( rValue, m_isNullable, m_nPos, m_xMetaData, &XResultSetMetaData::isNullable ); break; case PROPERTY_ID_TYPENAME: rValue <<= m_xMetaData->getColumnTypeName(m_nPos); break; default: OSL_ENSURE( false, "OResultColumn::getFastPropertyValue: unknown property handle!" ); break; } } } catch (SQLException& ) { // default handling if we caught an exception switch (nHandle) { case PROPERTY_ID_LABEL: case PROPERTY_ID_TYPENAME: case PROPERTY_ID_SERVICENAME: case PROPERTY_ID_TABLENAME: case PROPERTY_ID_SCHEMANAME: case PROPERTY_ID_CATALOGNAME: // empty string'S rValue <<= rtl::OUString(); break; case PROPERTY_ID_ISROWVERSION: case PROPERTY_ID_ISAUTOINCREMENT: case PROPERTY_ID_ISWRITABLE: case PROPERTY_ID_ISDEFINITELYWRITABLE: case PROPERTY_ID_ISCASESENSITIVE: case PROPERTY_ID_ISSEARCHABLE: case PROPERTY_ID_ISCURRENCY: case PROPERTY_ID_ISSIGNED: { sal_Bool bVal = sal_False; rValue.setValue(&bVal, getBooleanCppuType()); } break; case PROPERTY_ID_ISREADONLY: { sal_Bool bVal = sal_True; rValue.setValue(&bVal, getBooleanCppuType()); } break; case PROPERTY_ID_SCALE: case PROPERTY_ID_PRECISION: case PROPERTY_ID_DISPLAYSIZE: rValue <<= sal_Int32(0); break; case PROPERTY_ID_TYPE: rValue <<= sal_Int32(DataType::SQLNULL); break; case PROPERTY_ID_ISNULLABLE: rValue <<= ColumnValue::NULLABLE_UNKNOWN; break; } } }