[BACK]Return to parser3pgsql.C CVS log [TXT] [DIR] Up to [parser3project] / sql / pgsql

Diff for /sql/pgsql/parser3pgsql.C between versions 1.30 and 1.34

version 1.30, 2008/06/26 15:49:40 version 1.34, 2008/12/25 02:33:56
Line 16  static const char *RCSId="$Id$"; Line 16  static const char *RCSId="$Id$";
 #include <libpq-fe.h>  #include <libpq-fe.h>
 #include <libpq/libpq-fs.h>  #include <libpq/libpq-fs.h>
   
 // OIDOID from catalog/pg_type.h  // from catalog/pg_type.h
   #define BOOLOID                 16
   #define INT8OID                 20
   #define INT2OID                 21
   #define INT4OID                 23
 #define OIDOID                  26  #define OIDOID                  26
   #define FLOAT4OID               700
   #define FLOAT8OID               701
   #define DATEOID                 1082
   #define TIMEOID                 1083
   #define TIMESTAMPOID    1114
   #define TIMESTAMPTZOID  1184
   #define TIMETZOID               1266
   #define NUMERICOID              1700
   
 // LO_BUFSIZE from interfaces\libpq\fe-lobj.c = 8192 (0x2000)  // LO_BUFSIZE from interfaces\libpq\fe-lobj.c = 8192 (0x2000)
 // actually writing chunks of that size failed, reduced it twice  // actually writing chunks of that size failed, reduced it twice
 #define LO_BUFSIZE                0x1000  #define LO_BUFSIZE                0x1000
 // from postgres_ext.h  
 //#define InvalidOid            ((Oid) 0)  
   
   
 #include "ltdl.h"  #include "ltdl.h"
   
   #define MAX_COLS 500
   
 #define MAX_STRING 0x400  #define MAX_STRING 0x400
 #define MAX_NUMBER 20  #define MAX_NUMBER 20
   
Line 78  struct Connection { Line 91  struct Connection {
         PGconn *conn;          PGconn *conn;
         const char* client_charset;          const char* client_charset;
         bool autocommit;          bool autocommit;
           bool without_default_transactions;
 };  };
   
 /**  /**
Line 111  public: Line 125  public:
                         ClientCharset=charset&  // transcode by parser                          ClientCharset=charset&  // transcode by parser
                         charset=value&                  // transcode by server with 'SET CLIENT_ENCODING=value'                          charset=value&                  // transcode by server with 'SET CLIENT_ENCODING=value'
                         datestyle=value&                // 'SET DATESTYLE=value' available values are: ISO|SQL|Postgres|European|US|German [default=ISO]                          datestyle=value&                // 'SET DATESTYLE=value' available values are: ISO|SQL|Postgres|European|US|German [default=ISO]
                         autocommit=1&                          autocommit=1&                   // each transaction is commited automatically (default)
                         WithoutDefaultTransaction=1     // == autocommit=0                          WithoutDefaultTransaction=0     // 1 -- disable any BEGIN TRAN/COMMIT/ROLLBACK [can NOT be used with autocommit option]
         */          */
         void connect(          void connect(
                                 char* url,                                   char* url, 
Line 135  public: Line 149  public:
                 connection.services=&services;                  connection.services=&services;
                 connection.client_charset=0;                      connection.client_charset=0;    
                 connection.autocommit=true;                  connection.autocommit=true;
                   connection.without_default_transactions=false;
   
                 connection.conn=PQsetdbLogin(                  connection.conn=PQsetdbLogin(
                         (host&&strcasecmp(host, "local")==0)?NULL/* local Unix domain socket */:host, port,                           (host&&strcasecmp(host, "local")==0)?NULL/* local Unix domain socket */:host, port, 
                         NULL, NULL, db, user, pwd);                          NULL, NULL, db, user, pwd);
Line 149  public: Line 165  public:
                         if(char *key=lsplit(&options, '&')){                          if(char *key=lsplit(&options, '&')){
                                 if(*key){                                  if(*key){
                                         if(char *value=lsplit(key, '=')){                                          if(char *value=lsplit(key, '=')){
                                                 if(strcmp(key, "ClientCharset")==0){ // transcoding with parser                                                  if(strcmp(key, "ClientCharset")==0){
                                                         toupper_str(value, value, strlen(value));                                                          toupper_str(value, value, strlen(value));
                                                         connection.client_charset=value;                                                          connection.client_charset=value;
                                                 } else if(strcasecmp(key, "charset")==0){ // transcoding with server                                                  } else if(strcasecmp(key, "charset")==0){
                                                         charset=value;                                                          charset=value;
                                                 } else if(strcasecmp(key, "datestyle")==0){                                                  } else if(strcasecmp(key, "datestyle")==0){
                                                         datestyle=value;                                                          datestyle=value;
                                                 } else if(strcasecmp(key, "autocommit")==0){                                                  } else if(strcasecmp(key, "autocommit")==0){
                                                           if(connection.without_default_transactions)
                                                                   services._throw("options WithoutDefaultTransaction and autocommit can't be used together");
                                                         if(atoi(value)==0)                                                          if(atoi(value)==0)
                                                                 connection.autocommit=false;                                                                  connection.autocommit=false;
                                                 } else if(strcmp(key, "WithoutDefaultTransaction")==0){ // backward, use autocommit=0                                                  } else if(strcmp(key, "WithoutDefaultTransaction")==0){
                                                         if(atoi(value)==1)                                                          if(!connection.autocommit)
                                                                   services._throw("options WithoutDefaultTransaction and autocommit can't be used together");
                                                           if(atoi(value)==1){
                                                                   connection.without_default_transactions=true;
                                                                 connection.autocommit=false;                                                                  connection.autocommit=false;
                                                           }
                                                 } else                                                  } else
                                                         services._throw("unknown connect option" /*key*/);                                                          services._throw("unknown connect option" /*key*/);
                                         } else                                           } else 
Line 184  public: Line 206  public:
                         _execute_cmd(connection, statement);                          _execute_cmd(connection, statement);
                 }                  }
   
                 _begin_transaction(connection);                  _transaction_begin(connection);
         }          }
   
         void disconnect(void *aconnection){          void disconnect(void *aconnection){
Line 195  public: Line 217  public:
   
         void commit(void *aconnection){          void commit(void *aconnection){
                 Connection& connection=*static_cast<Connection*>(aconnection);                  Connection& connection=*static_cast<Connection*>(aconnection);
                 if(connection.autocommit){                  _transaction_commit(connection);
                         _execute_cmd(connection, "COMMIT");                  _transaction_begin(connection);
                 }  
                 _begin_transaction(connection);  
         }          }
   
         void rollback(void *aconnection){          void rollback(void *aconnection){
                 Connection& connection=*static_cast<Connection*>(aconnection);                  Connection& connection=*static_cast<Connection*>(aconnection);
                 if(connection.autocommit){                  _transaction_rollback(connection);
                         _execute_cmd(connection, "ROLLBACK");                  _transaction_begin(connection);
                 }  
                 _begin_transaction(connection);  
         }          }
   
         bool ping(void *aconnection) {          bool ping(void *aconnection) {
Line 230  public: Line 248  public:
                                 SQL_Driver_query_event_handlers& handlers                                  SQL_Driver_query_event_handlers& handlers
         ){          ){
                 Connection& connection=*static_cast<Connection*>(aconnection);                  Connection& connection=*static_cast<Connection*>(aconnection);
                 const char* client_charset=connection.client_charset;  
                 SQL_Driver_services& services=*connection.services;                  SQL_Driver_services& services=*connection.services;
                 PGconn *conn=connection.conn;                  PGconn *conn=connection.conn;
   
                 bool transcode_needed=_transcode_required(connection);                  const char* client_charset=connection.client_charset;
                   const char* request_charset=services.request_charset();
                   bool transcode_needed=client_charset && strcmp(client_charset, request_charset)!=0;
   
                 const char** paramValues;                  const char** paramValues;
                 if(placeholders_count>0){                  if(placeholders_count>0){
Line 243  public: Line 262  public:
                         _bind_parameters(placeholders_count, placeholders, paramValues, connection, transcode_needed);                          _bind_parameters(placeholders_count, placeholders, paramValues, connection, transcode_needed);
                 }                  }
   
                 // transcode query from $request:charset to ?ClientCharset  
                 if(transcode_needed){                  if(transcode_needed){
                           // transcode query from $request:charset to ?ClientCharset
                         size_t length=strlen(astatement);                          size_t length=strlen(astatement);
                         services.transcode(astatement, length,                          services.transcode(astatement, length,
                                 astatement, length,                                  astatement, length,
                                 services.request_charset(),                                  request_charset,
                                 connection.client_charset);                                  client_charset);
                 }                  }
   
                 const char *statement=_preprocess_statement(connection, astatement, offset, limit);                  const char *statement=_preprocess_statement(connection, astatement, offset, limit);
Line 264  public: Line 283  public:
                 if(!res)                   if(!res) 
                         throwPQerror;                          throwPQerror;
   
                   bool failed=false;
                   SQL_Error sql_error;
   
                 switch(PQresultStatus(res)) {                  switch(PQresultStatus(res)) {
                         case PGRES_EMPTY_QUERY:                           case PGRES_EMPTY_QUERY: 
                                 PQclear_throw("no query");                                  PQclear_throw("no query");
                                 break;                                  break;
                         case PGRES_COMMAND_OK: // empty result: insert|delete|update|...                          case PGRES_COMMAND_OK: // empty result: insert|delete|update|...
                                 PQclear(res);                                  PQclear(res);
                                   if(connection.autocommit)
                                           commit(aconnection);
                                 return;                                  return;
                         case PGRES_TUPLES_OK:                           case PGRES_TUPLES_OK: 
                                 break;                                    break;  
Line 278  public: Line 302  public:
                                 break;                                  break;
                 }                  }
                                   
                 int column_count=PQnfields(res);  
                 if(!column_count)  
                         PQclear_throw("result contains no columns");  
   
                 bool failed=false;  
                 SQL_Error sql_error;  
 #define CHECK(afailed) \  #define CHECK(afailed) \
                 if(afailed) { \                  if(afailed) { \
                         failed=true; \                          failed=true; \
                         goto cleanup; \                          goto cleanup; \
                 }                  }
   
                   int column_count=PQnfields(res);
                   if(!column_count)
                           PQclear_throw("result contains no columns");
   
                   if(column_count>MAX_COLS)
                           column_count=MAX_COLS;
   
                   unsigned int column_types[MAX_COLS];
                   bool transcode_column[MAX_COLS];
   
                 for(int i=0; i<column_count; i++){                  for(int i=0; i<column_count; i++){
                           column_types[i]=PQftype(res, i);
                           switch(column_types[i]){
                                   case BOOLOID:
                                   case INT8OID:
                                   case INT2OID:
                                   case INT4OID:
                                   case FLOAT4OID:
                                   case FLOAT8OID:
                                   case DATEOID:
                                   case TIMEOID:
                                   case TIMESTAMPOID:
                                   case TIMESTAMPTZOID:
                                   case TIMETZOID:
                                   case NUMERICOID:
                                           transcode_column[i]=false;
                                           break;
                                   default:
                                           transcode_column[i]=transcode_needed;
                                           break;
                           }
                         char *name=PQfname(res, i);                          char *name=PQfname(res, i);
                         size_t length=strlen(name);                          size_t length=strlen(name);
                         char* strm=(char*)services.malloc(length+1);                          char* strm=(char*)services.malloc(length+1);
                         memcpy(strm, name, length+1);                          memcpy(strm, name, length+1);
                         const char* str=strm;                          const char* str=strm;
   
                         // transcode column name from ?ClientCharset to $request:charset                          if(transcode_needed) // transcode column name from ?ClientCharset to $request:charset
                         if(transcode_needed)   
                                 services.transcode(str, length,                                  services.transcode(str, length,
                                         str, length,                                          str, length,
                                         connection.client_charset,                                          client_charset,
                                         services.request_charset());                                          request_charset);
   
                         CHECK(handlers.add_column(sql_error, str, length));                          CHECK(handlers.add_column(sql_error, str, length));
                 }                  }
Line 316  public: Line 363  public:
                                         const char *cell=PQgetvalue(res, r, i);                                          const char *cell=PQgetvalue(res, r, i);
                                         size_t length;                                          size_t length;
                                         const char* str;                                          const char* str;
                                         if(PQftype(res, i)==OIDOID) {  
                                                 // ObjectID column, read object bytes  
   
                                                 char *error_pos=0;                                          switch(column_types[i]){
                                                 Oid oid=cell?atoi(cell):0;                                                  case OIDOID:
                                                 int fd=lo_open(conn, oid, INV_READ);                                                          {
                                                 if(fd>=0) {                                                                  char *error_pos=0;
                                                         // seek to end                                                                  Oid oid=cell?atoi(cell):0;
                                                         if(lo_lseek(conn, fd, 0, SEEK_END)<0)                                                                  int fd=lo_open(conn, oid, INV_READ);
                                                                 PQclear_throwPQerror;                                                                  if(fd>=0){
                                                         // get length                                                                          // seek to end
                                                         int size_tell=lo_tell(conn, fd);                                                                          if(lo_lseek(conn, fd, 0, SEEK_END)<0)
                                                         if(size_tell<0)                                                                                  PQclear_throwPQerror;
                                                                 PQclear_throwPQerror;                                                                          // get length
                                                         // seek to begin                                                                          int size_tell=lo_tell(conn, fd);
                                                         if(lo_lseek(conn, fd, 0, SEEK_SET)<0)                                                                          if(size_tell<0)
                                                                 PQclear_throwPQerror;                                                                                  PQclear_throwPQerror;
                                                         length=(size_t)size_tell;                                                                          // seek to begin
                                                         if(length) {                                                                          if(lo_lseek(conn, fd, 0, SEEK_SET)<0)
                                                                 // read                                                                                   PQclear_throwPQerror;
                                                                           length=(size_t)size_tell;
                                                                           if(length){
                                                                                   // read 
                                                                                   char* strm=(char*)services.malloc(length+1);
                                                                                   if(!lo_read_ex(conn, fd, strm, size_tell))
                                                                                           PQclear_throw("lo_read can not read all bytes of object");
                                                                                   strm[length]=0;
                                                                                   str=strm;
                                                                           } else
                                                                                   str=0;
                                                                           if(lo_close(conn, fd)<0)
                                                                                   PQclear_throwPQerror;
                                                                   } else
                                                                           PQclear_throwPQerror;
                                                           }
                                                   default:
                                                           // normal column, read it normally
                                                           length=(size_t)PQgetlength(res, r, i);
                                                           if(length){
                                                                 char* strm=(char*)services.malloc(length+1);                                                                  char* strm=(char*)services.malloc(length+1);
                                                                 if(!lo_read_ex(conn, fd, strm, size_tell))                                                                  memcpy(strm, cell, length+1);
                                                                         PQclear_throw("lo_read can not read all bytes of object");  
                                                                 strm[length]=0;  
                                                                 str=strm;                                                                  str=strm;
                                                         } else                                                          } else
                                                                 str=0;                                                                  str=0;
                                                         if(lo_close(conn, fd)<0)  
                                                                 PQclear_throwPQerror;  
                                                 } else  
                                                         PQclear_throwPQerror;  
                                         } else {  
                                                 // normal column, read it normally  
                                                 length=(size_t)PQgetlength(res, r, i);  
                                                 if(length) {  
                                                         char* strm=(char*)services.malloc(length+1);  
                                                         memcpy(strm, cell, length+1);  
                                                         str=strm;  
                                                 } else  
                                                         str=0;  
                                         }                                          }
   
                                         if(transcode_needed && str && length){                                          if(str && length && transcode_column[i]){
                                                 // transcode cell value from ?ClientCharset to $request:charset                                                  // transcode cell value from ?ClientCharset to $request:charset
                                                 services.transcode(str, length,                                                  services.transcode(str, length,
                                                         str, length,                                                          str, length,
                                                         connection.client_charset,                                                          client_charset,
                                                         services.request_charset());                                                          request_charset);
                                         }                                          }
   
                                         CHECK(handlers.add_row_cell(sql_error, str, length));                                          CHECK(handlers.add_row_cell(sql_error, str, length));
Line 373  cleanup: Line 422  cleanup:
                 PQclear(res);                  PQclear(res);
                 if(failed)                  if(failed)
                         services._throw(sql_error);                          services._throw(sql_error);
   
                   if(connection.autocommit)
                           commit(aconnection);
         }          }
   
 private:  private:
Line 387  private: Line 439  private:
                         Placeholder& ph=placeholders[i];                          Placeholder& ph=placeholders[i];
                         if(transcode_needed){                          if(transcode_needed){
                                 size_t name_length;                                  size_t name_length;
                                 size_t value_length;  
                                 connection.services->transcode(ph.name, strlen(ph.name),                                  connection.services->transcode(ph.name, strlen(ph.name),
                                         ph.name, name_length,                                          ph.name, name_length,
                                         connection.services->request_charset(),                                          connection.services->request_charset(),
                                         connection.client_charset);                                          connection.client_charset);
   
                                 if(ph.value) {                                  if(ph.value) {
                                           size_t value_length;
                                         connection.services->transcode(ph.value, strlen(ph.value),                                          connection.services->transcode(ph.value, strlen(ph.value),
                                                 ph.value, value_length,                                                  ph.value, value_length,
                                                 connection.services->request_charset(),                                                  connection.services->request_charset(),
Line 401  private: Line 453  private:
                                 }                                  }
                         }                          }
                         int name_numner=atoi(ph.name);                          int name_numner=atoi(ph.name);
                         if(name_numner <= 0 || name_numner > placeholders_count)                          if(name_numner <= 0 || (size_t)name_numner > placeholders_count)
                                 connection.services->_throw("bad bind parameter key");                                  connection.services->_throw("bad bind parameter key");
   
                         paramValues[name_numner-1]=ph.value;                          paramValues[name_numner-1]=ph.value;
Line 409  private: Line 461  private:
         }          }
                   
                   
         /**          void _transaction_begin(Connection& connection){
                 Executes a query and throw away the result.                  _execute_transactions_cmd(connection, "BEGIN");
         */          }
   
           void _transaction_commit(Connection& connection){
                   _execute_transactions_cmd(connection, "COMMIT");
           }
   
           void _transaction_rollback(Connection& connection){
                   _execute_transactions_cmd(connection, "ROLLBACK");
           }
   
           void _execute_transactions_cmd(const Connection& connection, const char *query){
                   if(!connection.without_default_transactions) // with option ?WithoutDefaultTransaction=1 user must execute BEGIN/COMMIT/ROLLBACK by himself
                           _execute_cmd(connection, query);
           }
   
           // executes a query and throw away the result.
         void _execute_cmd(const Connection& connection, const char *query){          void _execute_cmd(const Connection& connection, const char *query){
                 if(PGresult *res=PQexec(connection.conn, query))                  if(PGresult *res=PQexec(connection.conn, query))
                         PQclear(res); // throw out the result [don't need but must call]                          PQclear(res); // throw away the result [don't need but must call]
                 else                  else
                         throwPQerror;                          throwPQerror;
         }          }
   
         void _begin_transaction(Connection& connection){  
                 if(connection.autocommit)  
                         _execute_cmd(connection, "BEGIN");  
         }  
   
         const char *_preprocess_statement(          const char *_preprocess_statement(
                                         Connection& connection,                                          Connection& connection,
                                         const char *astatement,                                          const char *astatement,
Line 510  private: Line 572  private:
                 return result;                  return result;
         }          }
   
         bool _transcode_required(Connection& connection){  
                 return (connection.client_charset && strcmp(connection.client_charset, connection.services->request_charset())!=0);  
         }  
   
 private: // lo_read/write exchancements  private: // lo_read/write exchancements
   
         bool lo_read_ex(PGconn *conn, int fd, const/*paf*/ char *buf, size_t len) {          bool lo_read_ex(PGconn *conn, int fd, const/*paf*/ char *buf, size_t len) {
Removed from v.1.30  
changed lines
  Added in v.1.34

E-mail: