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

Diff for /sql/pgsql/parser3pgsql.C between versions 1.16 and 1.25

version 1.16, 2004/01/26 15:22:26 version 1.25, 2004/12/23 16:54:52
Line 58  static char *lsplit(char **string_ref, c Line 58  static char *lsplit(char **string_ref, c
     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 {  struct Connection {
         SQL_Driver_services* services;          SQL_Driver_services* services;
   
         PGconn *conn;          PGconn *conn;
           const char* cstrClientCharset;
 };  };
   
 /**  /**
Line 89  public: Line 106  public:
         #define PQclear_throwPQerror PQclear_throw(PQerrorMessage(connection.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
         */          */
         void connect(          void connect(
                 char *used_only_in_connect_url,                   char *url, 
                 SQL_Driver_services& services,                   SQL_Driver_services& services, 
                 void **connection_ref ///< output: Connection*                  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, '?');
   
                 Connection& connection=*(Connection  *)::calloc(sizeof(Connection), 1);                  char *cstrBackwardCompAskServerToTranscode=0;
   
                   Connection& connection=*(Connection  *)services.malloc(sizeof(Connection));
                 *connection_ref=&connection;                  *connection_ref=&connection;
                 connection.services=&services;                  connection.services=&services;
                   connection.cstrClientCharset=0; 
                 connection.conn=PQsetdbLogin(                  connection.conn=PQsetdbLogin(
                         (host&&strcasecmp(host, "local")==0)?NULL/* local Unix domain socket */:host, port,                           (host&&strcasecmp(host, "local")==0)?NULL/* local Unix domain socket */:host, port, 
                         NULL, NULL, db, user, pwd);                          NULL, NULL, db, user, pwd);
Line 118  public: Line 138  public:
   
                 char *charset=0;                  char *charset=0;
                 char *datestyle=0;                  char *datestyle=0;
                   isDefaultTransaction = true;
   
                 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) {
                                                         charset=value;                                                          toupper_str(value, value, strlen(value));
                                                           connection.cstrClientCharset=value;
                                                   } else if(strcasecmp(key, "charset")==0) { // left for backward compatibility, consider using ClientCharset
                                                           cstrBackwardCompAskServerToTranscode=value;
                                                 } else if(strcasecmp(key, "datestyle")==0) {                                                  } else if(strcasecmp(key, "datestyle")==0) {
                                                         datestyle=value;                                                          datestyle=value;
                                                   } else if(strcmp(key, "WithoutDefaultTransaction")==0) {
                                                           isDefaultTransaction = false;
                                                 } else                                                  } else
                                                         services._throw("unknown connect option" /*key*/);                                                          services._throw("unknown connect option" /*key*/);
                                         } else                                           } else 
Line 135  public: Line 161  public:
                         }                          }
                 }                  }
   
                 if(charset) {                  if(connection.cstrClientCharset && cstrBackwardCompAskServerToTranscode)
                           services._throw("use 'ClientCharset' option only, "
                                   "'charset' option is obsolete and should not be used with new 'ClientCharset' option");
   
                   if(cstrBackwardCompAskServerToTranscode) {
                         // set CLIENT_ENCODING                          // set CLIENT_ENCODING
                         char statement[MAX_STRING]="set CLIENT_ENCODING="; // win                          char statement[MAX_STRING]="set CLIENT_ENCODING="; // win
                         strncat(statement, charset, MAX_STRING);                          strncat(statement, cstrBackwardCompAskServerToTranscode, MAX_STRING);
                                                   
                         PGresult *res=PQexec(connection.conn, statement);                          PGresult *res=PQexec(connection.conn, statement);
                         if(!res)                           if(!res) 
Line 166  public: Line 196  public:
                 connection.conn=0;                  connection.conn=0;
         }          }
         void commit(void *aconnection) {          void commit(void *aconnection) {
                 Connection& connection=*static_cast<Connection*>(aconnection);                  if(isDefaultTransaction)
                   {
                 if(PGresult *res=PQexec(connection.conn, "COMMIT"))                          Connection& connection=*static_cast<Connection*>(aconnection);
                         PQclear(res);  
                 else                          if(PGresult *res=PQexec(connection.conn, "COMMIT"))
                         throwPQerror;                                  PQclear(res);
                 begin_transaction(connection);                          else
                                   throwPQerror;
                           begin_transaction(connection);
                   }
         }          }
         void rollback(void *aconnection) {          void rollback(void *aconnection) {
                 Connection& connection=*static_cast<Connection*>(aconnection);                  if(isDefaultTransaction)
                   {
                 if(PGresult *res=PQexec(connection.conn, "ROLLBACK"))                          Connection& connection=*static_cast<Connection*>(aconnection);
                         PQclear(res);  
                 else                          if(PGresult *res=PQexec(connection.conn, "ROLLBACK"))
                         throwPQerror;                                  PQclear(res);
                 begin_transaction(connection);                          else
                                   throwPQerror;
                           begin_transaction(connection);
                   }
         }          }
   
         bool ping(void *aconnection) {          bool ping(void *aconnection) {
Line 212  public: Line 248  public:
                 return result;                  return result;
                 }                  }
         void query(void *aconnection,           void query(void *aconnection, 
                 const char *astatement, unsigned long offset, unsigned long limit,                  const char *astatement, 
                   size_t placeholders_count, Placeholder* placeholders, 
                   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);                  Connection& connection=*static_cast<Connection*>(aconnection);
                   const char* cstrClientCharset=connection.cstrClientCharset;
                 SQL_Driver_services& services=*connection.services;                  SQL_Driver_services& services=*connection.services;
                 PGconn *conn=connection.conn;                  PGconn *conn=connection.conn;
   
                   if(placeholders_count>0)
                           services._throw("bind variables not supported (yet)");
   
                   // transcode from $request:charset to connect-string?client_charset
                   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(connection,                  const char *statement=preprocess_statement(connection,
                         astatement, offset, limit);                          astatement, offset, limit);
   
Line 255  public: Line 306  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);
                         char* str=(char*)services.malloc(size+1);                          char* strm=(char*)services.malloc(length+1);
                         memcpy(str, name, size+1);                          memcpy(strm, name, length+1);
                         CHECK(handlers.add_column(sql_error, str, size));                          const char* str=strm;
   
                           // transcode to $request:charset from connect-string?client_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 268  public: Line 328  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;
                                         char* str;                                          const char* str;
                                         if(PQftype(res, i)==OIDOID) {                                          if(PQftype(res, i)==OIDOID) {
                                                 // ObjectID column, read object bytes                                                  // ObjectID column, read object bytes
   
Line 280  public: Line 340  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 
                                                                 str=(char*)services.malloc(size+1);                                                                  char* strm=(char*)services.malloc(length+1);
                                                                 if(!lo_read_ex(conn, fd, str, 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");
                                                                 str[size]=0;                                                                  strm[length]=0;
                                                                   str=strm;
                                                         } else                                                          } else
                                                                 str=0;                                                                  str=0;
                                                         if(lo_close(conn, fd)<0)                                                          if(lo_close(conn, fd)<0)
Line 302  public: Line 363  public:
                                                         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) {
                                                         str=(char*)services.malloc(size+1);                                                          char* strm=(char*)services.malloc(length+1);
                                                         memcpy(str, cell, size+1);                                                          memcpy(strm, cell, length+1);
                                                           str=strm;
                                                 } else                                                  } else
                                                         str=0;                                                          str=0;
                                         }                                          }
                                         CHECK(handlers.add_row_cell(sql_error, str, size));  
                                           if(str && length) {
                                                   // transcode to $request:charset from connect-string?client_charset
                                                   if(cstrClientCharset)
                                                           services.transcode(str, length,
                                                                   str, length,
                                                                   cstrClientCharset,
                                                                   services.request_charset());
                                           }
   
                                           CHECK(handlers.add_row_cell(sql_error, str, length));
                                 }                                  }
                         }                          }
 cleanup:  cleanup:
Line 321  cleanup: Line 393  cleanup:
 private: // private funcs  private: // private funcs
   
         void begin_transaction(Connection& connection) {          void begin_transaction(Connection& connection) {
                 if(PGresult *res=PQexec(connection.conn, "BEGIN"))                  if(isDefaultTransaction)
                         PQclear(res);                  {
                 else                          if(PGresult *res=PQexec(connection.conn, "BEGIN"))
                         throwPQerror;                                  PQclear(res);
                           else
                                   throwPQerror;
                   }
         }          }
   
         const char *preprocess_statement(Connection& connection,          const char *preprocess_statement(Connection& connection,
Line 508  private: // conn client library funcs li Line 583  private: // conn client library funcs li
                 return 0;                  return 0;
         }          }
   
           bool isDefaultTransaction;
 };  };
   
 extern "C" SQL_Driver *SQL_DRIVER_CREATE() {  extern "C" SQL_Driver *SQL_DRIVER_CREATE() {
Removed from v.1.16  
changed lines
  Added in v.1.25

E-mail: