connectivity/source/drivers/firebird/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 #include "ResultSetMetaData.hxx"
  21 #include "Util.hxx"
  22
  23 #include <com/sun/star/sdbc/ColumnValue.hpp>
  24 #include <com/sun/star/sdbcx/XColumnsSupplier.hpp>
  25 #include <com/sun/star/sdbc/XRow.hpp>
  26 #include <com/sun/star/sdbc/DataType.hpp>
  27
  28 using namespace connectivity::firebird;
  29
  30 using namespace com::sun::star::lang;
  31 using namespace com::sun::star::sdbc;
  32 using namespace com::sun::star::sdbcx;
  33 using namespace com::sun::star::uno;
  34
  35 using com::sun::star::beans::XPropertySet;
  36 using com::sun::star::container::XNameAccess;
  37
  38 OResultSetMetaData::~OResultSetMetaData()
  39 {
  40 }
  41
  42 void OResultSetMetaData::verifyValidColumn(sal_Int32 column)
  43     throw(SQLException)
  44 {
  45     if (column>getColumnCount() || column < 1)
  46         throw SQLException("Invalid column specified", *this, OUString(), 0, Any());
  47 }
  48
  49 sal_Int32 SAL_CALL OResultSetMetaData::getColumnCount() throw(SQLException, RuntimeException, std::exception)
  50 {
  51     return m_pSqlda->sqld;
  52 }
  53
  54 sal_Int32 SAL_CALL OResultSetMetaData::getColumnDisplaySize( sal_Int32 column ) throw(SQLException, RuntimeException, std::exception)
  55 {
  56     verifyValidColumn(column);
  57     return 32; // Hard limit for firebird
  58 }
  59
  60 sal_Int32 SAL_CALL OResultSetMetaData::getColumnType(sal_Int32 column)
  61     throw(SQLException, RuntimeException, std::exception)
  62 {
  63     verifyValidColumn(column);
  64
  65     short aType = m_pSqlda->sqlvar[column-1].sqltype;
  66     short aSubType = m_pSqlda->sqlvar[column-1].sqlsubtype;
  67
  68     return getColumnTypeFromFBType(aType, aSubType);
  69 }
  70
  71 sal_Bool SAL_CALL OResultSetMetaData::isCaseSensitive(sal_Int32 column)
  72     throw(SQLException, RuntimeException, std::exception)
  73 {
  74     // Firebird is generally case sensitive when using quoted identifiers.
  75     // IF THIS CHANGES make ResultSet::findColumn to be case-insensitive as needed.
  76     // Generally names that are entirely UPPERCASE are case insensitive, however
  77     // there remains some ambiguity if there is another mixed-case-named column
  78     // of the same name. For safety always assume case insensitive.
  79     (void) column;
  80     return true;
  81 }
  82
  83 OUString SAL_CALL OResultSetMetaData::getSchemaName(sal_Int32 column)
  84     throw(SQLException, RuntimeException, std::exception)
  85 {
  86     (void) column;
  87     return OUString(); // Schemas supported by firebird
  88 }
  89
  90 OUString SAL_CALL OResultSetMetaData::getColumnName(sal_Int32 column)
  91     throw(SQLException, RuntimeException, std::exception)
  92 {
  93     verifyValidColumn(column);
  94     OUString sRet(m_pSqlda->sqlvar[column-1].sqlname,
  95                     m_pSqlda->sqlvar[column-1].sqlname_length,
  96                     RTL_TEXTENCODING_UTF8);
  97     sanitizeIdentifier(sRet);
  98     return sRet;
  99 }
 100
 101 OUString SAL_CALL OResultSetMetaData::getTableName(sal_Int32 column)
 102     throw(SQLException, RuntimeException, std::exception)
 103 {
 104     verifyValidColumn(column);
 105     return OUString(m_pSqlda->sqlvar[column-1].relname,
 106                     m_pSqlda->sqlvar[column-1].relname_length,
 107                     RTL_TEXTENCODING_UTF8);
 108 }
 109
 110 OUString SAL_CALL OResultSetMetaData::getCatalogName(sal_Int32 column)
 111     throw(SQLException, RuntimeException, std::exception)
 112 {
 113     (void) column;
 114     return OUString(); // Catalogs not supported by firebird
 115 }
 116
 117 OUString SAL_CALL OResultSetMetaData::getColumnTypeName(sal_Int32 column)
 118     throw(SQLException, RuntimeException, std::exception)
 119 {
 120     verifyValidColumn(column);
 121
 122     short aType = m_pSqlda->sqlvar[column-1].sqltype;
 123     short aSubType = m_pSqlda->sqlvar[column-1].sqlsubtype;
 124
 125     return getColumnTypeNameFromFBType(aType, aSubType);
 126 }
 127
 128 OUString SAL_CALL OResultSetMetaData::getColumnLabel(sal_Int32 column)
 129     throw(SQLException, RuntimeException, std::exception)
 130 {
 131     // aliasname
 132     verifyValidColumn(column);
 133     OUString sRet(m_pSqlda->sqlvar[column-1].aliasname,
 134                     m_pSqlda->sqlvar[column-1].aliasname_length,
 135                     RTL_TEXTENCODING_UTF8);
 136     sanitizeIdentifier(sRet);
 137     return sRet;
 138 }
 139
 140 OUString SAL_CALL OResultSetMetaData::getColumnServiceName(sal_Int32 column)
 141     throw(SQLException, RuntimeException, std::exception)
 142 {
 143     // TODO: implement
 144     (void) column;
 145     return OUString();
 146 }
 147
 148 sal_Bool SAL_CALL OResultSetMetaData::isCurrency(sal_Int32 column)
 149     throw(SQLException, RuntimeException, std::exception)
 150 {
 151     (void) column;
 152     return false;
 153 }
 154
 155 sal_Bool SAL_CALL OResultSetMetaData::isAutoIncrement(sal_Int32 column)
 156     throw(SQLException, RuntimeException, std::exception)
 157 {
 158     OUString sTable = getTableName(column);
 159     if( !sTable.isEmpty() )
 160     {
 161         OUString sColumnName = getColumnName( column );
 162
 163         OUString sSql = "SELECT RDB$IDENTITY_TYPE FROM RDB$RELATION_FIELDS "
 164                    "WHERE RDB$RELATION_NAME = '"
 165                    + escapeWith(sTable, '\'', '\'') + "' AND "
 166                    "RDB$FIELD_NAME = '"+ escapeWith(sColumnName, '\'', '\'') +"'";
 167
 168         Reference<XStatement> xStmt =m_pConnection ->createStatement();
 169
 170         Reference<XResultSet> xRes =
 171                 xStmt->executeQuery(sSql);
 172         Reference<XRow> xRow ( xRes, UNO_QUERY);
 173         if(xRes->next())
 174         {
 175             int iType = xRow->getShort(1);
 176             if(iType == 1) // IDENTITY
 177                 return true;
 178         }
 179         else
 180         {
 181             SAL_WARN("connectivity.firebird","Column '"
 182                     << sColumnName
 183                     << "' not found in database");
 184
 185             return false;
 186         }
 187     }
 188     return false;
 189 }
 190
 191
 192 sal_Bool SAL_CALL OResultSetMetaData::isSigned(sal_Int32 column)
 193     throw(SQLException, RuntimeException, std::exception)
 194 {
 195     // Unsigned values aren't supported in firebird.
 196     (void) column;
 197     return true;
 198 }
 199
 200 sal_Int32 SAL_CALL OResultSetMetaData::getPrecision(sal_Int32 column)
 201     throw(SQLException, RuntimeException, std::exception)
 202 {
 203     sal_Int32 nType = getColumnType(column);
 204     if( nType == DataType::NUMERIC || nType == DataType::DECIMAL )
 205     {
 206         OUString sColumnName = getColumnName( column );
 207
 208         // RDB$FIELD_SOURCE is a unique name of column per database
 209         OUString sSql = "SELECT RDB$FIELD_PRECISION FROM RDB$FIELDS "
 210                     " INNER JOIN RDB$RELATION_FIELDS "
 211                     " ON RDB$RELATION_FIELDS.RDB$FIELD_SOURCE = RDB$FIELDS.RDB$FIELD_NAME "
 212                     "WHERE RDB$RELATION_FIELDS.RDB$RELATION_NAME = '"
 213                     + escapeWith(getTableName(column), '\'', '\'') + "' AND "
 214                     "RDB$RELATION_FIELDS.RDB$FIELD_NAME = '"
 215                     + escapeWith(sColumnName, '\'', '\'') +"'";
 216         Reference<XStatement> xStmt= m_pConnection->createStatement();
 217
 218         Reference<XResultSet> xRes =
 219                 xStmt->executeQuery(sSql);
 220         Reference<XRow> xRow ( xRes, UNO_QUERY);
 221         if(xRes->next())
 222         {
 223             return (sal_Int32) xRow->getShort(1);
 224         }
 225         else
 226         {
 227             SAL_WARN("connectivity.firebird","Column '"
 228                     << sColumnName
 229                     << "' not found in database");
 230             return 0;
 231         }
 232     }
 233     return 0;
 234 }
 235
 236 sal_Int32 SAL_CALL OResultSetMetaData::getScale(sal_Int32 column)
 237     throw(css::sdbc::SQLException, css::uno::RuntimeException, std::exception)
 238 {
 239     return -(m_pSqlda->sqlvar[column-1].sqlscale); // fb stores negative number
 240 }
 241
 242 sal_Int32 SAL_CALL OResultSetMetaData::isNullable(sal_Int32 column)
 243     throw(SQLException, RuntimeException, std::exception)
 244 {
 245     if (m_pSqlda->sqlvar[column-1].sqltype & 1)
 246         return ColumnValue::NULLABLE;
 247     else
 248         return ColumnValue::NO_NULLS;
 249 }
 250
 251 sal_Bool SAL_CALL OResultSetMetaData::isSearchable(sal_Int32 column)
 252     throw(SQLException, RuntimeException, std::exception)
 253 {
 254     // TODO: Can the column be used as part of a where clause? Assume yes
 255     (void) column;
 256     return true;
 257 }
 258
 259 sal_Bool SAL_CALL OResultSetMetaData::isReadOnly(sal_Int32 column)
 260     throw(SQLException, RuntimeException, std::exception)
 261 {
 262     (void) column;
 263     return m_pConnection->isReadOnly(); // Readonly only available on db level
 264 }
 265
 266 sal_Bool SAL_CALL OResultSetMetaData::isDefinitelyWritable(sal_Int32 column)
 267     throw(SQLException, RuntimeException, std::exception)
 268 {
 269     (void) column;
 270     return !m_pConnection->isReadOnly();
 271 }
 272
 273 sal_Bool SAL_CALL OResultSetMetaData::isWritable( sal_Int32 column ) throw(SQLException, RuntimeException, std::exception)
 274 {
 275     (void) column;
 276     return !m_pConnection->isReadOnly();
 277 }
 278
 279
 280 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */