connectivity/source/drivers/odbc/OResultSetMetaData.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 #include <odbc/OResultSetMetaData.hxx>
  21 #include <odbc/OTools.hxx>
  22
  23 using namespace connectivity::odbc;
  24 using namespace com::sun::star::uno;
  25 using namespace com::sun::star::sdbc;
  26
  27
  28 OResultSetMetaData::~OResultSetMetaData()
  29 {
  30 }
  31
  32 OUString OResultSetMetaData::getCharColAttrib(sal_Int32 _column,sal_Int32 ident)
  33 {
  34     sal_Int32 column = _column;
  35     if(_column <static_cast<sal_Int32>(m_vMapping.size())) // use mapping
  36         column = m_vMapping[_column];
  37
  38     OUString sValue;
  39     SQLSMALLINT cbRealLen = 0;
  40     if (bUseWChar && functions().has(ODBC3SQLFunctionId::ColAttributeW))
  41     {
  42         // SQLColAttributeW gets/returns count of bytes, not characters
  43         SQLSMALLINT cbBufferLen = 128 * sizeof(SQLWCHAR);
  44         auto pName = std::make_unique<SQLWCHAR[]>(cbBufferLen / sizeof(SQLWCHAR) + 1);
  45         SQLRETURN nRet = functions().ColAttributeW(m_aStatementHandle,
  46                                                    column,
  47                                                    ident,
  48                                                    pName.get(),
  49                                                    cbBufferLen,
  50                                                    &cbRealLen,
  51                                                    nullptr);
  52         OTools::ThrowException(m_pConnection, nRet, m_aStatementHandle, SQL_HANDLE_STMT, *this);
  53         if (nRet == SQL_SUCCESS)
  54         {
  55             if (cbRealLen < 0)
  56                 cbRealLen = cbBufferLen;
  57             sValue = toUString(pName.get(), cbRealLen / sizeof(SQLWCHAR));
  58         }
  59         if (cbRealLen > cbBufferLen)
  60         {
  61             cbBufferLen = (cbRealLen + 1) & ~1; // Make sure it's even
  62             pName = std::make_unique<SQLWCHAR[]>(cbBufferLen / sizeof(SQLWCHAR) + 1);
  63             nRet = functions().ColAttributeW(m_aStatementHandle,
  64                                              column,
  65                                              ident,
  66                                              pName.get(),
  67                                              cbBufferLen,
  68                                              &cbRealLen,
  69                                              nullptr);
  70             OTools::ThrowException(m_pConnection, nRet, m_aStatementHandle, SQL_HANDLE_STMT, *this);
  71             if (nRet == SQL_SUCCESS && cbRealLen > 0)
  72                 sValue = toUString(pName.get(), cbRealLen / sizeof(SQLWCHAR));
  73         }
  74     }
  75     else
  76     {
  77         SQLSMALLINT BUFFER_LEN = 128;
  78         auto pName = std::make_unique<SQLCHAR[]>(BUFFER_LEN + 1);
  79         SQLRETURN nRet = functions().ColAttribute(m_aStatementHandle,
  80                                         static_cast<SQLUSMALLINT>(column),
  81                                         static_cast<SQLUSMALLINT>(ident),
  82                                         static_cast<SQLPOINTER>(pName.get()),
  83                                         BUFFER_LEN,
  84                                         &cbRealLen,
  85                                         nullptr
  86                                         );
  87         if ( nRet == SQL_SUCCESS )
  88         {
  89             if ( cbRealLen < 0 )
  90                 cbRealLen = BUFFER_LEN;
  91             sValue = toUString(pName.get(), cbRealLen, m_pConnection->getTextEncoding());
  92         }
  93         OTools::ThrowException(m_pConnection,nRet,m_aStatementHandle,SQL_HANDLE_STMT,*this);
  94         if(cbRealLen > BUFFER_LEN)
  95         {
  96             pName = std::make_unique<SQLCHAR[]>(cbRealLen + 1);
  97             nRet = functions().ColAttribute(m_aStatementHandle,
  98                                         static_cast<SQLUSMALLINT>(column),
  99                                         static_cast<SQLUSMALLINT>(ident),
 100                                         static_cast<SQLPOINTER>(pName.get()),
 101                                         cbRealLen,
 102                                         &cbRealLen,
 103                                         nullptr
 104                                         );
 105             if ( nRet == SQL_SUCCESS && cbRealLen > 0)
 106                 sValue = toUString(pName.get(), cbRealLen, m_pConnection->getTextEncoding());
 107             OTools::ThrowException(m_pConnection,nRet,m_aStatementHandle,SQL_HANDLE_STMT,*this);
 108         }
 109     }
 110
 111     return  sValue;
 112 }
 113
 114 SQLLEN OResultSetMetaData::getNumColAttrib(OConnection const * _pConnection
 115                                               ,SQLHANDLE _aStatementHandle
 116                                               ,const css::uno::Reference< css::uno::XInterface >& _xInterface
 117                                               ,sal_Int32 _column
 118                                               ,sal_Int32 _ident)
 119 {
 120     SQLLEN nValue=0;
 121     OTools::ThrowException(_pConnection,_pConnection->functions().ColAttribute(_aStatementHandle,
 122                                          static_cast<SQLUSMALLINT>(_column),
 123                                          static_cast<SQLUSMALLINT>(_ident),
 124                                          nullptr,
 125                                          0,
 126                                          nullptr,
 127                                          &nValue),_aStatementHandle,SQL_HANDLE_STMT,_xInterface);
 128     return nValue;
 129 }
 130
 131 sal_Int32 OResultSetMetaData::getNumColAttrib(sal_Int32 _column,sal_Int32 ident)
 132 {
 133     sal_Int32 column = _column;
 134     if(_column < static_cast<sal_Int32>(m_vMapping.size())) // use mapping
 135         column = m_vMapping[_column];
 136
 137     return getNumColAttrib(m_pConnection,m_aStatementHandle,*this,column,ident);
 138 }
 139
 140 sal_Int32 SAL_CALL OResultSetMetaData::getColumnDisplaySize( sal_Int32 column )
 141 {
 142     return getNumColAttrib(column,SQL_DESC_DISPLAY_SIZE);
 143 }
 144
 145 SQLSMALLINT OResultSetMetaData::getColumnODBCType(OConnection const * _pConnection
 146                                               ,SQLHANDLE _aStatementHandle
 147                                               ,const css::uno::Reference< css::uno::XInterface >& _xInterface
 148                                               ,sal_Int32 column)
 149 {
 150     SQLSMALLINT nType = 0;
 151     try
 152     {
 153         nType = static_cast<SQLSMALLINT>(getNumColAttrib(_pConnection,_aStatementHandle,_xInterface,column,SQL_DESC_CONCISE_TYPE));
 154         if(nType == SQL_UNKNOWN_TYPE)
 155             nType = static_cast<SQLSMALLINT>(getNumColAttrib(_pConnection,_aStatementHandle,_xInterface,column, SQL_DESC_TYPE));
 156     }
 157     catch(SQLException& ) // in this case we have an odbc 2.0 driver
 158     {
 159         nType = static_cast<SQLSMALLINT>(getNumColAttrib(_pConnection,_aStatementHandle,_xInterface,column,SQL_DESC_CONCISE_TYPE ));
 160     }
 161
 162     return nType;
 163 }
 164
 165 sal_Int32 SAL_CALL OResultSetMetaData::getColumnType( sal_Int32 column )
 166 {
 167     std::map<sal_Int32,sal_Int32>::iterator aFind = m_aColumnTypes.find(column);
 168     if ( aFind == m_aColumnTypes.end() )
 169     {
 170         sal_Int32 nType = 0;
 171         if(!m_bUseODBC2Types)
 172         {
 173             try
 174             {
 175                 nType = getNumColAttrib(column,SQL_DESC_CONCISE_TYPE);
 176                 if(nType == SQL_UNKNOWN_TYPE)
 177                     nType = getNumColAttrib(column, SQL_DESC_TYPE);
 178                 nType = OTools::MapOdbcType2Jdbc(nType);
 179             }
 180             catch(SQLException& ) // in this case we have an odbc 2.0 driver
 181             {
 182                 m_bUseODBC2Types = true;
 183             }
 184         }
 185         if (m_bUseODBC2Types)
 186             nType = OTools::MapOdbcType2Jdbc(getNumColAttrib(column, SQL_DESC_CONCISE_TYPE));
 187         aFind = m_aColumnTypes.emplace(column,nType).first;
 188     }
 189
 190
 191     return aFind->second;
 192 }
 193
 194
 195 sal_Int32 SAL_CALL OResultSetMetaData::getColumnCount(  )
 196 {
 197     if(m_nColCount != -1)
 198         return m_nColCount;
 199     sal_Int16 nNumResultCols=0;
 200     OTools::ThrowException(m_pConnection,functions().NumResultCols(m_aStatementHandle,&nNumResultCols),m_aStatementHandle,SQL_HANDLE_STMT,*this);
 201     m_nColCount = nNumResultCols;
 202     return m_nColCount;
 203 }
 204
 205
 206 sal_Bool SAL_CALL OResultSetMetaData::isCaseSensitive( sal_Int32 column )
 207 {
 208     return getNumColAttrib(column,SQL_DESC_CASE_SENSITIVE) == SQL_TRUE;
 209 }
 210
 211
 212 OUString SAL_CALL OResultSetMetaData::getSchemaName( sal_Int32 column )
 213 {
 214     return getCharColAttrib(column,SQL_DESC_SCHEMA_NAME);
 215 }
 216
 217
 218 OUString SAL_CALL OResultSetMetaData::getColumnName( sal_Int32 column )
 219 {
 220     return getCharColAttrib(column,SQL_DESC_NAME);
 221 }
 222
 223 OUString SAL_CALL OResultSetMetaData::getTableName( sal_Int32 column )
 224 {
 225     return getCharColAttrib(column,SQL_DESC_TABLE_NAME);
 226 }
 227
 228 OUString SAL_CALL OResultSetMetaData::getCatalogName( sal_Int32 column )
 229 {
 230     return getCharColAttrib(column,SQL_DESC_CATALOG_NAME);
 231 }
 232
 233 OUString SAL_CALL OResultSetMetaData::getColumnTypeName( sal_Int32 column )
 234 {
 235     return getCharColAttrib(column,SQL_DESC_TYPE_NAME);
 236 }
 237
 238 OUString SAL_CALL OResultSetMetaData::getColumnLabel( sal_Int32 column )
 239 {
 240     return getCharColAttrib(column,SQL_DESC_LABEL);
 241 }
 242
 243 OUString SAL_CALL OResultSetMetaData::getColumnServiceName( sal_Int32 /*column*/ )
 244 {
 245     return OUString();
 246 }
 247
 248
 249 sal_Bool SAL_CALL OResultSetMetaData::isCurrency( sal_Int32 column )
 250 {
 251     return getNumColAttrib(column,SQL_DESC_FIXED_PREC_SCALE) == SQL_TRUE;
 252 }
 253
 254
 255 sal_Bool SAL_CALL OResultSetMetaData::isAutoIncrement( sal_Int32 column )
 256 {
 257     return getNumColAttrib(column,SQL_DESC_AUTO_UNIQUE_VALUE) == SQL_TRUE;
 258 }
 259
 260
 261 sal_Bool SAL_CALL OResultSetMetaData::isSigned( sal_Int32 column )
 262 {
 263     return getNumColAttrib(column,SQL_DESC_UNSIGNED) == SQL_FALSE;
 264 }
 265
 266 sal_Int32 SAL_CALL OResultSetMetaData::getPrecision( sal_Int32 column )
 267 {
 268     sal_Int32 nType = 0;
 269     if (!m_bUseODBC2Types)
 270     {
 271         try
 272         {
 273             nType = getNumColAttrib(column, SQL_DESC_PRECISION);
 274         }
 275         catch (const SQLException&) // in this case we have an odbc 2.0 driver
 276         {
 277             m_bUseODBC2Types = true;
 278         }
 279     }
 280     if (m_bUseODBC2Types)
 281         nType = getNumColAttrib(column, SQL_COLUMN_PRECISION);
 282     return nType;
 283 }
 284
 285 sal_Int32 SAL_CALL OResultSetMetaData::getScale( sal_Int32 column )
 286 {
 287     sal_Int32 nType = 0;
 288     if (!m_bUseODBC2Types)
 289     {
 290         try
 291         {
 292             nType = getNumColAttrib(column, SQL_DESC_SCALE);
 293         }
 294         catch (const SQLException&) // in this case we have an odbc 2.0 driver
 295         {
 296             m_bUseODBC2Types = true;
 297         }
 298     }
 299     if (m_bUseODBC2Types)
 300         nType = getNumColAttrib(column, SQL_COLUMN_SCALE);
 301     return nType;
 302 }
 303
 304
 305 sal_Int32 SAL_CALL OResultSetMetaData::isNullable( sal_Int32 column )
 306 {
 307     return getNumColAttrib(column,SQL_DESC_NULLABLE);
 308 }
 309
 310
 311 sal_Bool SAL_CALL OResultSetMetaData::isSearchable( sal_Int32 column )
 312 {
 313     return getNumColAttrib(column,SQL_DESC_SEARCHABLE) != SQL_PRED_NONE;
 314 }
 315
 316
 317 sal_Bool SAL_CALL OResultSetMetaData::isReadOnly( sal_Int32 column )
 318 {
 319     return getNumColAttrib(column,SQL_DESC_UPDATABLE) == SQL_ATTR_READONLY;
 320 }
 321
 322
 323 sal_Bool SAL_CALL OResultSetMetaData::isDefinitelyWritable( sal_Int32 column )
 324 {
 325     return getNumColAttrib(column,SQL_DESC_UPDATABLE) == SQL_ATTR_WRITE;
 326 }
 327
 328 sal_Bool SAL_CALL OResultSetMetaData::isWritable( sal_Int32 column )
 329 {
 330     return getNumColAttrib(column,SQL_DESC_UPDATABLE) == SQL_ATTR_WRITE;
 331 }
 332
 333
 334 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */