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

Diff for /sql/pgsql/parser3pgsql.C between versions 1.42 and 1.49

version 1.42, 2012/10/19 04:13:28 version 1.49, 2021/11/03 16:27:15
Line 1 Line 1
 /** @file  /** @file
         Parser PgSQL driver.          Parser PgSQL driver.
   
         Copyright (c) 2001-2012 Art. Lebedev Studio (http://www.artlebedev.com)          Copyright (c) 2001-2019 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)
   
Line 78  static char* rsplit(char* string, char d Line 78  static char* rsplit(char* string, char d
                         return v+1;                          return v+1;
                 }                  }
         }          }
         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){
Line 99  struct Connection { Line 99  struct Connection {
         PGconn *conn;          PGconn *conn;
         const char* client_charset;          const char* client_charset;
         bool autocommit;          bool autocommit;
         bool without_default_transactions;  
         bool standard_conforming_strings;          bool standard_conforming_strings;
 };  };
   
Line 117  public: Line 116  public:
   
         /// 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 connection.services->_throw(PQerrorMessage(connection.conn))          #define throwPQerror connection.services->_throw(PQerrorMessage(connection.conn))
         #define PQclear_throw(msg) { \          #define PQclear_throw(msg) { \
                         PQclear(res); \                          PQclear(res); \
                         connection.services->_throw(msg); \                          connection.services->_throw(msg); \
                 }                                                                 }
         #define PQclear_throwPQerror PQclear_throw(PQerrorMessage(connection.conn))          #define PQclear_throwPQerror PQclear_throw(PQerrorMessage(connection.conn))
   
         /**     connect          /**     connect
Line 134  public: Line 132  public:
                         ClientCharset=charset&  // transcode by parser                          ClientCharset=charset&  // transcode by parser
                         charset=value&                  // transcode by server with 'SET CLIENT_ENCODING=value'                          charset=value&                  // transcode by server with 'SET CLIENT_ENCODING=value'
                         datestyle=value&                // 'SET DATESTYLE=value' available values are: ISO|SQL|Postgres|European|US|German [default=ISO]                          datestyle=value&                // 'SET DATESTYLE=value' available values are: ISO|SQL|Postgres|European|US|German [default=ISO]
                         autocommit=1&                   // each transaction is commited automatically (default)                          autocommit=0&                   // 1 -- each statement is commited automatically, only when with_default_transaction enabled
                         WithoutDefaultTransaction=0     // 1 -- disable any BEGIN TRAN/COMMIT/ROLLBACK [can NOT be used with autocommit option]                          standard_conforming_strings=1&  // 0 -- escape \ char that could be needed for old servers
         */          */
         void connect(          void connect(char* url, SQL_Driver_services& services, void** connection_ref /* < output: Connection* */){
                                 char* url,   
                                 SQL_Driver_services& services,   
                                 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, '/');
Line 154  public: Line 148  public:
                 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.client_charset=0;                      connection.client_charset=0;
                 connection.autocommit=true;                  connection.autocommit=true;
                 connection.without_default_transactions=false;  
                 connection.standard_conforming_strings=true;                  connection.standard_conforming_strings=true;
   
                 connection.conn=PQsetdbLogin(  
                         (host&&strcasecmp(host, "local")==0)?NULL/* local Unix domain socket */:host, port,   
                         NULL, NULL, db, user, pwd);  
   
                 if(!connection.conn)  
                         services._throw("PQsetdbLogin failed");  
   
                 if(PQstatus(connection.conn)!=CONNECTION_OK)  
                         throwPQerror;  
   
                 while(options){                  while(options){
                         if(char *key=lsplit(&options, '&')){                          if(char *key=lsplit(&options, '&')){
                                 if(*key){                                  if(*key){
Line 183  public: Line 167  public:
                                                 } else if(strcasecmp(key, "datestyle")==0){                                                  } else if(strcasecmp(key, "datestyle")==0){
                                                         datestyle=value;                                                          datestyle=value;
                                                 } else if(strcasecmp(key, "autocommit")==0){                                                  } else if(strcasecmp(key, "autocommit")==0){
                                                         if(connection.without_default_transactions)  
                                                                 services._throw("options WithoutDefaultTransaction and autocommit can't be used together");  
                                                         if(atoi(value)==0)                                                          if(atoi(value)==0)
                                                                 connection.autocommit=false;                                                                  connection.autocommit=false;
                                                 } else if(strcmp(key, "WithoutDefaultTransaction")==0){  
                                                         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 if(strcasecmp(key, "standard_conforming_strings")==0){                                                  } else if(strcasecmp(key, "standard_conforming_strings")==0){
                                                         if(atoi(value)==0)                                                          if(atoi(value)==0)
                                                                 connection.standard_conforming_strings=false;                                                                  connection.standard_conforming_strings=false;
Line 205  public: Line 180  public:
                         }                          }
                 }                  }
   
                   connection.conn=PQsetdbLogin( (host && strcasecmp(host, "local") == 0) ? NULL /* local Unix domain socket */ : host, port, NULL, NULL, db, user, pwd);
   
                   if(!connection.conn)
                           services._throw("PQsetdbLogin failed");
   
                   if(PQstatus(connection.conn)!=CONNECTION_OK)
                           throwPQerror;
   
                 if(charset){                  if(charset){
                         char statement[MAX_STRING+1]="SET CLIENT_ENCODING=";                          char statement[MAX_STRING+1]="SET CLIENT_ENCODING=";
                         strncat(statement, charset, MAX_STRING);                          strncat(statement, charset, MAX_STRING);
Line 219  public: Line 202  public:
                         _execute_cmd(connection, statement);                          _execute_cmd(connection, statement);
                 }                  }
   
                 _transaction_begin(connection);                  if(!connection.autocommit)
                           _execute_cmd(connection, "set AUTOCOMMIT off");
         }          }
   
         void disconnect(void *aconnection){          void disconnect(void *aconnection){
Line 230  public: Line 214  public:
   
         void commit(void *aconnection){          void commit(void *aconnection){
                 Connection& connection=*static_cast<Connection*>(aconnection);                  Connection& connection=*static_cast<Connection*>(aconnection);
                 _transaction_commit(connection);                  if(!connection.autocommit)
                 _transaction_begin(connection);                          _execute_cmd(connection, "COMMIT");
         }          }
   
         void rollback(void *aconnection){          void rollback(void *aconnection){
                 Connection& connection=*static_cast<Connection*>(aconnection);                  Connection& connection=*static_cast<Connection*>(aconnection);
                 _transaction_rollback(connection);                  if(!connection.autocommit)
                 _transaction_begin(connection);                          _execute_cmd(connection, "ROLLBACK");
         }          }
   
         bool ping(void *aconnection) {          bool ping(void *aconnection) {
Line 247  public: Line 231  public:
   
         // charset here is services.request_charset(), not connection.client_charset          // charset here is services.request_charset(), not connection.client_charset
         // thus we can't use the sql server quoting support          // thus we can't use the sql server quoting support
         const char* quote(void *aconnection, const char *str, unsigned int length)           const char* quote(void *aconnection, const char *str, unsigned int length){
         {  
                 Connection& connection=*static_cast<Connection*>(aconnection);                  Connection& connection=*static_cast<Connection*>(aconnection);
   
                 const char* from;                  const char* from;
Line 301  public: Line 284  public:
                 return result;                  return result;
         }          }
   
         void query(void *aconnection,           void query(void *aconnection, const char *astatement, size_t placeholders_count, Placeholder* placeholders, unsigned long offset, unsigned long limit, SQL_Driver_query_event_handlers& handlers ){
                                 const char *astatement,   
                                 size_t placeholders_count, Placeholder* placeholders,   
                                 unsigned long offset, unsigned long limit,  
                                 SQL_Driver_query_event_handlers& handlers  
         ){  
                 Connection& connection=*static_cast<Connection*>(aconnection);                  Connection& connection=*static_cast<Connection*>(aconnection);
                 SQL_Driver_services& services=*connection.services;                  SQL_Driver_services& services=*connection.services;
                 PGconn *conn=connection.conn;                  PGconn *conn=connection.conn;
Line 326  public: Line 304  public:
                 if(transcode_needed){                  if(transcode_needed){
                         // transcode query from $request:charset to ?ClientCharset                          // transcode query from $request:charset to ?ClientCharset
                         statement_size=strlen(astatement);                          statement_size=strlen(astatement);
                         services.transcode(astatement, statement_size,                          services.transcode(astatement, statement_size, astatement, statement_size, request_charset, client_charset);
                                 astatement, statement_size,  
                                 request_charset,  
                                 client_charset);  
                 }                  }
   
                 const char *statement=_preprocess_statement(connection, astatement, statement_size, offset, limit);                  const char *statement=_preprocess_statement(connection, astatement, statement_size, offset, limit);
Line 348  public: Line 323  public:
                 SQL_Error sql_error;                  SQL_Error sql_error;
   
                 switch(PQresultStatus(res)) {                  switch(PQresultStatus(res)) {
                         case PGRES_EMPTY_QUERY:                           case PGRES_EMPTY_QUERY:
                                 PQclear_throw("no query");                                  PQclear_throw("no query");
                                 break;                                  break;
                         case PGRES_COMMAND_OK: // empty result: insert|delete|update|...                          case PGRES_COMMAND_OK: // empty result: insert|delete|update|...
                                 PQclear(res);                                  PQclear(res);
                                 if(connection.autocommit)  
                                         commit(aconnection);  
                                 return;                                  return;
                         case PGRES_TUPLES_OK:                           case PGRES_TUPLES_OK: 
                                 break;                                    break;
                         default:                          default:
                                 PQclear_throwPQerror;                                  PQclear_throwPQerror;
                                 break;                                  break;
Line 387  public: Line 360  public:
   
                         if(transcode_needed)                          if(transcode_needed)
                                 // transcode column name from ?ClientCharset to $request:charset                                  // transcode column name from ?ClientCharset to $request:charset
                                 services.transcode(str, length,                                  services.transcode(str, length, str, length, client_charset, request_charset);
                                         str, length,  
                                         client_charset,  
                                         request_charset);  
   
                         CHECK(handlers.add_column(sql_error, str, length));                          CHECK(handlers.add_column(sql_error, str, length));
                 }                  }
Line 481  cleanup: Line 451  cleanup:
                 PQclear(res);                  PQclear(res);
                 if(failed)                  if(failed)
                         services._throw(sql_error);                          services._throw(sql_error);
   
                 if(connection.autocommit)  
                         commit(aconnection);  
         }          }
   
 private:  private:
         void _bind_parameters(          void _bind_parameters( size_t placeholders_count, Placeholder* placeholders, const char** paramValues, Connection& connection, bool transcode_needed){
                                 size_t placeholders_count,   
                                 Placeholder* placeholders,   
                                 const char** paramValues,  
                                 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];
                         if(transcode_needed){                          if(transcode_needed){
                                 size_t name_length;                                  size_t name_length;
                                 connection.services->transcode(ph.name, strlen(ph.name),                                  connection.services->transcode(ph.name, strlen(ph.name), ph.name, name_length, connection.services->request_charset(), connection.client_charset);
                                         ph.name, name_length,  
                                         connection.services->request_charset(),  
                                         connection.client_charset);  
   
                                 if(ph.value) {                                  if(ph.value) {
                                         size_t value_length;                                          size_t value_length;
                                         connection.services->transcode(ph.value, strlen(ph.value),                                          connection.services->transcode(ph.value, strlen(ph.value), ph.value, value_length, connection.services->request_charset(), connection.client_charset);
                                                 ph.value, value_length,  
                                                 connection.services->request_charset(),  
                                                 connection.client_charset);  
                                 }                                  }
                         }                          }
                         int name_number=atoi(ph.name);                          int name_number=atoi(ph.name);
Line 519  private: Line 474  private:
                 }                  }
         }          }
                   
           
         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.          // executes a query and throw away the result.
         void _execute_cmd(const Connection& connection, const char *query){          void _execute_cmd(const Connection& connection, const char *query){
                 if(PGresult *res=PQexec(connection.conn, query))                  if(PGresult *res=PQexec(connection.conn, query))
Line 545  private: Line 482  private:
                         throwPQerror;                          throwPQerror;
         }          }
   
         const char *_preprocess_statement(          const char *_preprocess_statement(Connection& connection, const char *astatement, size_t statement_size, 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;
   
                 if(!statement_size)                  if(!statement_size)
Line 584  private: Line 515  private:
                                 const char* saved_o=o;                                  const char* saved_o=o;
                                 o+=3;                                  o+=3;
                                 while(*o)                                  while(*o)
                                         if(                                          if(o[0]=='*' &&         o[1]=='*' && o[2]=='/' && o[3]=='\'') { // name end
                                                 o[0]=='*' &&  
                                                 o[1]=='*' &&  
                                                 o[2]=='/' &&  
                                                 o[3]=='\'') { // name end  
                                                 saved_o=0; // found, marking that                                                  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);
Line 746  private: // conn client library funcs li Line 673  private: // conn client library funcs li
                 DLINK(PQexecParams);                  DLINK(PQexecParams);
                 DLINK(PQftype);                  DLINK(PQftype);
                 DLINK(PQescapeStringConn);                  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);
                 DLINK(lo_tell);         DLINK(lo_unlink);                  DLINK(lo_tell);   DLINK(lo_unlink);
                 DLINK(lo_import);               DLINK(lo_export);                  DLINK(lo_import); DLINK(lo_export);
   
                 return 0;                  return 0;
         }          }
Removed from v.1.42  
changed lines
  Added in v.1.49

E-mail: