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

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

version 1.29, 2008/06/24 17:43:48 version 1.30, 2008/06/26 15:49:40
Line 36  static const char *RCSId="$Id$"; Line 36  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;
                 }                  }
Line 51  static char *lsplit(char *string, char d Line 50  static char *lsplit(char *string, char d
         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) {  static char* rsplit(char* string, char delim){
         if(string) {          if(string){
                 char* v=strrchr(string, delim);                   if(char* v=strrchr(string, delim)){
                 if(v) {  
                         *v=0;                          *v=0;
                         return v+1;                          return v+1;
                 }                  }
Line 69  static char* rsplit(char* string, char d Line 67  static char* rsplit(char* string, char d
         return NULL;              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++);
 }  }
Line 78  struct Connection { Line 76  struct Connection {
         SQL_Driver_services* services;          SQL_Driver_services* services;
   
         PGconn *conn;          PGconn *conn;
         const char* cstrClientCharset;          const char* client_charset;
         bool autocommit;          bool autocommit;
 };  };
   
Line 92  public: Line 90  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 110  public: Line 108  public:
         /**     connect          /**     connect
                 @param url                  @param url
                         format: @b user:pass@host[:port]|[local]/database?                          format: @b user:pass@host[:port]|[local]/database?
                         ClientCharset=xyz&      // transcode by parser                          ClientCharset=charset&  // transcode by parser
                         charset=xyz&            // transcode by server with 'set CLIENT_ENCODING=xyz'                          charset=value&                  // transcode by server with 'SET CLIENT_ENCODING=value'
                         datestyle=xyz&          // set DATESTYLE=xyz                          datestyle=value&                // 'SET DATESTYLE=value' available values are: ISO|SQL|Postgres|European|US|German [default=ISO]
                         autocommit=1&                          autocommit=1&
                         WithoutDefaultTransaction=1     // == autocommit=0                          WithoutDefaultTransaction=1     // == autocommit=0
         */          */
         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=rsplit(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;                  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.autocommit=true;
                 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, 
Line 151  public: Line 149  public:
                         if(char *key=lsplit(&options, '&')){                          if(char *key=lsplit(&options, '&')){
                                 if(*key){                                  if(*key){
                                         if(char *value=lsplit(key, '=')){                                          if(char *value=lsplit(key, '=')){
                                                 if(strcmp(key, "ClientCharset")==0) { // transcoding with parser                                                  if(strcmp(key, "ClientCharset")==0){ // transcoding with parser
                                                         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){ // transcoding with server                                                  } else if(strcasecmp(key, "charset")==0){ // transcoding with server
                                                         cstrBackwardCompAskServerToTranscode=value;                                                          charset=value;
                                                 } else if(strcasecmp(key, "datestyle")==0) {                                                  } else if(strcasecmp(key, "datestyle")==0){
                                                         datestyle=value;                                                          datestyle=value;
                                                 } else if(strcasecmp(key, "autocommit")==0){                                                  } else if(strcasecmp(key, "autocommit")==0){
                                                         if(atoi(value)==0)                                                          if(atoi(value)==0)
Line 172  public: Line 170  public:
                         }                          }
                 }                  }
   
                 if(cstrBackwardCompAskServerToTranscode){                  if(charset){
                         char statement[MAX_STRING]="set CLIENT_ENCODING=";                          char statement[MAX_STRING]="SET CLIENT_ENCODING=";
                         strncat(statement, cstrBackwardCompAskServerToTranscode, MAX_STRING);                          strncat(statement, charset, MAX_STRING);
   
                         execute_resultless(connection, statement);                          _execute_cmd(connection, statement);
                 }                  }
   
                 if(datestyle){                  if(datestyle){
                         char statement[MAX_STRING]="set DATESTYLE="; // ISO,SQL,Postgres,European,NonEuropean=US,German,DEFAULT=ISO                          char statement[MAX_STRING]="SET DATESTYLE=";
                         strncat(statement, datestyle, MAX_STRING);                          strncat(statement, datestyle, MAX_STRING);
   
                         execute_resultless(connection, statement);                          _execute_cmd(connection, statement);
                 }                  }
   
                 begin_transaction(connection);                  _begin_transaction(connection);
         }          }
   
         void disconnect(void *aconnection) {          void disconnect(void *aconnection){
                 Connection& connection=*static_cast<Connection*>(aconnection);                  Connection& connection=*static_cast<Connection*>(aconnection);
   
                 PQfinish(connection.conn);                  PQfinish(connection.conn);
                 connection.conn=0;                  connection.conn=0;
         }          }
   
         void commit(void *aconnection) {          void commit(void *aconnection){
                 execute_transaction_cmd(aconnection, "COMMIT");                  Connection& connection=*static_cast<Connection*>(aconnection);
                   if(connection.autocommit){
                           _execute_cmd(connection, "COMMIT");
                   }
                   _begin_transaction(connection);
         }          }
   
         void rollback(void *aconnection) {          void rollback(void *aconnection){
                 execute_transaction_cmd(aconnection, "ROLLBACK");                  Connection& connection=*static_cast<Connection*>(aconnection);
                   if(connection.autocommit){
                           _execute_cmd(connection, "ROLLBACK");
                   }
                   _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(          const char* quote(void *aconnection, const char *from, unsigned int length){
                 void *aconnection,  
                 const char *from, unsigned int length) {  
                 Connection& connection=*static_cast<Connection*>(aconnection);                  Connection& connection=*static_cast<Connection*>(aconnection);
   
                 char *result=(char*)connection.services->malloc_atomic(length*2+1);                  char *result=(char*)connection.services->malloc_atomic(length*2+1);
                 int err=0;                  int err=0;
                 PQescapeStringConn (connection.conn,                  PQescapeStringConn(connection.conn, result, from, length, &err);
                                                         result, from, length,  
                                                         &err);  
                 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;                  const char* client_charset=connection.client_charset;
                 SQL_Driver_services& services=*connection.services;                  SQL_Driver_services& services=*connection.services;
                 PGconn *conn=connection.conn;                  PGconn *conn=connection.conn;
   
                   bool transcode_needed=_transcode_required(connection);
   
                 const char** paramValues;                  const char** paramValues;
                 if(placeholders_count>0){                  if(placeholders_count>0){
                         //services._throw("bind variables not supported (yet)");                          int binds_size=sizeof(char)*placeholders_count;
                         int binds_size=sizeof(char) * placeholders_count;  
                         paramValues = static_cast<const char**>(services.malloc_atomic(binds_size));                          paramValues = static_cast<const char**>(services.malloc_atomic(binds_size));
                         bind_parameters(placeholders_count, placeholders, paramValues, connection);                          _bind_parameters(placeholders_count, placeholders, paramValues, connection, transcode_needed);
                 }                  }
   
                 // transcode from $request:charset to ?ClientCharset                  // transcode query from $request:charset to ?ClientCharset
                 if(cstrClientCharset) {                  if(transcode_needed){
                         size_t transcoded_statement_size;                          size_t length=strlen(astatement);
                         services.transcode(astatement, strlen(astatement),                          services.transcode(astatement, length,
                                 astatement, transcoded_statement_size,                                  astatement, length,
                                 services.request_charset(),                                  services.request_charset(),
                                 cstrClientCharset);                                  connection.client_charset);
                 }                  }
   
                 const char *statement=preprocess_statement(connection,                  const char *statement=_preprocess_statement(connection, astatement, offset, limit);
                         astatement, offset, limit);                  // error after prepare?
   
                 PGresult *res;                  PGresult *res;
                 if(placeholders_count>0){                  if(placeholders_count>0){
Line 264  public: Line 265  public:
                         throwPQerror;                          throwPQerror;
   
                 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);                                  return;
                         return;                          case PGRES_TUPLES_OK: 
                 case PGRES_TUPLES_OK:                                   break;  
                         break;                            default:
                 default:                                  PQclear_throwPQerror;
                         PQclear_throwPQerror;                                  break;
                         break;  
                 }                  }
                                   
                 int column_count=PQnfields(res);                  int column_count=PQnfields(res);
Line 297  public: Line 297  public:
                         memcpy(strm, name, length+1);                          memcpy(strm, name, length+1);
                         const char* str=strm;                          const char* str=strm;
   
                         // transcode from ?ClientCharset to $request:charset                          // transcode column name from ?ClientCharset to $request:charset
                         if(cstrClientCharset)                           if(transcode_needed) 
                                 services.transcode(str, length,                                  services.transcode(str, length,
                                         str, length,                                          str, length,
                                         cstrClientCharset,                                          connection.client_charset,
                                         services.request_charset());                                          services.request_charset());
   
                         CHECK(handlers.add_column(sql_error, str, length));                          CHECK(handlers.add_column(sql_error, str, length));
Line 358  public: Line 358  public:
                                                         str=0;                                                          str=0;
                                         }                                          }
   
                                         if(str && length) {                                          if(transcode_needed && str && length){
                                                 // transcode from ?ClientCharset to $request:charset                                                  // transcode cell value from ?ClientCharset to $request:charset
                                                 if(cstrClientCharset)                                                  services.transcode(str, length,
                                                         services.transcode(str, length,                                                          str, length,
                                                                 str, length,                                                          connection.client_charset,
                                                                 cstrClientCharset,                                                          services.request_charset());
                                                                 services.request_charset());  
                                         }                                          }
   
                                         CHECK(handlers.add_row_cell(sql_error, str, length));                                          CHECK(handlers.add_row_cell(sql_error, str, length));
Line 376  cleanup: Line 375  cleanup:
                         services._throw(sql_error);                          services._throw(sql_error);
         }          }
   
 private: // private funcs  private:
           void _bind_parameters(
         void bind_parameters(                                  size_t placeholders_count, 
                 size_t placeholders_count,                                   Placeholder* placeholders, 
                 Placeholder* placeholders,                                   const char** paramValues,
                 const char** paramValues,                                  Connection& connection,
                 Connection& connection                                  bool transcode_needed
                 ) {          ){
                 for(size_t i=0; i<placeholders_count; i++) {                  for(size_t i=0; i<placeholders_count; i++){
                         Placeholder& ph=placeholders[i];                          Placeholder& ph=placeholders[i];
                         size_t value_length;                          if(transcode_needed){
                         if(connection.cstrClientCharset) {  
                                 size_t name_length;                                  size_t name_length;
                                   size_t value_length;
                                 connection.services->transcode(ph.name, strlen(ph.name),                                  connection.services->transcode(ph.name, strlen(ph.name),
                                         ph.name, name_length,                                          ph.name, name_length,
                                         connection.services->request_charset(),                                          connection.services->request_charset(),
                                         connection.cstrClientCharset);                                          connection.client_charset);
   
                                 if(ph.value) {                                  if(ph.value) {
                                         connection.services->transcode(ph.value, strlen(ph.value),                                          connection.services->transcode(ph.value, strlen(ph.value),
                                                 ph.value, value_length,                                                  ph.value, value_length,
                                                 connection.services->request_charset(),                                                  connection.services->request_charset(),
                                                 connection.cstrClientCharset);                                                  connection.client_charset);
                                 }                                  }
                         }                          }
                         if( atoi(ph.name) <= 0 || atoi(ph.name) > placeholders_count) {                          int name_numner=atoi(ph.name);
                           if(name_numner <= 0 || name_numner > placeholders_count)
                                 connection.services->_throw("bad bind parameter key");                                  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){                          paramValues[name_numner-1]=ph.value;
                         Connection& connection=*static_cast<Connection*>(aconnection);  
                         execute_resultless(connection, query);  
                 }                  }
   
                 begin_transaction(connection);  
         }          }
                   
           
         /**          /**
                 Executes a query and throws the result.                  Executes a query and throw away the result.
         */          */
         void execute_resultless(const Connection& connection, const char *query) {          void _execute_cmd(const Connection& connection, const char *query){
                 if(PGresult *res=PQexec(connection.conn, query))                  if(PGresult *res=PQexec(connection.conn, query))
                         PQclear(res); // throw out the result [don't need but must call]                          PQclear(res); // throw out the result [don't need but must call]
                 else                  else
                         throwPQerror;                          throwPQerror;
         }          }
   
         void begin_transaction(Connection& connection) {          void _begin_transaction(Connection& connection){
                 if(connection.autocommit){                  if(connection.autocommit)
                         execute_resultless(connection, "BEGIN");                          _execute_cmd(connection, "BEGIN");
                 }  
         }          }
   
         const char *preprocess_statement(Connection& connection,          const char *_preprocess_statement(
                 const char *astatement, unsigned long offset, unsigned long limit) {                                          Connection& connection,
                                           const char *astatement,
                                           unsigned long offset,
                                           unsigned long limit
           ){
                 PGconn *conn=connection.conn;                  PGconn *conn=connection.conn;
   
                 size_t statement_size=strlen(astatement);                  size_t statement_size=strlen(astatement);
Line 448  private: // private funcs Line 440  private: // private funcs
                         +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 %u", limit);
                         if(offset)                          if(offset)
                                 cur+=snprintf(cur, 8+MAX_NUMBER, " offset %u", offset);                                  cur+=snprintf(cur, 8+MAX_NUMBER, " offset %u", offset);
Line 518  private: // private funcs Line 510  private: // private funcs
                 return result;                  return result;
         }          }
   
           bool _transcode_required(Connection& connection){
                   return (connection.client_charset && strcmp(connection.client_charset, connection.services->request_charset())!=0);
           }
   
 private: // lo_read/write exchancements  private: // lo_read/write exchancements
   
         bool lo_read_ex(PGconn *conn, int fd, const/*paf*/ char *buf, size_t len) {          bool lo_read_ex(PGconn *conn, int fd, const/*paf*/ char *buf, size_t len) {
Line 569  private: // conn client library funcs Line 565  private: // conn client library funcs
         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;
Removed from v.1.29  
changed lines
  Added in v.1.30

E-mail: