connectivity/source/drivers/postgresql/pq_resultset.cxx

   1 /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
   2 /*************************************************************************
   3  *
   4  *  Effective License of whole file:
   5  *
   6  *    This library is free software; you can redistribute it and/or
   7  *    modify it under the terms of the GNU Lesser General Public
   8  *    License version 2.1, as published by the Free Software Foundation.
   9  *
  10  *    This library is distributed in the hope that it will be useful,
  11  *    but WITHOUT ANY WARRANTY; without even the implied warranty of
  12  *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  13  *    Lesser General Public License for more details.
  14  *
  15  *    You should have received a copy of the GNU Lesser General Public
  16  *    License along with this library; if not, write to the Free Software
  17  *    Foundation, Inc., 59 Temple Place, Suite 330, Boston,
  18  *    MA  02111-1307  USA
  19  *
  20  *  Parts "Copyright by Sun Microsystems, Inc" prior to August 2011:
  21  *
  22  *    The Contents of this file are made available subject to the terms of
  23  *    the GNU Lesser General Public License Version 2.1
  24  *
  25  *    Copyright: 2000 by Sun Microsystems, Inc.
  26  *
  27  *    Contributor(s): Joerg Budischewski
  28  *
  29  *  All parts contributed on or after August 2011:
  30  *
  31  *    This Source Code Form is subject to the terms of the Mozilla Public
  32  *    License, v. 2.0. If a copy of the MPL was not distributed with this
  33  *    file, You can obtain one at http://mozilla.org/MPL/2.0/.
  34  *
  35  ************************************************************************/
  36
  37 #include "pq_resultset.hxx"
  38 #include "pq_resultsetmetadata.hxx"
  39
  40 #include <connectivity/dbexception.hxx>
  41
  42 #include <com/sun/star/sdbc/FetchDirection.hpp>
  43 #include <com/sun/star/sdbc/ResultSetConcurrency.hpp>
  44 #include <com/sun/star/sdbc/ResultSetType.hpp>
  45 #include <com/sun/star/sdbc/DataType.hpp>
  46 #include <com/sun/star/sdbc/SQLException.hpp>
  47 #include <utility>
  48
  49
  50 using osl::MutexGuard;
  51
  52 using com::sun::star::uno::Any;
  53 using com::sun::star::uno::Reference;
  54 using com::sun::star::uno::XInterface;
  55
  56 using com::sun::star::sdbc::SQLException;
  57 using com::sun::star::sdbc::XResultSetMetaData;
  58
  59
  60 namespace pq_sdbc_driver
  61 {
  62
  63 void ResultSet::checkClosed()
  64 {
  65     if( ! m_result )
  66     {
  67         throw SQLException( u"pq_resultset: already closed"_ustr,
  68                             *this,  OUString(), 1, Any() );
  69     }
  70
  71     if( ! m_ppSettings || ! *m_ppSettings || ! (*m_ppSettings)->pConnection )
  72     {
  73         throw SQLException( u"pq_resultset: statement has been closed already"_ustr,
  74                             *this, OUString(), 1, Any() );
  75     }
  76
  77 }
  78
  79 ResultSet::ResultSet( const ::rtl::Reference< comphelper::RefCountedMutex > & refMutex,
  80                       const Reference< XInterface > & owner,
  81                       ConnectionSettings **ppSettings,
  82                       PGresult * result,
  83                       OUString schema,
  84                       OUString table)
  85     : BaseResultSet(
  86         refMutex, owner, PQntuples( result ),
  87         PQnfields( result ),(*ppSettings)->tc ),
  88       m_result( result ),
  89       m_schema(std::move( schema )),
  90       m_table(std::move( table )),
  91       m_ppSettings( ppSettings )
  92 {
  93     // LEM TODO: shouldn't these things be inherited from the statement or something like that?
  94     // Positioned update/delete not supported, so no cursor name
  95     // Fetch direction and size are cursor-specific things, so not used now.
  96     // Fetch size not set
  97     m_props[ BASERESULTSET_FETCH_DIRECTION ] <<= css::sdbc::FetchDirection::UNKNOWN;
  98     // No escape processing for now
  99     m_props[ BASERESULTSET_ESCAPE_PROCESSING ] <<= false;
 100     // Bookmarks not implemented for now
 101     m_props[ BASERESULTSET_IS_BOOKMARKABLE ] <<= false;
 102     m_props[ BASERESULTSET_RESULT_SET_CONCURRENCY ] <<= css::sdbc::ResultSetConcurrency::READ_ONLY;
 103     m_props[ BASERESULTSET_RESULT_SET_TYPE ] <<= css::sdbc::ResultSetType::SCROLL_INSENSITIVE;
 104 }
 105
 106
 107 Any ResultSet::getValue( sal_Int32 columnIndex )
 108 {
 109     Any ret;
 110     if( PQgetisnull( m_result, m_row, columnIndex -1 ) )
 111     {
 112         m_wasNull = true;
 113     }
 114     else
 115     {
 116         m_wasNull = false;
 117         ret <<= OUString(
 118             PQgetvalue( m_result, m_row , columnIndex -1 ) ,
 119             PQgetlength( m_result, m_row , columnIndex -1 ) ,
 120             ConnectionSettings::encoding );
 121
 122     }
 123     return ret;
 124 }
 125
 126 ResultSet::~ResultSet()
 127 {}
 128
 129 void ResultSet::close(  )
 130 {
 131     Reference< XInterface > owner;
 132     {
 133         MutexGuard guard( m_xMutex->GetMutex() );
 134         if( m_result )
 135         {
 136             PQclear(m_result );
 137             m_result = nullptr;
 138             m_row = -1;
 139         }
 140         owner = m_owner;
 141         m_owner.clear();
 142     }
 143 }
 144
 145 Reference< XResultSetMetaData > ResultSet::getMetaData(  )
 146 {
 147     MutexGuard guard( m_xMutex->GetMutex() );
 148     checkClosed();
 149     return new ResultSetMetaData(
 150         m_xMutex, this, this, m_ppSettings, m_result, m_schema, m_table );
 151 }
 152
 153 sal_Int32 ResultSet::findColumn( const OUString& columnName )
 154 {
 155     MutexGuard guard( m_xMutex->GetMutex() );
 156     checkClosed();
 157     sal_Int32 res = PQfnumber( m_result,
 158                                OUStringToOString( columnName, ConnectionSettings::encoding ).getStr());
 159     /* PQfnumber return -1 for not found, which is what we want
 160      * other than that we use col number as 1-based not 0-based */
 161     if(res >= 0)
 162     {
 163         res += 1;
 164     }
 165     else
 166     {
 167         ::dbtools::throwInvalidColumnException( columnName, *this );
 168     }
 169     return res;
 170 }
 171
 172 static bool isNumber( const char * data, sal_Int32 len )
 173 {
 174     bool ret = false;
 175     if( len )
 176     {
 177         ret = true;
 178         for( int i = 0 ; i < len ; i ++ )
 179         {
 180             if( ( data[i] >= '0' && data[i] <= '9' ) ||
 181                 data[i] == '-' || data[i] == '+' || data[i] == '.' || data[i] == ',' )
 182             {
 183                 if( data[i] == '-' && i != 0 && i != len-1 )
 184                 {
 185                     // no number, maybe a date
 186                     ret = false;
 187                     break;
 188                 }
 189             }
 190             else
 191             {
 192                 ret = false;
 193                 break;
 194             }
 195         }
 196     }
 197     return ret;
 198 }
 199
 200 static bool isInteger( const char * data, sal_Int32 len )
 201 {
 202     bool ret = false;
 203     if( len )
 204     {
 205         ret = true;
 206         for( int i = 0 ; i < len ; i ++ )
 207         {
 208             if( ( data[i] >= '0' && data[i] <= '9' ) ||
 209                 data[i] == '-' || data[i] == '+' )
 210             {
 211                 if( data[i] == '-' && i != 0 && i != len-1 )
 212                 {
 213                     // no number, maybe a date
 214                     ret = false;
 215                     break;
 216                 }
 217             }
 218             else
 219             {
 220                 ret = false;
 221                 break;
 222             }
 223         }
 224     }
 225     return ret;
 226 }
 227
 228 static bool isDate( const char * data, sal_Int32 len )
 229 {
 230     return 10 == len &&
 231         '-' == data[4] &&
 232         '-' == data[7] &&
 233         isInteger( &(data[0]),4 ) &&
 234         isInteger( &(data[5]),2) &&
 235         isInteger( &(data[8]),2 );
 236 }
 237
 238 static bool isTime( const char * data, sal_Int32 len )
 239 {
 240     return 8 == len &&
 241         ':' == data[2] &&
 242         ':' == data[5] &&
 243         isInteger( &(data[0]),2 ) &&
 244         isInteger( &(data[3]),2) &&
 245         isInteger( &(data[6]),2 );
 246
 247 }
 248
 249 static bool isTimestamp( const char * data, sal_Int32 len )
 250 {
 251     return len == 19 && isDate( data, 10) && isTime( &(data[11]),8 );
 252 }
 253
 254 sal_Int32 ResultSet::guessDataType( sal_Int32 column )
 255 {
 256     // we don't look into more than 100 rows ...
 257     sal_Int32 ret = css::sdbc::DataType::INTEGER;
 258
 259     int maxRows = std::min<sal_Int32>( m_rowCount, 100 );
 260     for( int i = 0 ; i < maxRows ; i ++ )
 261     {
 262         if( ! PQgetisnull( m_result, i , column-1  ) )
 263         {
 264             const char * p = PQgetvalue( m_result, i , column -1 );
 265             int len = PQgetlength( m_result, i , column -1 );
 266
 267             if( css::sdbc::DataType::INTEGER == ret )
 268             {
 269                 if( ! isInteger( p,len ) )
 270                     ret = css::sdbc::DataType::NUMERIC;
 271             }
 272             if( css::sdbc::DataType::NUMERIC == ret )
 273             {
 274                 if( ! isNumber( p,len ) )
 275                 {
 276                     ret = css::sdbc::DataType::DATE;
 277                 }
 278             }
 279             if( css::sdbc::DataType::DATE == ret )
 280             {
 281                 if( ! isDate( p,len ) )
 282                 {
 283                     ret = css::sdbc::DataType::TIME;
 284                 }
 285             }
 286             if( css::sdbc::DataType::TIME == ret )
 287             {
 288                 if( ! isTime( p,len ) )
 289                 {
 290                     ret = css::sdbc::DataType::TIMESTAMP;
 291                 }
 292             }
 293             if( css::sdbc::DataType::TIMESTAMP == ret )
 294             {
 295                 if( ! isTimestamp( p,len ) )
 296                 {
 297                     ret = css::sdbc::DataType::LONGVARCHAR;
 298                     break;
 299                 }
 300             }
 301         }
 302     }
 303     return ret;
 304 }
 305
 306 }
 307
 308 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */