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

Diff for /sql/pgsql/parser3pgsql.C between versions 1.23 and 1.39

version 1.23, 2004/12/23 15:57:41 version 1.39, 2012/06/06 14:47:44
Line 1 Line 1
 /** @file  /** @file
         Parser PgSQL driver.          Parser PgSQL driver.
   
         Copyright(c) 2001, 2003 ArtLebedev Group (http://www.artlebedev.com)          Copyright (c) 2001-2012 Art. Lebedev Studio (http://www.artlebedev.com)
   
         Author: Alexandr Petrosian <paf@design.ru> (http://paf.design.ru)          Author: Alexandr Petrosian <paf@design.ru> (http://paf.design.ru)
   
         2001.07.30 using PgSQL 7.1.2          2007.10.25 using PgSQL 8.1.5
 */  */
 static const char *RCSId="$Id$";   
   
 #include "config_includes.h"  #include "config_includes.h"
   
Line 16  static const char *RCSId="$Id$"; Line 15  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  volatile const char * IDENT_PARSER3PGSQL_C="$Id$" IDENT_PA_SQL_DRIVER_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 36  static const char *RCSId="$Id$"; Line 50  static const char *RCSId="$Id$";
 #endif  #endif
   
 #ifndef max  #ifndef max
 inline int max(int a,int b) { return a>b?a:b; }  inline int max(int a,int b){ return a>b?a:b; }
 inline int min(int a,int b){ return a<b?a:b; }  inline int min(int a,int b){ return a<b?a:b; }
 #endif  #endif
   
 static char *lsplit(char *string, char delim) {  static char *lsplit(char *string, char delim){
     if(string) {          if(string){
                 char *v=strchr(string, delim);                  if(char *v=strchr(string, delim)){
                 if(v) {  
                         *v=0;                          *v=0;
                         return v+1;                          return v+1;
                 }                  }
     }          }
     return 0;          return 0;
 }  }
   
 static char *lsplit(char **string_ref, char delim) {  static char *lsplit(char **string_ref, char delim){
     char *result=*string_ref;          char *result=*string_ref;
         char *next=lsplit(*string_ref, delim);          char *next=lsplit(*string_ref, delim);
     *string_ref=next;          *string_ref=next;
     return result;          return result;
   }
   
   static char* rsplit(char* string, char delim){
           if(string){
                   if(char* v=strrchr(string, delim)){
                           *v=0;
                           return v+1;
                   }
           }
           return NULL;    
 }  }
   
 static void toupper_str(char *out, const char *in, size_t size) {  static void toupper_str(char *out, const char *in, size_t size){
         while(size--)          while(size--)
                 *out++=(char)toupper(*in++);                  *out++=(char)toupper(*in++);
 }  }
   
   inline static const char* strdup(SQL_Driver_services& services, char* str, size_t length) {
           char *strm=(char*)services.malloc_atomic(length+1);
           memcpy(strm, str, length);
           strm[length]=0;
           return (const char*)strm;
   }
   
 struct Connection {  struct Connection {
         SQL_Driver_services* services;          SQL_Driver_services* services;
   
         PGconn *conn;          PGconn *conn;
         const char* cstrClientCharset;          const char* client_charset;
           bool autocommit;
           bool without_default_transactions;
 };  };
   
 /**  /**
Line 80  public: Line 112  public:
         }          }
   
         /// get api version          /// get api version
         int api_version() { return SQL_DRIVER_API_VERSION; }          int api_version(){ return SQL_DRIVER_API_VERSION; }
   
         /// initialize driver by loading sql dynamic link library          /// initialize driver by loading sql dynamic link library
         const char *initialize(char *dlopen_file_spec) {          const char *initialize(char *dlopen_file_spec){
                 return dlopen_file_spec?                  return dlopen_file_spec?
                         dlink(dlopen_file_spec):"client library column is empty";                          dlink(dlopen_file_spec):"client library column is empty";
         }          }
Line 96  public: Line 129  public:
   
         /**     connect          /**     connect
                 @param url                  @param url
                         format: @b user:pass@host[:port]|[local]/database                          format: @b user:pass@host[:port]|[local]/database?
                           ClientCharset=charset&  // transcode by parser
                           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]
                           autocommit=1&                   // each transaction is commited automatically (default)
                           WithoutDefaultTransaction=0     // 1 -- disable any BEGIN TRAN/COMMIT/ROLLBACK [can NOT be used with autocommit option]
         */          */
         void connect(          void connect(
                 char *url,                                   char* url, 
                 SQL_Driver_services& services,                                   SQL_Driver_services& services, 
                 void **connection_ref ///< output: Connection*                                  void** connection_ref ///< output: Connection*
                 ) {          ){
                 char *user=url;                  char* user=url;
                 char *host=lsplit(user, '@');                  char* host=rsplit(user, '@');
                 char *db=lsplit(host, '/');                  char* db=lsplit(host, '/');
                 char *pwd=lsplit(user, ':');                  char* pwd=lsplit(user, ':');
                 char *port=lsplit(host, ':');                  char* port=lsplit(host, ':');
   
                 char *options=lsplit(db, '?');                  char *options=lsplit(db, '?');
   
                 char *cstrBackwardCompAskServerToTranscode=0;                  char* charset=0;
                   char* datestyle=0;
   
                 Connection& connection=*(Connection  *)services.malloc(sizeof(Connection));                  Connection& connection=*(Connection *)services.malloc(sizeof(Connection));
                 *connection_ref=&connection;                  *connection_ref=&connection;
                 connection.services=&services;                  connection.services=&services;
                 connection.cstrClientCharset=0;                   connection.client_charset=0;    
                   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);
   
                 if(!connection.conn)                  if(!connection.conn)
                         services._throw("PQsetdbLogin failed");                          services._throw("PQsetdbLogin failed");
                 if(PQstatus(connection.conn)!=CONNECTION_OK)    
                   if(PQstatus(connection.conn)!=CONNECTION_OK)
                         throwPQerror;                          throwPQerror;
   
                 char *charset=0;                  while(options){
                 char *datestyle=0;                          if(char *key=lsplit(&options, '&')){
                 isDefaultTransaction = true;                                  if(*key){
                                           if(char *value=lsplit(key, '=')){
                 while(options) {                                                  if(strcmp(key, "ClientCharset")==0){
                         if(char *key=lsplit(&options, '&')) {  
                                 if(*key) {  
                                         if(char *value=lsplit(key, '=')) {  
                                                 if(strcmp(key, "ClientCharset" ) == 0) {  
                                                         toupper_str(value, value, strlen(value));                                                          toupper_str(value, value, strlen(value));
                                                         connection.cstrClientCharset=value;                                                          connection.client_charset=value;
                                                 } else if(strcasecmp(key, "charset")==0) { // left for backward compatibility, consider using ClientCharset                                                  } else if(strcasecmp(key, "charset")==0){
                                                         cstrBackwardCompAskServerToTranscode=value;                                                          charset=value;
                                                 } else if(strcasecmp(key, "datestyle")==0) {                                                  } else if(strcasecmp(key, "datestyle")==0){
                                                         datestyle=value;                                                          datestyle=value;
                                                 } else if(strcmp(key, "WithoutDefaultTransaction")==0) {                                                  } else if(strcasecmp(key, "autocommit")==0){
                                                         isDefaultTransaction = false;                                                          if(connection.without_default_transactions)
                                                                   services._throw("options WithoutDefaultTransaction and autocommit can't be used together");
                                                           if(atoi(value)==0)
                                                                   connection.autocommit=false;
                                                   } else if(strcmp(key, "WithoutDefaultTransaction")==0){
                                                           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;
                                                           }
                                                 } else                                                  } else
                                                         services._throw("unknown connect option" /*key*/);                                                          services._throw("unknown connect option" /*key*/);
                                         } else                                           } else 
Line 150  public: Line 200  public:
                         }                          }
                 }                  }
   
                 if(connection.cstrClientCharset && cstrBackwardCompAskServerToTranscode)                  if(charset){
                         services._throw("use 'ClientCharset' option only, "                          char statement[MAX_STRING+1]="SET CLIENT_ENCODING=";
                                 "'charset' option is obsolete and should not be used with new 'ClientCharset' option");  
   
                 if(cstrBackwardCompAskServerToTranscode) {  
                         // set CLIENT_ENCODING  
                         char statement[MAX_STRING]="set CLIENT_ENCODING="; // win  
                         strncat(statement, cstrBackwardCompAskServerToTranscode, MAX_STRING);  
                           
                         PGresult *res=PQexec(connection.conn, statement);  
                         if(!res)   
                                 throwPQerror;  
                         PQclear(res); // throw out the result [don't need but must call]  
                 }  
   
                 if(datestyle) {  
                         // set DATESTYLE  
                         char statement[MAX_STRING]="set DATESTYLE="; // ISO,SQL,Postgres,European,NonEuropean=US,German,DEFAULT=ISO  
                         strncat(statement, charset, MAX_STRING);                          strncat(statement, charset, MAX_STRING);
                           
                         PGresult *res=PQexec(connection.conn, statement);                          _execute_cmd(connection, statement);
                         if(!res)   
                                 throwPQerror;  
                         PQclear(res); // throw out the result [don't need but must call]  
                 }                  }
   
                 begin_transaction(connection);                  if(datestyle){
                           char statement[MAX_STRING]="SET DATESTYLE=";
                           strncat(statement, datestyle, MAX_STRING);
   
                           _execute_cmd(connection, statement);
                   }
   
                   _transaction_begin(connection);
         }          }
         void disconnect(void *aconnection) {  
                 Connection& connection=*static_cast<Connection*>(aconnection);  
   
             PQfinish(connection.conn);          void disconnect(void *aconnection){
                   Connection& connection=*static_cast<Connection*>(aconnection);
                   PQfinish(connection.conn);
                 connection.conn=0;                  connection.conn=0;
         }          }
         void commit(void *aconnection) {  
                 if(isDefaultTransaction)  
                 {  
                         Connection& connection=*static_cast<Connection*>(aconnection);  
   
                         if(PGresult *res=PQexec(connection.conn, "COMMIT"))          void commit(void *aconnection){
                                 PQclear(res);                  Connection& connection=*static_cast<Connection*>(aconnection);
                         else                  _transaction_commit(connection);
                                 throwPQerror;                  _transaction_begin(connection);
                         begin_transaction(connection);  
                 }  
         }          }
         void rollback(void *aconnection) {  
                 if(isDefaultTransaction)  
                 {  
                         Connection& connection=*static_cast<Connection*>(aconnection);  
   
                         if(PGresult *res=PQexec(connection.conn, "ROLLBACK"))          void rollback(void *aconnection){
                                 PQclear(res);                  Connection& connection=*static_cast<Connection*>(aconnection);
                         else                  _transaction_rollback(connection);
                                 throwPQerror;                  _transaction_begin(connection);
                         begin_transaction(connection);  
                 }  
         }          }
   
         bool ping(void *aconnection) {          bool ping(void *aconnection) {
                 Connection& connection=*static_cast<Connection*>(aconnection);                  Connection& connection=*static_cast<Connection*>(aconnection);
   
                 return PQstatus(connection.conn)==CONNECTION_OK;                  return PQstatus(connection.conn)==CONNECTION_OK;
         }          }
   
         const char* quote(          // charset here is services.request_charset(), not connection.client_charset
                 void *aconnection,          // thus we can't use the sql server quoting support
                 const char *from, unsigned int length) {          const char* quote(void *aconnection, const char *str, unsigned int length) 
           {
                   const char* from;
                   const char* from_end=str+length;
   
                   size_t quoted=0;
   
                   for(from=str; from<from_end; from++){
                           switch (*from) {
                           case '\'':
                           case '\\':
                                   quoted++;
                           }
                   }
   
                   if(!quoted)
                           return str;
   
                 Connection& connection=*static_cast<Connection*>(aconnection);                  Connection& connection=*static_cast<Connection*>(aconnection);
                   char *result=(char*)connection.services->malloc_atomic(length + quoted + 1);
                   char *to = result;
   
                 char *result=(char*)connection.services->malloc_atomic(length*2+1);                  for(from=str; from<from_end; from++){
                 char *to=result;                          switch (*from) {
                 while(length--) {  
                         switch(*from) {  
                         case '\'': // "'" -> "''"                          case '\'': // "'" -> "''"
                                 *to++='\'';                                  *to++='\'';
                                 break;                                  break;
Line 231  public: Line 273  public:
                                 *to++='\\';                                  *to++='\\';
                                 break;                                  break;
                         }                          }
                         *to++=*from++;                          *to++=*from;
                 }                  }
                   
                 *to=0;                  *to=0;
                 return result;                  return result;
                 }          }
   
         void query(void *aconnection,           void query(void *aconnection, 
                 const char *astatement,                                   const char *astatement, 
                 size_t placeholders_count, Placeholder* placeholders,                                   size_t placeholders_count, Placeholder* placeholders, 
                 unsigned long offset, unsigned long limit,                                  unsigned long offset, unsigned long limit,
                 SQL_Driver_query_event_handlers& handlers) {                                  SQL_Driver_query_event_handlers& handlers
 //              _asm int 3;          ){
                 Connection& connection=*static_cast<Connection*>(aconnection);                  Connection& connection=*static_cast<Connection*>(aconnection);
                 const char* cstrClientCharset=connection.cstrClientCharset;  
                 SQL_Driver_services& services=*connection.services;                  SQL_Driver_services& services=*connection.services;
                 PGconn *conn=connection.conn;                  PGconn *conn=connection.conn;
   
                 if(placeholders_count>0)                  const char* client_charset=connection.client_charset;
                         services._throw("bind variables not supported (yet)");                  const char* request_charset=services.request_charset();
                   bool transcode_needed=client_charset && strcmp(client_charset, request_charset)!=0;
                 // transcode from $request:charset to connect-string?client_charset  
                 if(cstrClientCharset) {                  const char** paramValues;
                         size_t transcoded_statement_size;                  if(placeholders_count>0){
                         services.transcode(astatement, strlen(astatement),                          int binds_size=sizeof(char)*placeholders_count;
                                 astatement, transcoded_statement_size,                          paramValues = static_cast<const char**>(services.malloc_atomic(binds_size));
                                 services.request_charset(),                          _bind_parameters(placeholders_count, placeholders, paramValues, connection, transcode_needed);
                                 cstrClientCharset);                  }
   
                   size_t statement_size=0;
                   if(transcode_needed){
                           // transcode query from $request:charset to ?ClientCharset
                           statement_size=strlen(astatement);
                           services.transcode(astatement, statement_size,
                                   astatement, statement_size,
                                   request_charset,
                                   client_charset);
                   }
   
                   const char *statement=_preprocess_statement(connection, astatement, statement_size, offset, limit);
                   // error after prepare?
   
                   PGresult *res;
                   if(placeholders_count>0){
                           res=PQexecParams(conn, statement, placeholders_count, NULL, paramValues, NULL, NULL, 0);
                   } else {
                           res=PQexec(conn, statement);
                 }                  }
   
                 const char *statement=preprocess_statement(connection,  
                         astatement, offset, limit);  
   
                 PGresult *res=PQexec(conn, statement);  
                 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:                          case PGRES_COMMAND_OK: // empty result: insert|delete|update|...
                         // empty result: insert|delete|update|...                                  PQclear(res);
                         PQclear(res);                                  if(connection.autocommit)
                         return;                                          commit(aconnection);
                 case PGRES_TUPLES_OK:                                   return;
                         break;                            case PGRES_TUPLES_OK: 
                 default:                                  break;  
                         PQclear_throwPQerror;                          default:
                         break;                                  PQclear_throwPQerror;
                                   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; \
                 }                  }
   
                 for(int i=0; i<column_count; i++){                  size_t 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];
   
                   for(size_t i=0; i<column_count; i++){
                           column_types[i]=PQftype(res, i);
   
                         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);                          const char* str=strdup(services, name, length);
                         memcpy(strm, name, length+1);  
                         const char* str=strm;  
   
                         // transcode to $request:charset from connect-string?client_charset                          if(transcode_needed)
                         if(cstrClientCharset)                                   // transcode column name from ?ClientCharset to $request:charset
                                 services.transcode(str, length,                                  services.transcode(str, length,
                                         str, length,                                          str, length,
                                         cstrClientCharset,                                          client_charset,
                                         services.request_charset());                                          request_charset);
   
                         CHECK(handlers.add_column(sql_error, str, length));                          CHECK(handlers.add_column(sql_error, str, length));
                 }                  }
Line 315  public: Line 379  public:
                 if(unsigned long row_count=(unsigned long)PQntuples(res))                  if(unsigned long row_count=(unsigned long)PQntuples(res))
                         for(unsigned long r=0; r<row_count; r++) {                          for(unsigned long r=0; r<row_count; r++) {
                                 CHECK(handlers.add_row(sql_error));                                  CHECK(handlers.add_row(sql_error));
                                 for(int i=0; i<column_count; i++){                                  for(size_t i=0; i<column_count; i++){
                                         const char *cell=PQgetvalue(res, r, i);                                          char *cell=PQgetvalue(res, r, i);
                                         size_t length;  
                                         const char* str;  
                                         if(PQftype(res, i)==OIDOID) {  
                                                 // ObjectID column, read object bytes  
   
                                                 char *error_pos=0;                                          size_t length=0;
                                                 Oid oid=cell?atoi(cell):0;                                          const char* str;
                                                 int fd=lo_open(conn, oid, INV_READ);  
                                                 if(fd>=0) {  
                                                         // seek to end  
                                                         if(lo_lseek(conn, fd, 0, SEEK_END)<0)  
                                                                 PQclear_throwPQerror;  
                                                         // get length  
                                                         int size_tell=lo_tell(conn, fd);  
                                                         if(size_tell<0)  
                                                                 PQclear_throwPQerror;  
                                                         // seek to begin  
                                                         if(lo_lseek(conn, fd, 0, SEEK_SET)<0)  
                                                                 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;  
                                         } 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(str && length) {                                          switch(column_types[i]){
                                                 // transcode to $request:charset from connect-string?client_charset                                                  case BOOLOID:
                                                 if(cstrClientCharset)                                                  case INT8OID:
                                                         services.transcode(str, length,                                                  case INT2OID:
                                                                 str, length,                                                  case INT4OID:
                                                                 cstrClientCharset,                                                  case FLOAT4OID:
                                                                 services.request_charset());                                                  case FLOAT8OID:
                                                   case DATEOID:
                                                   case TIMEOID:
                                                   case TIMESTAMPOID:
                                                   case TIMESTAMPTZOID:
                                                   case TIMETZOID:
                                                   case NUMERICOID:
                                                           length=(size_t)PQgetlength(res, r, i);
                                                           str=length ? strdup(services, cell, length) : 0;
                                                           // transcode is never required for these types
                                                           break;
                                                   case OIDOID:
                                                           {
                                                                   Oid oid=cell?atoi(cell):0;
                                                                   int fd=lo_open(conn, oid, INV_READ);
                                                                   if(fd>=0){
                                                                           // seek to end
                                                                           if(lo_lseek(conn, fd, 0, SEEK_END)<0)
                                                                                   PQclear_throwPQerror;
                                                                           // get length
                                                                           int size_tell=lo_tell(conn, fd);
                                                                           if(size_tell<0)
                                                                                   PQclear_throwPQerror;
                                                                           // seek to begin
                                                                           if(lo_lseek(conn, fd, 0, SEEK_SET)<0)
                                                                                   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;
                                                                                   if(transcode_needed) {
                                                                                           // transcode cell value from ?ClientCharset to $request:charset
                                                                                           services.transcode(str, length,
                                                                                                   str, length,
                                                                                                   client_charset,
                                                                                                   request_charset);
                                                                                   }
                                                                           } else
                                                                                   str=0;
                                                                           if(lo_close(conn, fd)<0)
                                                                                   PQclear_throwPQerror;
                                                                   } else
                                                                           PQclear_throwPQerror;
                                                                   break;
                                                           }
                                                   default:
                                                           // normal column, read it normally
                                                           length=(size_t)PQgetlength(res, r, i);
                                                           str=length ? strdup(services, cell, length) : 0;
                                                           if(transcode_needed) {
                                                                   // transcode cell value from ?ClientCharset to $request:charset
                                                                   services.transcode(str, length,
                                                                           str, length,
                                                                           client_charset,
                                                                           request_charset);
                                                           }
                                                           break;
                                         }                                          }
   
                                         CHECK(handlers.add_row_cell(sql_error, str, length));                                          CHECK(handlers.add_row_cell(sql_error, str, length));
                                 }                                  }
                         }                          }
Line 377  cleanup: Line 460  cleanup:
                 PQclear(res);                  PQclear(res);
                 if(failed)                  if(failed)
                         services._throw(sql_error);                          services._throw(sql_error);
   
                   if(connection.autocommit)
                           commit(aconnection);
         }          }
   
 private: // private funcs  private:
           void _bind_parameters(
                                   size_t placeholders_count, 
                                   Placeholder* placeholders, 
                                   const char** paramValues,
                                   Connection& connection,
                                   bool transcode_needed
           ){
                   for(size_t i=0; i<placeholders_count; i++){
                           Placeholder& ph=placeholders[i];
                           if(transcode_needed){
                                   size_t name_length;
                                   connection.services->transcode(ph.name, strlen(ph.name),
                                           ph.name, name_length,
                                           connection.services->request_charset(),
                                           connection.client_charset);
   
                                   if(ph.value) {
                                           size_t value_length;
                                           connection.services->transcode(ph.value, strlen(ph.value),
                                                   ph.value, value_length,
                                                   connection.services->request_charset(),
                                                   connection.client_charset);
                                   }
                           }
                           int name_number=atoi(ph.name);
                           if(name_number <= 0 || (size_t)name_number > placeholders_count)
                                   connection.services->_throw("bad bind parameter key");
   
         void begin_transaction(Connection& connection) {                          paramValues[name_number-1]=ph.value;
                 if(isDefaultTransaction)  
                 {  
                         if(PGresult *res=PQexec(connection.conn, "BEGIN"))  
                                 PQclear(res);  
                         else  
                                 throwPQerror;  
                 }                  }
         }          }
           
           
           void _transaction_begin(Connection& connection){
                   _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){
                   if(PGresult *res=PQexec(connection.conn, query))
                           PQclear(res); // throw away the result [don't need but must call]
                   else
                           throwPQerror;
           }
   
         const char *preprocess_statement(Connection& connection,          const char *_preprocess_statement(
                 const char *astatement, unsigned long offset, unsigned long limit) {                                          Connection& connection,
                                           const char *astatement,
                                           size_t statement_size,
                                           unsigned long offset,
                                           unsigned long limit
           ){
                 PGconn *conn=connection.conn;                  PGconn *conn=connection.conn;
   
                 size_t statement_size=strlen(astatement);                  if(!statement_size)
                           statement_size=strlen(astatement);
   
                 char *result=(char *)connection.services->malloc(statement_size                  char *result=(char *)connection.services->malloc(statement_size
                         +MAX_NUMBER*2+15 // limit # offset #                          +MAX_NUMBER*2+15 // " limit # offset #"
                         +MAX_STRING // in case of short 'strings'                          +MAX_STRING // in case of short 'strings'
                         +1);                          +1);
                 // offset & limit -> suffixes                  // offset & limit -> suffixes
                 const char *o;                  const char *o;
                 if(offset || limit) {                  if(offset || limit!=SQL_NO_LIMIT){
                         char *cur=result;                          char *cur=result;
                         memcpy(cur, astatement, statement_size); cur+=statement_size;                          memcpy(cur, astatement, statement_size); cur+=statement_size;
                         if(limit)                          if(limit!=SQL_NO_LIMIT)
                                 cur+=snprintf(cur, 7+MAX_NUMBER, " limit %u", limit);                                  cur+=snprintf(cur, 7+MAX_NUMBER, " limit %lu", limit);
                         if(offset)                          if(offset)
                                 cur+=snprintf(cur, 8+MAX_NUMBER, " offset %u", offset);                                  cur+=snprintf(cur, 8+MAX_NUMBER, " offset %lu", offset);
                         o=result;                          o=result;
                 } else                   } else 
                         o=astatement;                          o=astatement;
Line 419  private: // private funcs Line 558  private: // private funcs
                 while(*o) {                  while(*o) {
                         if(                          if(
                                 o[0]=='/' &&                                  o[0]=='/' &&
                                 o[1]=='*' &&                                   o[1]=='*' &&
                                 o[2]=='*') { // name start                                  o[2]=='*') { // name start
                                 const char* saved_o=o;                                  const char* saved_o=o;
                                 o+=3;                                  o+=3;
Line 476  private: // private funcs Line 615  private: // private funcs
 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) {
                 int size_read;                  return lo_rw_method (conn, fd, buf, len, lo_read);
                 while(len && (size_read=lo_read(conn, fd, buf, min(LO_BUFSIZE, len)))>0) {  
                         buf+=size_read;  
                         len-=size_read;                                                                   
                 }  
                 return len==0;  
         }          }
   
         bool lo_write_ex(PGconn *conn, int fd, const/*paf*/ char *buf, size_t len) {          bool lo_write_ex(PGconn *conn, int fd, const/*paf*/ char *buf, size_t len) {
                 int size_written;                  return lo_rw_method (conn, fd, buf, len, lo_write);
                 while(len && (size_written=lo_write(conn, fd, buf, min(LO_BUFSIZE, len)))>0) {          }
                         buf+=size_written;  
                         len-=size_written;                                                                                bool lo_rw_method(PGconn *conn, int fd, const/*paf*/ char *buf, size_t len, int (*lo_func)(PGconn *conn, int fd, const/*paf*/ char *buf, size_t len)) {
                   int size_op;
                   while(len && (size_op=lo_func(conn, fd, buf, min(LO_BUFSIZE, len)))>0) {
                           buf+=size_op;
                           len-=size_op;
                 }                  }
                 return len==0;                  return len==0;
         }          }
Line 507  private: // conn client library funcs Line 645  private: // conn client library funcs
         typedef char *(*t_PQerrorMessage)(const PGconn* conn); t_PQerrorMessage PQerrorMessage;          typedef char *(*t_PQerrorMessage)(const PGconn* conn); t_PQerrorMessage PQerrorMessage;
         typedef ConnStatusType (*t_PQstatus)(const PGconn *conn); t_PQstatus PQstatus;          typedef ConnStatusType (*t_PQstatus)(const PGconn *conn); t_PQstatus PQstatus;
         typedef PGresult *(*t_PQexec)(PGconn *conn,          typedef PGresult *(*t_PQexec)(PGconn *conn,
                          const char *query); t_PQexec PQexec;                                                  const char *query); t_PQexec PQexec;
           typedef PGresult *(*t_PQexecParams)(
                                                   PGconn *conn,
                                                   const char *query, 
                                                   int nParams,
                                                   const Oid *paramTypes,
                                                   const char * const *paramValues,
                                                   const int *paramLengths,
                                                   const int *paramFormats,
                                                   int resultFormat); t_PQexecParams PQexecParams;
   
         typedef ExecStatusType (*t_PQresultStatus)(const PGresult *res); t_PQresultStatus PQresultStatus;          typedef ExecStatusType (*t_PQresultStatus)(const PGresult *res); t_PQresultStatus PQresultStatus;
         typedef int (*t_PQgetlength)(const PGresult *res,          typedef int (*t_PQgetlength)(const PGresult *res,
                                         int tup_num,                                                  int tup_num,
                                         int field_num); t_PQgetlength PQgetlength;                                                  int field_num); t_PQgetlength PQgetlength;
         typedef char* (*t_PQgetvalue)(const PGresult *res,          typedef char* (*t_PQgetvalue)(const PGresult *res,
                                          int tup_num,                                                  int tup_num,
                                          int field_num); t_PQgetvalue PQgetvalue;                                                  int field_num); t_PQgetvalue PQgetvalue;
         typedef int (*t_PQntuples)(const PGresult *res); t_PQntuples PQntuples;          typedef int     (*t_PQntuples)(const PGresult *res); t_PQntuples PQntuples;
         typedef char *(*t_PQfname)(const PGresult *res,          typedef char *(*t_PQfname)(const PGresult *res,
                                                 int field_index); t_PQfname PQfname;                                                  int field_index); t_PQfname PQfname;
         typedef int (*t_PQnfields)(const PGresult *res); t_PQnfields PQnfields;          typedef int (*t_PQnfields)(const PGresult *res); t_PQnfields PQnfields;
Line 523  private: // conn client library funcs Line 671  private: // conn client library funcs
   
         typedef Oid     (*t_PQftype)(const PGresult *res, int field_num); t_PQftype PQftype;          typedef Oid     (*t_PQftype)(const PGresult *res, int field_num); t_PQftype PQftype;
   
           typedef size_t (*t_PQescapeStringConn)(PGconn *conn,
                                                   char *to, const char *from, size_t length,
                                                   int *error); t_PQescapeStringConn PQescapeStringConn;
   
         typedef int     (*t_lo_open)(PGconn *conn, Oid lobjId, int mode); t_lo_open lo_open;          typedef int     (*t_lo_open)(PGconn *conn, Oid lobjId, int mode); t_lo_open lo_open;
         typedef int     (*t_lo_close)(PGconn *conn, int fd); t_lo_close lo_close;          typedef int     (*t_lo_close)(PGconn *conn, int fd); t_lo_close lo_close;
         typedef int     (*t_lo_read)(PGconn *conn, int fd, const/*paf*/ char *buf, size_t len); t_lo_read lo_read;          typedef int     (*t_lo_read)(PGconn *conn, int fd, const/*paf*/ char *buf, size_t len); t_lo_read lo_read;
Line 539  private: // conn client library funcs li Line 691  private: // conn client library funcs li
         const char *dlink(const char *dlopen_file_spec) {          const char *dlink(const char *dlopen_file_spec) {
                 if(lt_dlinit())                  if(lt_dlinit())
                         return lt_dlerror();                          return lt_dlerror();
         lt_dlhandle handle=lt_dlopen(dlopen_file_spec);                  lt_dlhandle handle=lt_dlopen(dlopen_file_spec);
         if(!handle)                  if(!handle)
                         return "can not open the dynamic link module";                          return "can not open the dynamic link module";
   
                 #define DSLINK(name, action) \                  #define DSLINK(name, action) \
Line 562  private: // conn client library funcs li Line 714  private: // conn client library funcs li
                 DLINK(PQclear);                  DLINK(PQclear);
                 DLINK(PQresultStatus);                  DLINK(PQresultStatus);
                 DLINK(PQexec);                  DLINK(PQexec);
                   DLINK(PQexecParams);
                 DLINK(PQftype);                  DLINK(PQftype);
                   DLINK(PQescapeStringConn);
                 DLINK(lo_open);         DLINK(lo_close);                  DLINK(lo_open);         DLINK(lo_close);
                 DLINK(lo_read);         DLINK(lo_write);                  DLINK(lo_read);         DLINK(lo_write);
                 DLINK(lo_lseek);                DLINK(lo_creat);                  DLINK(lo_lseek);                DLINK(lo_creat);
Line 571  private: // conn client library funcs li Line 725  private: // conn client library funcs li
   
                 return 0;                  return 0;
         }          }
   
         // Default transaction flag, if true make it.  
         bool isDefaultTransaction;  
 };  };
   
 extern "C" SQL_Driver *SQL_DRIVER_CREATE() {  extern "C" SQL_Driver *SQL_DRIVER_CREATE() {
Removed from v.1.23  
changed lines
  Added in v.1.39

E-mail: