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

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

version 1.10, 2002/12/15 08:52:10 version 1.16, 2004/01/26 15:22:26
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)
   
Line 58  static char *lsplit(char **string_ref, c Line 58  static char *lsplit(char **string_ref, c
     return result;      return result;
 }  }
   
   struct Connection {
           SQL_Driver_services* services;
   
           PGconn *conn;
   };
   
 /**  /**
         PgSQL server driver          PgSQL server driver
 */  */
Line 75  public: Line 81  public:
                         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 used_only_in_connect_url
Line 89  public: Line 95  public:
         void connect(          void connect(
                 char *used_only_in_connect_url,                   char *used_only_in_connect_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=used_only_in_connect_url;
                 char *host=lsplit(user, '@');                  char *host=lsplit(user, '@');
Line 99  public: Line 105  public:
   
                 char *options=lsplit(db, '?');                  char *options=lsplit(db, '?');
   
                 PGconn *conn=PQsetdbLogin(                  Connection& connection=*(Connection  *)::calloc(sizeof(Connection), 1);
                   *connection_ref=&connection;
                   connection.services=&services;
                   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)                    if(PQstatus(connection.conn)!=CONNECTION_OK)  
                         throwPQerror;                          throwPQerror;
   
                 char *charset=0;                  char *charset=0;
Line 131  public: Line 140  public:
                         char statement[MAX_STRING]="set CLIENT_ENCODING="; // win                          char statement[MAX_STRING]="set CLIENT_ENCODING="; // win
                         strncat(statement, charset, MAX_STRING);                          strncat(statement, charset, MAX_STRING);
                                                   
                         PGresult *res=PQexec(conn, statement);                          PGresult *res=PQexec(connection.conn, statement);
                         if(!res)                           if(!res) 
                                 throwPQerror;                                  throwPQerror;
                         PQclear(res); // throw out the result [don't need but must call]                          PQclear(res); // throw out the result [don't need but must call]
Line 142  public: Line 151  public:
                         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, charset, MAX_STRING);
                                                   
                         PGresult *res=PQexec(conn, statement);                          PGresult *res=PQexec(connection.conn, statement);
                         if(!res)                           if(!res) 
                                 throwPQerror;                                  throwPQerror;
                         PQclear(res); // throw out the result [don't need but must call]                          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) {          void disconnect(void *aconnection) {
             PQfinish((PGconn *)connection);                  Connection& connection=*static_cast<Connection*>(aconnection);
   
               PQfinish(connection.conn);
                   connection.conn=0;
         }          }
         void commit(SQL_Driver_services& services, void *connection) {          void commit(void *aconnection) {
                 PGconn *conn=(PGconn *)connection;                  Connection& connection=*static_cast<Connection*>(aconnection);
                 if(PGresult *res=PQexec(conn, "COMMIT"))  
                   if(PGresult *res=PQexec(connection.conn, "COMMIT"))
                         PQclear(res);                          PQclear(res);
                 else                  else
                         throwPQerror;                          throwPQerror;
                 begin_transaction(services, conn);                  begin_transaction(connection);
         }          }
         void rollback(SQL_Driver_services& services, void *connection) {          void rollback(void *aconnection) {
                 PGconn *conn=(PGconn *)connection;                  Connection& connection=*static_cast<Connection*>(aconnection);
                 if(PGresult *res=PQexec(conn, "ROLLBACK"))  
                   if(PGresult *res=PQexec(connection.conn, "ROLLBACK"))
                         PQclear(res);                          PQclear(res);
                 else                  else
                         throwPQerror;                          throwPQerror;
                 begin_transaction(services, conn);                  begin_transaction(connection);
         }          }
   
         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) {                  char *to=result;
                                 case '\'': // "'" -> "''"                  while(length--) {
                                         *to++='\''; result++;                          switch(*from) {
                                         break;                          case '\'': // "'" -> "''"
                                 case '\\': // "\" -> "\\"                                  *to++='\'';
                                         *to++='\\'; result++;                                  break;
                                         break;                          case '\\': // "\" -> "\\"
                                 }                                  *to++='\\';
                                 *to++=*from++;                                  break;
                         }                          }
                         return result;                          *to++=*from++;
                 } else // estimate mode                  }
                         return length*2;                  *to=0;
         }                  return result;
         void query(                  }
                 SQL_Driver_services& services, void *connection,           void query(void *aconnection, 
                 const char *astatement, unsigned long offset, unsigned long limit,                  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);
                   SQL_Driver_services& services=*connection.services;
                   PGconn *conn=connection.conn;
   
                 PGconn *conn=(PGconn *)connection;                  const char *statement=preprocess_statement(connection,
   
                 const char *statement=preprocess_statement(services, conn,  
                         astatement, offset, limit);                          astatement, offset, limit);
   
                 PGresult *res=PQexec(conn, statement);                  PGresult *res=PQexec(conn, statement);
Line 240  public: Line 256  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 size=strlen(name);
                         void *ptr=services.malloc(size);                          char* str=(char*)services.malloc(size+1);
                         memcpy(ptr, name, size);                          memcpy(str, name, size+1);
                         CHECK(handlers.add_column(sql_error, ptr, size));                          CHECK(handlers.add_column(sql_error, str, size));
                 }                  }
   
                 CHECK(handlers.before_rows(sql_error));                  CHECK(handlers.before_rows(sql_error));
Line 253  public: Line 269  public:
                                 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 size;
                                         void *ptr;                                          char* str;
                                         if(PQftype(res, i)==OIDOID) {                                          if(PQftype(res, i)==OIDOID) {
                                                 // ObjectID column, read object bytes                                                  // ObjectID column, read object bytes
   
Line 274  public: Line 290  public:
                                                         size=(size_t)size_tell;                                                          size=(size_t)size_tell;
                                                         if(size) {                                                          if(size) {
                                                                 // read                                                                   // read 
                                                                 ptr=services.malloc(size);                                                                  str=(char*)services.malloc(size+1);
                                                                 if(!lo_read_ex(conn, fd, (const char *)ptr, size_tell))                                                                  if(!lo_read_ex(conn, fd, str, 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;
                                                         } else                                                          } else
                                                                 ptr=0;                                                                  str=0;
                                                         if(lo_close(conn, fd)<0)                                                          if(lo_close(conn, fd)<0)
                                                                 PQclear_throwPQerror;                                                                  PQclear_throwPQerror;
                                                 } else                                                  } else
Line 287  public: Line 304  public:
                                                 // normal column, read it normally                                                  // normal column, read it normally
                                                 size=(size_t)PQgetlength(res, r, i);                                                  size=(size_t)PQgetlength(res, r, i);
                                                 if(size) {                                                  if(size) {
                                                         ptr=services.malloc(size);                                                          str=(char*)services.malloc(size+1);
                                                         memcpy(ptr, cell, size);                                                          memcpy(str, cell, size+1);
                                                 } else                                                  } else
                                                         ptr=0;                                                          str=0;
                                         }                                          }
                                         CHECK(handlers.add_row_cell(sql_error, ptr, size));                                          CHECK(handlers.add_row_cell(sql_error, str, size));
                                 }                                  }
                         }                          }
 cleanup:  cleanup:
Line 303  cleanup: Line 320  cleanup:
   
 private: // private funcs  private: // private funcs
   
         void begin_transaction(SQL_Driver_services& services, PGconn *conn) {          void begin_transaction(Connection& connection) {
                 if(PGresult *res=PQexec(conn, "BEGIN"))                  if(PGresult *res=PQexec(connection.conn, "BEGIN"))
                         PQclear(res);                          PQclear(res);
                 else                  else
                         throwPQerror;                          throwPQerror;
         }          }
   
         const char *preprocess_statement(SQL_Driver_services& services, PGconn *conn,          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 357  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 365  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 379  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 397  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 448  private: // conn client library funcs Line 473  private: // conn client library funcs
 private: // conn client library funcs linking  private: // conn client library funcs linking
   
         const char *dlink(const char *dlopen_file_spec) {          const char *dlink(const char *dlopen_file_spec) {
                   if(lt_dlinit())
                           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";
Removed from v.1.10  
changed lines
  Added in v.1.16

E-mail: