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

Diff for /sql/pgsql/parser3pgsql.C between versions 1.11 and 1.29

version 1.11, 2003/01/15 10:55:38 version 1.29, 2008/06/24 17:43:48
Line 1 Line 1
 /** @file  /** @file
         Parser PgSQL driver.          Parser PgSQL driver.
   
         Copyright(c) 2001, 2002 ArtLebedev Group (http://www.artlebedev.com)          Copyright(c) 2001, 2003 ArtLebedev Group (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$";   static const char *RCSId="$Id$"; 
   
Line 22  static const char *RCSId="$Id$"; Line 22  static const char *RCSId="$Id$";
 // 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  // from postgres_ext.h
 #define InvalidOid              ((Oid) 0)  //#define InvalidOid            ((Oid) 0)
   
   
 #include "ltdl.h"  #include "ltdl.h"
Line 41  inline int min(int a,int b){ return a<b? Line 41  inline int min(int a,int b){ return 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);                  char *v=strchr(string, delim);
                 if(v) {                  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) {
                   char* v=strrchr(string, delim); 
                   if(v) {
                           *v=0;
                           return v+1;
                   }
           }
           return NULL;    
   }
   
   static void toupper_str(char *out, const char *in, size_t size) {
           while(size--)
                   *out++=(char)toupper(*in++);
 }  }
   
   struct Connection {
           SQL_Driver_services* services;
   
           PGconn *conn;
           const char* cstrClientCharset;
           bool autocommit;
   };
   
 /**  /**
         PgSQL server driver          PgSQL server driver
 */  */
Line 69  public: Line 93  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";
         }          }
   
         #define throwPQerror services._throw(PQerrorMessage(conn))          #define throwPQerror connection.services->_throw(PQerrorMessage(connection.conn))
         #define PQclear_throw(msg) { \          #define PQclear_throw(msg) { \
                         PQclear(res); \                          PQclear(res); \
                         services._throw(msg); \                          connection.services->_throw(msg); \
                 }                                                                 }                                               
         #define PQclear_throwPQerror PQclear_throw(PQerrorMessage(conn))          #define PQclear_throwPQerror PQclear_throw(PQerrorMessage(connection.conn))
   
         /**     connect          /**     connect
                 @param used_only_in_connect_url                  @param url
                         format: @b user:pass@host[:port]|[local]/database                          format: @b user:pass@host[:port]|[local]/database?
                           ClientCharset=xyz&      // transcode by parser
                           charset=xyz&            // transcode by server with 'set CLIENT_ENCODING=xyz'
                           datestyle=xyz&          // set DATESTYLE=xyz
                           autocommit=1&
                           WithoutDefaultTransaction=1     // == autocommit=0
         */          */
         void connect(          void connect(
                 char *used_only_in_connect_url,                   char *url, 
                 SQL_Driver_services& services,                   SQL_Driver_services& services, 
                 void **connection ///< output: PGconn *                  void **connection_ref ///< output: Connection*
                 ) {                  ) {
                 char *user=used_only_in_connect_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, '?');
   
                 PGconn *conn=PQsetdbLogin(                  char *cstrBackwardCompAskServerToTranscode=0;
                   char* datestyle=0;
   
                   Connection& connection=*(Connection  *)services.malloc(sizeof(Connection));
                   *connection_ref=&connection;
                   connection.services=&services;
                   connection.cstrClientCharset=0; 
                   connection.autocommit=true;
                   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(!conn)  
                   if(!connection.conn)
                         services._throw("PQsetdbLogin failed");                          services._throw("PQsetdbLogin failed");
                 if(PQstatus(conn)!=CONNECTION_OK)    
                         throwPQerror;  
   
                 char *charset=0;                  if(PQstatus(connection.conn)!=CONNECTION_OK)
                 char *datestyle=0;                          throwPQerror;
   
                 while(options) {                  while(options){
                         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(strcasecmp(key, "charset")==0) {                                                  if(strcmp(key, "ClientCharset")==0) { // transcoding with parser
                                                         charset=value;                                                          toupper_str(value, value, strlen(value));
                                                           connection.cstrClientCharset=value;
                                                   } else if(strcasecmp(key, "charset")==0){ // transcoding with server
                                                           cstrBackwardCompAskServerToTranscode=value;
                                                 } else if(strcasecmp(key, "datestyle")==0) {                                                  } else if(strcasecmp(key, "datestyle")==0) {
                                                         datestyle=value;                                                          datestyle=value;
                                                   } else if(strcasecmp(key, "autocommit")==0){
                                                           if(atoi(value)==0)
                                                                   connection.autocommit=false;
                                                   } else if(strcmp(key, "WithoutDefaultTransaction")==0){ // backward, use autocommit=0
                                                           if(atoi(value)==1)
                                                                   connection.autocommit=false;
                                                 } else                                                  } else
                                                         services._throw("unknown connect option" /*key*/);                                                          services._throw("unknown connect option" /*key*/);
                                         } else                                           } else 
Line 126  public: Line 172  public:
                         }                          }
                 }                  }
   
                 if(charset) {                  if(cstrBackwardCompAskServerToTranscode){
                         // set CLIENT_ENCODING                          char statement[MAX_STRING]="set CLIENT_ENCODING=";
                         char statement[MAX_STRING]="set CLIENT_ENCODING="; // win                          strncat(statement, cstrBackwardCompAskServerToTranscode, MAX_STRING);
                         strncat(statement, charset, MAX_STRING);  
                                                   execute_resultless(connection, statement);
                         PGresult *res=PQexec(conn, statement);  
                         if(!res)   
                                 throwPQerror;  
                         PQclear(res); // throw out the result [don't need but must call]  
                 }                  }
   
                 if(datestyle) {                  if(datestyle){
                         // set DATESTYLE  
                         char statement[MAX_STRING]="set DATESTYLE="; // ISO,SQL,Postgres,European,NonEuropean=US,German,DEFAULT=ISO                          char statement[MAX_STRING]="set DATESTYLE="; // ISO,SQL,Postgres,European,NonEuropean=US,German,DEFAULT=ISO
                         strncat(statement, charset, MAX_STRING);                          strncat(statement, datestyle, MAX_STRING);
                           
                         PGresult *res=PQexec(conn, statement);                          execute_resultless(connection, statement);
                         if(!res)   
                                 throwPQerror;  
                         PQclear(res); // throw out the result [don't need but must call]  
                 }                  }
   
                 *(PGconn **)connection=conn;                  begin_transaction(connection);
                 begin_transaction(services, conn);  
         }          }
         void disconnect(void *connection) {  
             PQfinish((PGconn *)connection);          void disconnect(void *aconnection) {
                   Connection& connection=*static_cast<Connection*>(aconnection);
   
                   PQfinish(connection.conn);
                   connection.conn=0;
         }          }
         void commit(SQL_Driver_services& services, void *connection) {  
                 PGconn *conn=(PGconn *)connection;          void commit(void *aconnection) {
                 if(PGresult *res=PQexec(conn, "COMMIT"))                  execute_transaction_cmd(aconnection, "COMMIT");
                         PQclear(res);  
                 else  
                         throwPQerror;  
                 begin_transaction(services, conn);  
         }          }
         void rollback(SQL_Driver_services& services, void *connection) {  
                 PGconn *conn=(PGconn *)connection;          void rollback(void *aconnection) {
                 if(PGresult *res=PQexec(conn, "ROLLBACK"))                  execute_transaction_cmd(aconnection, "ROLLBACK");
                         PQclear(res);  
                 else  
                         throwPQerror;  
                 begin_transaction(services, conn);  
         }          }
   
         bool ping(SQL_Driver_services&, void *connection) {          bool ping(void *aconnection) {
                 return PQstatus((PGconn *)connection)==CONNECTION_OK;                  Connection& connection=*static_cast<Connection*>(aconnection);
   
                   return PQstatus(connection.conn)==CONNECTION_OK;
         }          }
   
         unsigned int quote(          const char* quote(
                 SQL_Driver_services&, void *connection,                  void *aconnection,
                 char *to, const char *from, unsigned int length) {                  const char *from, unsigned int length) {
                 if(to) { // store mode                  Connection& connection=*static_cast<Connection*>(aconnection);
                         unsigned int result=length;  
                         while(length--) {                  char *result=(char*)connection.services->malloc_atomic(length*2+1);
                                 switch(*from) {                  int err=0;
                                 case '\'': // "'" -> "''"                  PQescapeStringConn (connection.conn,
                                         *to++='\''; result++;                                                          result, from, length,
                                         break;                                                          &err);
                                 case '\\': // "\" -> "\\"                  return result;
                                         *to++='\\'; result++;          }
                                         break;          
                                 }          void query(void *aconnection, 
                                 *to++=*from++;                  const char *astatement, 
                         }                  size_t placeholders_count, Placeholder* placeholders, 
                         return result;                  unsigned long offset, unsigned long limit,
                 } else // estimate mode  
                         return length*2;  
         }  
         void query(  
                 SQL_Driver_services& services, void *connection,   
                 const char *astatement, unsigned long offset, unsigned long limit,  
                 SQL_Driver_query_event_handlers& handlers) {                  SQL_Driver_query_event_handlers& handlers) {
 //              _asm int 3;  //              _asm int 3;
                   Connection& connection=*static_cast<Connection*>(aconnection);
                   const char* cstrClientCharset=connection.cstrClientCharset;
                   SQL_Driver_services& services=*connection.services;
                   PGconn *conn=connection.conn;
   
                   const char** paramValues;
                   if(placeholders_count>0){
                           //services._throw("bind variables not supported (yet)");
                           int binds_size=sizeof(char) * placeholders_count;
                           paramValues = static_cast<const char**>(services.malloc_atomic(binds_size));
                           bind_parameters(placeholders_count, placeholders, paramValues, connection);
                   }
   
                 PGconn *conn=(PGconn *)connection;                  // transcode from $request:charset to ?ClientCharset
                   if(cstrClientCharset) {
                           size_t transcoded_statement_size;
                           services.transcode(astatement, strlen(astatement),
                                   astatement, transcoded_statement_size,
                                   services.request_charset(),
                                   cstrClientCharset);
                   }
   
                 const char *statement=preprocess_statement(services, conn,                  const char *statement=preprocess_statement(connection,
                         astatement, offset, limit);                          astatement, offset, limit);
   
                 PGresult *res=PQexec(conn, statement);                  PGresult *res;
                   if(placeholders_count>0){
                           res=PQexecParams(conn, statement, placeholders_count, NULL, paramValues, NULL, NULL, 0);
                   } else {
                           res=PQexec(conn, statement);
                   }
                 if(!res)                   if(!res) 
                         throwPQerror;                          throwPQerror;
   
Line 239  public: Line 292  public:
   
                 for(int i=0; i<column_count; i++){                  for(int i=0; i<column_count; i++){
                         char *name=PQfname(res, i);                          char *name=PQfname(res, i);
                         size_t size=strlen(name);                          size_t length=strlen(name);
                         void *ptr=services.malloc(size);                          char* strm=(char*)services.malloc(length+1);
                         memcpy(ptr, name, size);                          memcpy(strm, name, length+1);
                         CHECK(handlers.add_column(sql_error, ptr, size));                          const char* str=strm;
   
                           // transcode from ?ClientCharset to $request:charset
                           if(cstrClientCharset) 
                                   services.transcode(str, length,
                                           str, length,
                                           cstrClientCharset,
                                           services.request_charset());
   
                           CHECK(handlers.add_column(sql_error, str, length));
                 }                  }
   
                 CHECK(handlers.before_rows(sql_error));                  CHECK(handlers.before_rows(sql_error));
Line 252  public: Line 314  public:
                                 CHECK(handlers.add_row(sql_error));                                  CHECK(handlers.add_row(sql_error));
                                 for(int i=0; i<column_count; i++){                                  for(int i=0; i<column_count; i++){
                                         const char *cell=PQgetvalue(res, r, i);                                          const char *cell=PQgetvalue(res, r, i);
                                         size_t size;                                          size_t length;
                                         void *ptr;                                          const char* str;
                                         if(PQftype(res, i)==OIDOID) {                                          if(PQftype(res, i)==OIDOID) {
                                                 // ObjectID column, read object bytes                                                  // ObjectID column, read object bytes
   
Line 264  public: Line 326  public:
                                                         // seek to end                                                          // seek to end
                                                         if(lo_lseek(conn, fd, 0, SEEK_END)<0)                                                          if(lo_lseek(conn, fd, 0, SEEK_END)<0)
                                                                 PQclear_throwPQerror;                                                                  PQclear_throwPQerror;
                                                         // get size                                                          // get length
                                                         int size_tell=lo_tell(conn, fd);                                                          int size_tell=lo_tell(conn, fd);
                                                         if(size_tell<0)                                                          if(size_tell<0)
                                                                 PQclear_throwPQerror;                                                                  PQclear_throwPQerror;
                                                         // seek to begin                                                          // seek to begin
                                                         if(lo_lseek(conn, fd, 0, SEEK_SET)<0)                                                          if(lo_lseek(conn, fd, 0, SEEK_SET)<0)
                                                                 PQclear_throwPQerror;                                                                  PQclear_throwPQerror;
                                                         size=(size_t)size_tell;                                                          length=(size_t)size_tell;
                                                         if(size) {                                                          if(length) {
                                                                 // read                                                                   // read 
                                                                 ptr=services.malloc(size);                                                                  char* strm=(char*)services.malloc(length+1);
                                                                 if(!lo_read_ex(conn, fd, (const char *)ptr, size_tell))                                                                  if(!lo_read_ex(conn, fd, strm, size_tell))
                                                                         PQclear_throw("lo_read can not read all bytes of object");                                                                          PQclear_throw("lo_read can not read all bytes of object");
                                                                   strm[length]=0;
                                                                   str=strm;
                                                         } else                                                          } else
                                                                 ptr=0;                                                                  str=0;
                                                         if(lo_close(conn, fd)<0)                                                          if(lo_close(conn, fd)<0)
                                                                 PQclear_throwPQerror;                                                                  PQclear_throwPQerror;
                                                 } else                                                  } else
                                                         PQclear_throwPQerror;                                                          PQclear_throwPQerror;
                                         } else {                                          } else {
                                                 // normal column, read it normally                                                  // normal column, read it normally
                                                 size=(size_t)PQgetlength(res, r, i);                                                  length=(size_t)PQgetlength(res, r, i);
                                                 if(size) {                                                  if(length) {
                                                         ptr=services.malloc(size);                                                          char* strm=(char*)services.malloc(length+1);
                                                         memcpy(ptr, cell, size);                                                          memcpy(strm, cell, length+1);
                                                           str=strm;
                                                 } else                                                  } else
                                                         ptr=0;                                                          str=0;
                                           }
   
                                           if(str && length) {
                                                   // transcode from ?ClientCharset to $request:charset
                                                   if(cstrClientCharset)
                                                           services.transcode(str, length,
                                                                   str, length,
                                                                   cstrClientCharset,
                                                                   services.request_charset());
                                         }                                          }
                                         CHECK(handlers.add_row_cell(sql_error, ptr, size));  
                                           CHECK(handlers.add_row_cell(sql_error, str, length));
                                 }                                  }
                         }                          }
 cleanup:  cleanup:
Line 303  cleanup: Line 378  cleanup:
   
 private: // private funcs  private: // private funcs
   
         void begin_transaction(SQL_Driver_services& services, PGconn *conn) {          void bind_parameters(
                 if(PGresult *res=PQexec(conn, "BEGIN"))                  size_t placeholders_count, 
                         PQclear(res);                  Placeholder* placeholders, 
                   const char** paramValues,
                   Connection& connection
                   ) {
                   for(size_t i=0; i<placeholders_count; i++) {
                           Placeholder& ph=placeholders[i];
                           size_t value_length;
                           if(connection.cstrClientCharset) {
                                   size_t name_length;
                                   connection.services->transcode(ph.name, strlen(ph.name),
                                           ph.name, name_length,
                                           connection.services->request_charset(),
                                           connection.cstrClientCharset);
   
                                   if(ph.value) {
                                           connection.services->transcode(ph.value, strlen(ph.value),
                                                   ph.value, value_length,
                                                   connection.services->request_charset(),
                                                   connection.cstrClientCharset);
                                   }
                           }
                           if( atoi(ph.name) <= 0 || atoi(ph.name) > placeholders_count) {
                                   connection.services->_throw("bad bind parameter key");
                           }
                           paramValues[atoi(ph.name)-1] = ph.value;
                   }
           }
           
           
           void execute_transaction_cmd(void *aconnection, const char *query) {
                   Connection& connection=*static_cast<Connection*>(aconnection);
   
                   if(connection.autocommit){
                           Connection& connection=*static_cast<Connection*>(aconnection);
                           execute_resultless(connection, query);
                   }
   
                   begin_transaction(connection);
           }
           
           /**
                   Executes a query and throws the result.
           */
           void execute_resultless(const Connection& connection, const char *query) {
                   if(PGresult *res=PQexec(connection.conn, query))
                           PQclear(res); // throw out the result [don't need but must call]
                 else                  else
                         throwPQerror;                          throwPQerror;
         }          }
   
         const char *preprocess_statement(SQL_Driver_services& services, PGconn *conn,          void begin_transaction(Connection& connection) {
                   if(connection.autocommit){
                           execute_resultless(connection, "BEGIN");
                   }
           }
   
           const char *preprocess_statement(Connection& connection,
                 const char *astatement, unsigned long offset, unsigned long limit) {                  const char *astatement, unsigned long offset, unsigned long limit) {
                   PGconn *conn=connection.conn;
   
                 size_t statement_size=strlen(astatement);                  size_t statement_size=strlen(astatement);
   
                 char *result=(char *)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);
Line 338  private: // private funcs Line 466  private: // private funcs
                                 o[0]=='/' &&                                  o[0]=='/' &&
                                 o[1]=='*' &&                                   o[1]=='*' && 
                                 o[2]=='*') { // name start                                  o[2]=='*') { // name start
                                   const char* saved_o=o;
                                 o+=3;                                  o+=3;
                                 while(*o)                                  while(*o)
                                         if(                                          if(
Line 345  private: // private funcs Line 474  private: // private funcs
                                                 o[1]=='*' &&                                                  o[1]=='*' &&
                                                 o[2]=='/' &&                                                  o[2]=='/' &&
                                                 o[3]=='\'') { // name end                                                  o[3]=='\'') { // name end
                                                   saved_o=0; // found, marking that
                                                 o+=4;                                                  o+=4;
                                                 Oid oid=lo_creat(conn, INV_READ|INV_WRITE);                                                  Oid oid=lo_creat(conn, INV_READ|INV_WRITE);
                                                 if(oid==InvalidOid)                                                  if(oid==InvalidOid)
Line 358  private: // private funcs Line 488  private: // private funcs
                                                                 if(escaped) {                                                                  if(escaped) {
                                                                         // write pending, skip "\" or "'"                                                                          // write pending, skip "\" or "'"
                                                                         if(!lo_write_ex(conn, fd, start, o-start))                                                                          if(!lo_write_ex(conn, fd, start, o-start))
                                                                                 services._throw("lo_write could not write all bytes of object (1)");                                                                                  connection.services->_throw("lo_write could not write all bytes of object (1)");
                                                                         start=++o;                                                                          start=++o;
                                                                 } else                                                                  } else
                                                                         o++;                                                                          o++;
                                                         }                                                          }
                                                         if(!lo_write_ex(conn, fd, start, o-start))                                                          if(!lo_write_ex(conn, fd, start, o-start))
                                                                 services._throw("lo_write can not write all bytes of object (2)");                                                                  connection.services->_throw("lo_write can not write all bytes of object (2)");
                                                         if(lo_close(conn, fd)<0)                                                          if(lo_close(conn, fd)<0)
                                                                 throwPQerror;                                                                  throwPQerror;
                                                 } else                                                  } else
Line 376  private: // private funcs Line 506  private: // private funcs
                                                 break;                                                  break;
                                         } else                                          } else
                                                 o++; // /**skip**/'xxx'                                                  o++; // /**skip**/'xxx'
                                   if(saved_o) {
                                           o=saved_o;
                                           *n++=*o++;
                                   }
                         } else                          } else
                                 *n++=*o++;                                  *n++=*o++;
                 }                  }
Line 387  private: // private funcs Line 521  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 418  private: // conn client library funcs Line 551  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;
Line 434  private: // conn client library funcs Line 577  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 450  private: // conn client library funcs li Line 597  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 473  private: // conn client library funcs li Line 620  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 482  private: // conn client library funcs li Line 631  private: // conn client library funcs li
   
                 return 0;                  return 0;
         }          }
   
 };  };
   
 extern "C" SQL_Driver *SQL_DRIVER_CREATE() {  extern "C" SQL_Driver *SQL_DRIVER_CREATE() {
Removed from v.1.11  
changed lines
  Added in v.1.29

E-mail: