connectivity/source/drivers/postgresql/pq_resultset.cxx

   1 #include "pq_resultset.hxx"
   2 #include "pq_resultsetmetadata.hxx"
   3
   4 #include <com/sun/star/sdbc/ResultSetType.hpp>
   5 #include <com/sun/star/sdbc/DataType.hpp>
   6
   7 using rtl::OUString;
   8 using rtl::OUStringToOString;
   9
  10 using osl::MutexGuard;
  11
  12 using com::sun::star::uno::RuntimeException;
  13 using com::sun::star::uno::Any;
  14 using com::sun::star::uno::makeAny;
  15 using com::sun::star::uno::Reference;
  16 using com::sun::star::uno::XInterface;
  17
  18 using com::sun::star::sdbc::SQLException;
  19 using com::sun::star::sdbc::XResultSetMetaData;
  20
  21
  22 namespace pq_sdbc_driver
  23 {
  24 #define ASCII_STR(x) OUString( RTL_CONSTASCII_USTRINGPARAM( x ) )
  25
  26 void ResultSet::checkClosed()
  27     throw ( com::sun::star::sdbc::SQLException, com::sun::star::uno::RuntimeException )
  28 {
  29     if( ! m_result )
  30     {
  31         throw SQLException( ASCII_STR( "pq_resultset: already closed" ),
  32                             *this,  OUString(), 1, Any() );
  33     }
  34
  35     if( ! m_ppSettings || ! *m_ppSettings || ! (*m_ppSettings)->pConnection )
  36     {
  37         throw SQLException( ASCII_STR( "pq_resultset: statement has been closed already" ),
  38                             *this, OUString(), 1, Any() );
  39     }
  40
  41 }
  42
  43 ResultSet::ResultSet( const ::rtl::Reference< RefCountedMutex > & refMutex,
  44                       const Reference< XInterface > & owner,
  45                       ConnectionSettings **ppSettings,
  46                       PGresult * result,
  47                       const rtl::OUString &schema,
  48                       const rtl::OUString &table)
  49     : BaseResultSet(
  50         refMutex, owner, PQntuples( result ),
  51         PQnfields( result ),(*ppSettings)->tc ),
  52       m_ppSettings( ppSettings ),
  53       m_result( result ),
  54       m_schema( schema ),
  55       m_table( table )
  56 {
  57     sal_Bool b = sal_True;
  58 //     m_props[RESULTSET_IS_BOOKMARKABLE] = Any( &b, getBooleanCppuType() );
  59     m_props[ BASERESULTSET_RESULT_SET_TYPE] = makeAny(
  60         com::sun::star::sdbc::ResultSetType::SCROLL_INSENSITIVE );
  61 }
  62
  63
  64 Any ResultSet::getValue( sal_Int32 columnIndex )
  65 {
  66     Any ret;
  67     if( PQgetisnull( m_result, m_row, columnIndex -1 ) )
  68     {
  69         m_wasNull = true;
  70     }
  71     else
  72     {
  73         m_wasNull = false;
  74         ret <<= ::rtl::OUString(
  75             PQgetvalue( m_result, m_row , columnIndex -1 ) ,
  76             PQgetlength( m_result, m_row , columnIndex -1 ) ,
  77             (*m_ppSettings)->encoding );
  78
  79     }
  80     return ret;
  81 }
  82
  83 ResultSet::~ResultSet()
  84 {}
  85
  86 void ResultSet::close(  ) throw (SQLException, RuntimeException)
  87 {
  88     Reference< XInterface > owner;
  89     {
  90         MutexGuard guard( m_refMutex->mutex );
  91         if( m_result )
  92         {
  93             PQclear(m_result );
  94             m_result = 0;
  95             m_row = -1;
  96         }
  97         owner = m_owner;
  98         m_owner.clear();
  99     }
 100 }
 101
 102 Reference< XResultSetMetaData > ResultSet::getMetaData(  ) throw (SQLException, RuntimeException)
 103 {
 104     MutexGuard guard( m_refMutex->mutex );
 105     checkClosed();
 106     return new ResultSetMetaData(
 107         m_refMutex, this, this, m_ppSettings, m_result, m_schema, m_table );
 108 }
 109
 110 sal_Int32 ResultSet::findColumn( const ::rtl::OUString& columnName )
 111         throw (SQLException, RuntimeException)
 112 {
 113     MutexGuard guard( m_refMutex->mutex );
 114     checkClosed();
 115     return PQfnumber(
 116         m_result,
 117         OUStringToOString( columnName, (*m_ppSettings)->encoding ).getStr())
 118         +1;
 119 }
 120
 121 static bool isNumber( const char * data, sal_Int32 len )
 122 {
 123     bool ret = false;
 124     if( len )
 125     {
 126         ret = true;
 127         for( int i = 0 ; i < len ; i ++ )
 128         {
 129             if( ( data[i] >= '0' && data[i] <= '9' ) ||
 130                 data[i] == '-' || data[i] == '+' || data[i] == '.' || data[i] == ',' )
 131             {
 132                 if( data[i] == '-' && i != 0 && i != len-1 )
 133                 {
 134                     // no number, maybe a date
 135                     ret = false;
 136                     break;
 137                 }
 138             }
 139             else
 140             {
 141                 ret = false;
 142                 break;
 143             }
 144         }
 145     }
 146     return ret;
 147 }
 148
 149 static bool isInteger( const char * data, sal_Int32 len )
 150 {
 151     bool ret = false;
 152     if( len )
 153     {
 154         ret = true;
 155         for( int i = 0 ; i < len ; i ++ )
 156         {
 157             if( ( data[i] >= '0' && data[i] <= '9' ) ||
 158                 data[i] == '-' || data[i] == '+' )
 159             {
 160                 if( data[i] == '-' && i != 0 && i != len-1 )
 161                 {
 162                     // no number, maybe a date
 163                     ret = false;
 164                     break;
 165                 }
 166             }
 167             else
 168             {
 169                 ret = false;
 170                 break;
 171             }
 172         }
 173     }
 174     return ret;
 175 }
 176
 177 static bool isDate( const char * data, sal_Int32 len )
 178 {
 179     bool ret = false;
 180     return 10 == len &&
 181         '-' == data[4] &&
 182         '-' == data[7] &&
 183         isInteger( &(data[0]),4 ) &&
 184         isInteger( &(data[5]),2) &&
 185         isInteger( &(data[8]),2 );
 186 }
 187
 188 static bool isTime( const char * data, sal_Int32 len )
 189 {
 190     bool ret = false;
 191     return 8 == len &&
 192         ':' == data[2] &&
 193         ':' == data[5] &&
 194         isInteger( &(data[0]),2 ) &&
 195         isInteger( &(data[3]),2) &&
 196         isInteger( &(data[6]),2 );
 197
 198 }
 199
 200 static bool isTimestamp( const char * data, sal_Int32 len )
 201 {
 202     return len == 19 && isDate( data, 10) && isTime( &(data[11]),8 );
 203 }
 204
 205 sal_Int32 ResultSet::guessDataType( sal_Int32 column )
 206 {
 207     // we don't look into more than 100 rows ...
 208     sal_Int32 ret = com::sun::star::sdbc::DataType::INTEGER;
 209
 210     int maxRows = ( m_rowCount > 100 ? 100 : m_rowCount );
 211     for( int i = 0 ; i < maxRows ; i ++ )
 212     {
 213         if( ! PQgetisnull( m_result, i , column-1  ) )
 214         {
 215             const char * p = PQgetvalue( m_result, i , column -1 );
 216             int len = PQgetlength( m_result, i , column -1 );
 217
 218             if( com::sun::star::sdbc::DataType::INTEGER == ret )
 219             {
 220                 if( ! isInteger( p,len ) )
 221                     ret = com::sun::star::sdbc::DataType::NUMERIC;
 222             }
 223             if( com::sun::star::sdbc::DataType::NUMERIC == ret )
 224             {
 225                 if( ! isNumber( p,len ) )
 226                 {
 227                     ret = com::sun::star::sdbc::DataType::DATE;
 228                 }
 229             }
 230             if( com::sun::star::sdbc::DataType::DATE == ret )
 231             {
 232                 if( ! isDate( p,len ) )
 233                 {
 234                     ret = com::sun::star::sdbc::DataType::TIME;
 235                 }
 236             }
 237             if( com::sun::star::sdbc::DataType::TIME == ret )
 238             {
 239                 if( ! isTime( p,len ) )
 240                 {
 241                     ret = com::sun::star::sdbc::DataType::TIMESTAMP;
 242                 }
 243             }
 244             if( com::sun::star::sdbc::DataType::TIMESTAMP == ret )
 245             {
 246                 if( ! isTimestamp( p,len ) )
 247                 {
 248                     ret = com::sun::star::sdbc::DataType::LONGVARCHAR;
 249                     break;
 250                 }
 251             }
 252         }
 253     }
 254     return ret;
 255 }
 256
 257 }