ucbhelper/source/provider/resultsetmetadata.cxx

   1 /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
   2 /*
   3  * This file is part of the LibreOffice project.
   4  *
   5  * This Source Code Form is subject to the terms of the Mozilla Public
   6  * License, v. 2.0. If a copy of the MPL was not distributed with this
   7  * file, You can obtain one at http://mozilla.org/MPL/2.0/.
   8  *
   9  * This file incorporates work covered by the following license notice:
  10  *
  11  *   Licensed to the Apache Software Foundation (ASF) under one or more
  12  *   contributor license agreements. See the NOTICE file distributed
  13  *   with this work for additional information regarding copyright
  14  *   ownership. The ASF licenses this file to you under the Apache
  15  *   License, Version 2.0 (the "License"); you may not use this file
  16  *   except in compliance with the License. You may obtain a copy of
  17  *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
  18  */
  19
  20
  21 /**************************************************************************
  22                                 TODO
  23  **************************************************************************
  24
  25  *************************************************************************/
  26
  27 #include <osl/diagnose.h>
  28 #include <com/sun/star/beans/Property.hpp>
  29 #include <com/sun/star/beans/XPropertySetInfo.hpp>
  30 #include <com/sun/star/io/XInputStream.hpp>
  31 #include <com/sun/star/lang/XMultiServiceFactory.hpp>
  32 #include <com/sun/star/sdbc/ColumnValue.hpp>
  33 #include <com/sun/star/sdbc/DataType.hpp>
  34 #include <com/sun/star/sdbc/XArray.hpp>
  35 #include <com/sun/star/sdbc/XBlob.hpp>
  36 #include <com/sun/star/sdbc/XClob.hpp>
  37 #include <com/sun/star/sdbc/XRef.hpp>
  38 #include <com/sun/star/util/Date.hpp>
  39 #include <com/sun/star/util/Time.hpp>
  40 #include <com/sun/star/util/DateTime.hpp>
  41 #include <com/sun/star/ucb/PropertiesManager.hpp>
  42 #include <ucbhelper/macros.hxx>
  43 #include <ucbhelper/resultsetmetadata.hxx>
  44 #include <cppuhelper/queryinterface.hxx>
  45
  46 using namespace com::sun::star::beans;
  47 using namespace com::sun::star::io;
  48 using namespace com::sun::star::lang;
  49 using namespace com::sun::star::sdbc;
  50 using namespace com::sun::star::ucb;
  51 using namespace com::sun::star::uno;
  52 using namespace com::sun::star::util;
  53
  54
  55 namespace ucbhelper_impl {
  56
  57 struct ResultSetMetaData_Impl
  58 {
  59     osl::Mutex                                      m_aMutex;
  60     std::vector< ::ucbhelper::ResultSetColumnData > m_aColumnData;
  61     bool                                        m_bObtainedTypes;
  62
  63     explicit ResultSetMetaData_Impl( sal_Int32 nSize )
  64     : m_aColumnData( nSize ), m_bObtainedTypes( false ) {}
  65
  66     explicit ResultSetMetaData_Impl(
  67         const std::vector< ::ucbhelper::ResultSetColumnData >& rColumnData )
  68     : m_aColumnData( rColumnData ), m_bObtainedTypes( false ) {}
  69 };
  70
  71 }
  72
  73 using namespace ucbhelper_impl;
  74
  75 namespace ucbhelper {
  76
  77
  78 // ResultSetMetaData Implementation.
  79
  80
  81 ResultSetMetaData::ResultSetMetaData(
  82                         const Reference< XComponentContext >& rxContext,
  83                         const Sequence< Property >& rProps )
  84 : m_pImpl( new ResultSetMetaData_Impl( rProps.getLength() ) ),
  85   m_xContext( rxContext ),
  86   m_aProps( rProps )
  87 {
  88 }
  89
  90
  91 ResultSetMetaData::ResultSetMetaData(
  92                         const Reference< XComponentContext >& rxContext,
  93                         const Sequence< Property >& rProps,
  94                         const std::vector< ResultSetColumnData >& rColumnData )
  95 : m_pImpl( new ResultSetMetaData_Impl( rColumnData ) ),
  96   m_xContext( rxContext ),
  97   m_aProps( rProps )
  98 {
  99     OSL_ENSURE( rColumnData.size() == sal_uInt32( rProps.getLength() ),
 100                 "ResultSetMetaData ctor - different array sizes!" );
 101 }
 102
 103
 104 // virtual
 105 ResultSetMetaData::~ResultSetMetaData()
 106 {
 107 }
 108
 109
 110 // XInterface methods.
 111
 112 void SAL_CALL ResultSetMetaData::acquire()
 113     throw()
 114 {
 115     OWeakObject::acquire();
 116 }
 117
 118 void SAL_CALL ResultSetMetaData::release()
 119     throw()
 120 {
 121     OWeakObject::release();
 122 }
 123
 124 css::uno::Any SAL_CALL ResultSetMetaData::queryInterface( const css::uno::Type & rType )
 125 {
 126     css::uno::Any aRet = cppu::queryInterface( rType,
 127                                                static_cast< XTypeProvider* >(this),
 128                                                static_cast< XResultSetMetaData* >(this)
 129                                                );
 130     return aRet.hasValue() ? aRet : OWeakObject::queryInterface( rType );
 131 }
 132
 133 // XTypeProvider methods.
 134
 135
 136 XTYPEPROVIDER_IMPL_2( ResultSetMetaData,
 137                       XTypeProvider,
 138                       XResultSetMetaData );
 139
 140
 141 // XResultSetMetaData methods.
 142
 143
 144 // virtual
 145 sal_Int32 SAL_CALL ResultSetMetaData::getColumnCount()
 146 {
 147     return m_aProps.getLength();
 148 }
 149
 150
 151 // virtual
 152 sal_Bool SAL_CALL ResultSetMetaData::isAutoIncrement( sal_Int32 /*column*/ )
 153 {
 154     /*
 155         Checks whether column is automatically numbered, which makes it
 156         read-only.
 157      */
 158     return false;
 159 }
 160
 161
 162 // virtual
 163 sal_Bool SAL_CALL ResultSetMetaData::isCaseSensitive( sal_Int32 column )
 164 {
 165     if ( ( column < 1 ) || ( column > m_aProps.getLength() ) )
 166         return false;
 167
 168     return m_pImpl->m_aColumnData[ column - 1 ].isCaseSensitive;
 169 }
 170
 171
 172 // virtual
 173 sal_Bool SAL_CALL ResultSetMetaData::isSearchable( sal_Int32 /*column*/ )
 174 {
 175     return false;
 176 }
 177
 178
 179 // virtual
 180 sal_Bool SAL_CALL ResultSetMetaData::isCurrency( sal_Int32 /*column*/ )
 181 {
 182     return false;
 183 }
 184
 185
 186 // virtual
 187 sal_Int32 SAL_CALL ResultSetMetaData::isNullable( sal_Int32 /*column*/ )
 188 {
 189     return ColumnValue::NULLABLE;
 190 }
 191
 192
 193 // virtual
 194 sal_Bool SAL_CALL ResultSetMetaData::isSigned( sal_Int32 /*column*/ )
 195 {
 196     return false;
 197 }
 198
 199
 200 // virtual
 201 sal_Int32 SAL_CALL ResultSetMetaData::getColumnDisplaySize( sal_Int32 /*column*/ )
 202 {
 203     /*
 204         Gets the normal maximum width in characters for column.
 205      */
 206     return 16;
 207 }
 208
 209
 210 // virtual
 211 OUString SAL_CALL ResultSetMetaData::getColumnLabel( sal_Int32 column )
 212 {
 213     /*
 214         Gets the suggested column title for column, to be used in print-
 215         outs and displays.
 216      */
 217
 218     if ( ( column < 1 ) || ( column > m_aProps.getLength() ) )
 219         return OUString();
 220
 221     return m_aProps.getConstArray()[ column - 1 ].Name;
 222 }
 223
 224
 225 // virtual
 226 OUString SAL_CALL ResultSetMetaData::getColumnName( sal_Int32 column )
 227 {
 228     /*
 229         Gets the name of column.
 230      */
 231
 232     if ( ( column < 1 ) || ( column > m_aProps.getLength() ) )
 233         return OUString();
 234
 235     return m_aProps.getConstArray()[ column - 1 ].Name;
 236 }
 237
 238
 239 // virtual
 240 OUString SAL_CALL ResultSetMetaData::getSchemaName( sal_Int32 /*column*/ )
 241 {
 242     /*
 243         Gets the schema name for the table from which column of this
 244         result set was derived.
 245         Because this feature is not widely supported, the return value
 246         for many DBMSs will be an empty string.
 247      */
 248     return OUString();
 249 }
 250
 251
 252 // virtual
 253 sal_Int32 SAL_CALL ResultSetMetaData::getPrecision( sal_Int32 /*column*/ )
 254 {
 255     return -1;
 256 }
 257
 258
 259 // virtual
 260 sal_Int32 SAL_CALL ResultSetMetaData::getScale( sal_Int32 /*column*/ )
 261 {
 262     return 0;
 263 }
 264
 265
 266 // virtual
 267 OUString SAL_CALL ResultSetMetaData::getTableName( sal_Int32 /*column*/ )
 268 {
 269     /*
 270         Gets the name of the table from which column of this result set
 271         was derived or "" if there is none (for example, for a join).
 272         Because this feature is not widely supported, the return value
 273         for many DBMSs will be an empty string.
 274      */
 275     return OUString();
 276 }
 277
 278
 279 // virtual
 280 OUString SAL_CALL ResultSetMetaData::getCatalogName( sal_Int32 /*column*/ )
 281 {
 282     /*
 283         Gets the catalog name for the table from which column of this
 284         result set was derived.
 285         Because this feature is not widely supported, the return value
 286         for many DBMSs will be an empty string.
 287      */
 288     return OUString();
 289 }
 290
 291
 292 // virtual
 293 sal_Int32 SAL_CALL ResultSetMetaData::getColumnType( sal_Int32 column )
 294 {
 295     /*
 296         Gets the JDBC type for the value stored in column. ... The STRUCT
 297         and DISTINCT type codes are always returned for structured and
 298         distinct types, regardless of whether the value will be mapped
 299         according to the standard mapping or be a custom mapping.
 300      */
 301
 302     if ( ( column < 1 ) || ( column > m_aProps.getLength() ) )
 303         return DataType::SQLNULL;
 304
 305     if ( m_aProps.getConstArray()[ column - 1 ].Type
 306             == cppu::UnoType<void>::get() )
 307     {
 308         // No type given. Try UCB's Properties Manager...
 309
 310         osl::Guard< osl::Mutex > aGuard( m_pImpl->m_aMutex );
 311
 312         if ( !m_pImpl->m_bObtainedTypes )
 313         {
 314             try
 315             {
 316                 Reference< XPropertySetInfo > xInfo = PropertiesManager::create( m_xContext );
 317     // Less (remote) calls...
 318
 319                 Sequence< Property > aProps = xInfo->getProperties();
 320                 const Property* pProps1 = aProps.getConstArray();
 321                 sal_Int32 nCount1 = aProps.getLength();
 322
 323                 sal_Int32 nCount = m_aProps.getLength();
 324                 Property* pProps = m_aProps.getArray();
 325                 for ( sal_Int32 n = 0; n < nCount; ++n )
 326                 {
 327                     Property& rProp = pProps[ n ];
 328
 329                     for ( sal_Int32 m = 0; m < nCount1; ++m )
 330                     {
 331                         const Property& rProp1 = pProps1[ m ];
 332                         if ( rProp.Name == rProp1.Name )
 333                         {
 334                             // Found...
 335                             rProp.Type = rProp1.Type;
 336                             break;
 337                         }
 338                     }
 339                 }
 340             }
 341             catch ( RuntimeException& )
 342             {
 343                 throw;
 344             }
 345             catch ( Exception& )
 346             {
 347                 // createInstance
 348             }
 349
 350             m_pImpl->m_bObtainedTypes = true;
 351         }
 352     }
 353
 354     const Type& rType = m_aProps.getConstArray()[ column - 1 ].Type;
 355     sal_Int32 nType = DataType::OTHER;
 356
 357     if ( rType == cppu::UnoType<OUString>::get() )
 358         nType = DataType::VARCHAR;  // XRow::getString
 359     else if ( rType == cppu::UnoType<bool>::get() )
 360         nType = DataType::BIT;      // XRow::getBoolean
 361     else if ( rType == cppu::UnoType<sal_Int32>::get() )
 362         nType = DataType::INTEGER;  // XRow::getInt
 363     else if ( rType == cppu::UnoType<sal_Int64>::get() )
 364         nType = DataType::BIGINT;   // XRow::getLong
 365     else if ( rType == cppu::UnoType<sal_Int16>::get() )
 366         nType = DataType::SMALLINT; // XRow::getShort
 367     else if ( rType == cppu::UnoType<sal_Int8>::get() )
 368         nType = DataType::TINYINT;  // XRow::getByte
 369     else if ( rType == cppu::UnoType<float>::get() )
 370         nType = DataType::REAL;     // XRow::getFloat
 371     else if ( rType == cppu::UnoType<double>::get() )
 372         nType = DataType::DOUBLE;   // XRow::getDouble
 373     else if ( rType == cppu::UnoType<Sequence<sal_Int8>>::get() )
 374         nType = DataType::VARBINARY;// XRow::getBytes
 375     else if ( rType == cppu::UnoType<Date>::get() )
 376         nType = DataType::DATE;     // XRow::getDate
 377     else if ( rType == cppu::UnoType<Time>::get() )
 378         nType = DataType::TIME;     // XRow::getTime
 379     else if ( rType == cppu::UnoType<DateTime>::get() )
 380         nType = DataType::TIMESTAMP;// XRow::getTimestamp
 381     else if ( rType == cppu::UnoType<XInputStream>::get() )
 382         nType = DataType::LONGVARBINARY;    // XRow::getBinaryStream
 383 //      nType = DataType::LONGVARCHAR;      // XRow::getCharacterStream
 384     else if ( rType == cppu::UnoType<XClob>::get() )
 385         nType = DataType::CLOB; // XRow::getClob
 386     else if ( rType == cppu::UnoType<XBlob>::get() )
 387         nType = DataType::BLOB; // XRow::getBlob
 388     else if ( rType == cppu::UnoType<XArray>::get() )
 389         nType = DataType::ARRAY;// XRow::getArray
 390     else if ( rType == cppu::UnoType<XRef>::get() )
 391         nType = DataType::REF;// XRow::getRef
 392     else
 393         nType = DataType::OBJECT;// XRow::getObject
 394
 395     return nType;
 396 }
 397
 398
 399 // virtual
 400 OUString SAL_CALL ResultSetMetaData::getColumnTypeName( sal_Int32 /*column*/ )
 401 {
 402     /*
 403         Gets the type name used by this particular data source for the
 404         values stored in column. If the type code for the type of value
 405         stored in column is STRUCT, DISTINCT or JAVA_OBJECT, this method
 406         returns a fully-qualified SQL type name.
 407      */
 408     return OUString();
 409 }
 410
 411
 412 // virtual
 413 sal_Bool SAL_CALL ResultSetMetaData::isReadOnly( sal_Int32 /*column*/ )
 414 {
 415     return true;
 416 }
 417
 418
 419 // virtual
 420 sal_Bool SAL_CALL ResultSetMetaData::isWritable( sal_Int32 /*column*/ )
 421 {
 422     return false;
 423 }
 424
 425
 426 // virtual
 427 sal_Bool SAL_CALL ResultSetMetaData::isDefinitelyWritable( sal_Int32 /*column*/ )
 428 {
 429     return false;
 430 }
 431
 432
 433 // virtual
 434 OUString SAL_CALL ResultSetMetaData::getColumnServiceName( sal_Int32 /*column*/ )
 435 {
 436     /*
 437           Returns the fully-qualified name of the service whose instances
 438          are manufactured if XResultSet::getObject is called to retrieve
 439         a value from the column.
 440      */
 441     return OUString();
 442 }
 443
 444 } // namespace ucbhelper
 445
 446 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */