[BACK]Return to parser3mysql.C CVS log [TXT] [DIR] Up to [parser3project] / sql / mysql

Diff for /sql/mysql/parser3mysql.C between versions 1.36 and 1.57

version 1.36, 2009/04/10 12:17:02 version 1.57, 2019/09/05 15:45:13
Line 1 Line 1
 /** @file  /** @file
         Parser MySQL driver.          Parser MySQL driver.
   
         Copyright(c) 2001-2009 ArtLebedev Group (http://www.artlebedev.com)          Copyright (c) 2001-2015 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 10 Line 10
         2001-11-06 numrows on "HP-UX istok1 B.11.00 A 9000/869 448594332 two-user license"          2001-11-06 numrows on "HP-UX istok1 B.11.00 A 9000/869 448594332 two-user license"
                 3.23.42 & 4.0.0.alfa never worked, both subst & .sl version returned 0                  3.23.42 & 4.0.0.alfa never worked, both subst & .sl version returned 0
 */  */
 static const char *RCSId="$Id$";   
   
 #include "config_includes.h"  #include "config_includes.h"
   
 #include "pa_sql_driver.h"  #include "pa_sql_driver.h"
   
   volatile const char * IDENT_PARSER3MYSQL_C="$Id$" IDENT_PA_SQL_DRIVER_H;
   
 #define NO_CLIENT_LONG_LONG  #define NO_CLIENT_LONG_LONG
 #include "mysql.h"  #include "mysql.h"
 #include "ltdl.h"  #include "ltdl.h"
Line 28  static const char *RCSId="$Id$"; Line 29  static const char *RCSId="$Id$";
 #       define strcasecmp _stricmp  #       define strcasecmp _stricmp
 #endif  #endif
   
 // for mysql < 4.1   
 #if !defined(CLIENT_MULTI_RESULTS) || !defined(CLIENT_MULTI_STATEMENTS)  
 #       define OLD_MYSQL_CLIENT 1  
 #endif  
   
 #ifndef CLIENT_MULTI_RESULTS  
 #       define  CLIENT_MULTI_RESULTS (1UL << 17)  
 #endif  
   
 #ifndef CLIENT_MULTI_STATEMENTS  
 #       define  CLIENT_MULTI_STATEMENTS (1UL << 16)  
 #endif  
   
 static char *lsplit(char *string, char delim){  static char *lsplit(char *string, char delim){
         if(string) {          if(string) {
                 if(char *v=strchr(string, delim)){                  if(char *v=strchr(string, delim)){
Line 73  static void toupper_str(char *out, const Line 61  static void toupper_str(char *out, const
                 *out++=(char)toupper(*in++);                  *out++=(char)toupper(*in++);
 }  }
   
   inline static bool is_column_transcode_required(enum_field_types type) {
           switch(type) {
                   case MYSQL_TYPE_NULL:
   
   #ifdef FIELD_TYPE_NEWDECIMAL
                   case MYSQL_TYPE_NEWDECIMAL:
   #endif
                   case MYSQL_TYPE_DECIMAL:
                   case MYSQL_TYPE_FLOAT:
                   case MYSQL_TYPE_DOUBLE:
   
                   case MYSQL_TYPE_TINY:
                   case MYSQL_TYPE_SHORT:
                   case MYSQL_TYPE_LONG:
                   case MYSQL_TYPE_LONGLONG:
                   case MYSQL_TYPE_INT24:
   #ifdef FIELD_TYPE_BIT
                   case MYSQL_TYPE_BIT:
   #endif
   
                   case MYSQL_TYPE_DATE:
                   case MYSQL_TYPE_NEWDATE:
                   case MYSQL_TYPE_TIME:
                   case MYSQL_TYPE_DATETIME:
                   case MYSQL_TYPE_YEAR:
                   case MYSQL_TYPE_TIMESTAMP:
   
                   case MYSQL_TYPE_BLOB:
                   case MYSQL_TYPE_TINY_BLOB:
                   case MYSQL_TYPE_MEDIUM_BLOB:
                   case MYSQL_TYPE_LONG_BLOB:
                           return false;
                           break;
                   default:
                           return true;
           }
   }
   
   inline static char* strdup(SQL_Driver_services& services, char* str, size_t length) {
           char *strm=(char*)services.malloc_atomic(length+1);
           memcpy(strm, str, length);
           strm[length]=0;
           return strm;
   }
   
 struct Connection {  struct Connection {
         SQL_Driver_services* services;          SQL_Driver_services* services;
   
Line 90  public: Line 123  public:
   
         MySQL_Driver() : SQL_Driver() {}          MySQL_Driver() : SQL_Driver() {}
   
 #ifndef FREEBSD4  
         ~MySQL_Driver() {  
                 if(mysql_server_end)  
                         mysql_server_end();  
         }  
 #endif  
   
         /// get api version          /// get api version
         int api_version() { return SQL_DRIVER_API_VERSION; }          int api_version() { return SQL_DRIVER_API_VERSION; }
   
Line 109  public: Line 135  public:
         /**     connect          /**     connect
                 @param url                  @param url
                         format: @b user:pass@host[:port]|[/unix/socket]/database?                          format: @b user:pass@host[:port]|[/unix/socket]/database?
                                 charset=value&  // transcode by server with command 'SET CHARACTER SET value'                                  charset=value&  // transcode by server with command 'SET NAMES value'
                                 ClientCharset=charset&  // transcode by parser                                  ClientCharset=charset&  // transcode by parser
                                 timeout=3&                                  timeout=3&
                                 compress=0&                                  compress=0&
                                 named_pipe=1&                                  named_pipe=1&
                                 autocommit=1&                                  autocommit=1&
                                 multi_statements=0      // allows more then one statement in one query                                  multi_statements=0      // allows more then one statement in one query
                                 old_client=1            // simulates 3.xx client. not compatible with multi_statements option                                  4.1+ accept not 'cp1251_koi8' but 'cp1251', 'utf8' and much more
                         3.x, 4.0   
                                 only option for charset is cp1251_koi8.  
                         4.1+ accept not 'cp1251_koi8' but 'cp1251', 'utf8' and much more  
                                 it is usable for transcoding using sql server                                  it is usable for transcoding using sql server
         */          */
         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 *s=rsplit(user, '@');                  char *s=rsplit(user, '@');
                 char *host=0;                  char *host=0;
Line 140  public: Line 159  public:
                 char *db=lsplit(s, '/');                  char *db=lsplit(s, '/');
                 char *pwd=lsplit(user, ':');                  char *pwd=lsplit(user, ':');
                 char *error_pos=0;                  char *error_pos=0;
                 char *port_cstr=lsplit(host, ':');  
                 int port=port_cstr?strtol(port_cstr, &error_pos, 0):0;  
                 char *options=lsplit(db, '?');                  char *options=lsplit(db, '?');
   
                 char *charset=0;                  char *charset=0;
   
 #ifdef OLD_MYSQL_CLIENT  
                 int client_flag=0;  
 #else  
                 int client_flag=CLIENT_MULTI_RESULTS;                  int client_flag=CLIENT_MULTI_RESULTS;
 #endif  
   
                 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.handle=mysql_init(NULL);                  connection.handle=mysql_init(NULL);
                 connection.client_charset=0;                      connection.client_charset=0;
                 connection.autocommit=true;                  connection.autocommit=true;
   
                 while(options){                  while(1){
                         if(char *key=lsplit(&options, '&')){                          char *next_host=lsplit(host, ',');
                                 if(*key){                          char *host_options=next_host && options ? strdup(services, options, strlen(options)) : options;
   
                           char *port_cstr=lsplit(host, ':');
                           int port=port_cstr?strtol(port_cstr, &error_pos, 0):0;
   
                           while(host_options){
                                   char *key=lsplit(&host_options, '&');
                                   if(key && *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));
Line 180  public: Line 198  public:
                                                         if(atoi(value))                                                          if(atoi(value))
                                                                 if(mysql_options(connection.handle, MYSQL_OPT_NAMED_PIPE, 0)!=0)                                                                  if(mysql_options(connection.handle, MYSQL_OPT_NAMED_PIPE, 0)!=0)
                                                                         services._throw(mysql_error(connection.handle));                                                                          services._throw(mysql_error(connection.handle));
                                                   } else if(strcasecmp(key, "local_infile")==0){
                                                           if(atoi(value))
                                                                   if(mysql_options(connection.handle, MYSQL_OPT_LOCAL_INFILE, 0)!=0)
                                                                           services._throw(mysql_error(connection.handle));
                                                 } else if(strcasecmp(key, "autocommit")==0){                                                  } else if(strcasecmp(key, "autocommit")==0){
                                                         if(atoi(value)==0)                                                          if(atoi(value)==0)
                                                                 connection.autocommit=false;                                                                  connection.autocommit=false;
                                                 } else if(strcasecmp(key, "multi_statements")==0){                                                  } else if(strcasecmp(key, "multi_statements")==0){
 #ifdef OLD_MYSQL_CLIENT  
                                                         services._throw("driver was built with old mysql includes so multi_statements option can't be used");  
 #else  
                                                         if(!(client_flag==CLIENT_MULTI_RESULTS || client_flag==CLIENT_MULTI_STATEMENTS))  
                                                                 services._throw("you can't specify together options old_client and multi_statements");  
                                                         if(atoi(value)!=0)                                                          if(atoi(value)!=0)
                                                                 client_flag=CLIENT_MULTI_STATEMENTS;                                                                  client_flag=CLIENT_MULTI_STATEMENTS;
 #endif                                                  } else if(strcasecmp(key, "config_file")==0){
                                                 } else if(strcasecmp(key, "old_client")==0){                                                          if(mysql_options(connection.handle, MYSQL_READ_DEFAULT_FILE, value)!=0)
 #ifdef OLD_MYSQL_CLIENT                                                                          services._throw(mysql_error(connection.handle));
                                                         services._throw("driver was built with old mysql includes so old_client option can't be used");                                                  } else if(strcasecmp(key, "config_group")==0){
 #else                                                          if(mysql_options(connection.handle, MYSQL_READ_DEFAULT_GROUP, value)!=0)
                                                         if(!(client_flag==CLIENT_MULTI_RESULTS || client_flag==0))                                                                          services._throw(mysql_error(connection.handle));
                                                                 services._throw("you can't specify together options old_client and multi_statements");  
                                                         if(atoi(value)!=0)  
                                                                 client_flag=0;  
 #endif  
                                                 } else                                                  } else
                                                         services._throw("unknown connect option" /*key*/);                                                          services._throw("unknown connect option" /*key*/);
                                         } else                                           } else
                                                 services._throw("connect option without =value" /*key*/);                                                  services._throw("connect option without =value" /*key*/);
                                 }                                  }
                         }                          }
                 }  
   
                 if(!mysql_real_connect(                          if(mysql_real_connect(connection.handle, host, user, pwd, db, port, unix_socket, client_flag))
                                         connection.handle,                                   break;
                                         host, user, pwd, db,  
                                         port?port:MYSQL_PORT,                          if(!next_host)
                                         unix_socket,                                  services._throw(mysql_error(connection.handle));
                                         client_flag  
                                 )                          host=next_host;
                 ){  
                         services._throw(mysql_error(connection.handle));  
                 }                  }
   
                 if(charset){                  if(charset){
                         char statement[MAX_STRING]="SET CHARACTER SET ";                          char statement[MAX_STRING+1]="SET NAMES ";
                         strncat(statement, charset, MAX_STRING);                          strncat(statement, charset, MAX_STRING);
                         _exec(connection, statement);                          _exec(connection, statement);
                 }                  }
Line 253  public: Line 263  public:
                 return mysql_ping(connection.handle)==0;                  return mysql_ping(connection.handle)==0;
         }          }
   
         const char* quote(void *aconnection, const char *from, unsigned int length) {          // charset here is services.request_charset(), not connection.client_charset
           // thus we can't use the sql server quoting support
           const char* quote(void *aconnection, const char *str, unsigned int length) {
                   const char* from;
                   const char* from_end=str+length;
   
                   size_t quoted=0;
   
                   for(from=str; from<from_end; from++){
                           switch (*from) {
                           case 0:
                           case '\n':
                           case '\r':
                           case '\032':
                           case '\\':
                           case '\'':
                           case '"':
                                   quoted++;
                           }
                   }
   
                   if(!quoted)
                           return str;
   
                 Connection& connection=*static_cast<Connection*>(aconnection);                  Connection& connection=*static_cast<Connection*>(aconnection);
                 /*                  char *result=(char*)connection.services->malloc_atomic(length + quoted + 1);
                         3.23.22b                  char *to = result;
                         You must allocate the to buffer to be at least length*2+1 bytes long.   
                         (In the worse case, each character may need to be encoded as using two bytes,                   for(from=str; from<from_end; from++){
                         and you need room for the terminating null byte.)                          char escape;
                 */                          switch (*from) {
                 char *result=(char*)connection.services->malloc_atomic(length*2+1);                          case 0: 
                 mysql_escape_string(result, from, length);                                  escape= '0'; 
                                   break;
                           case '\n': 
                                   escape= 'n'; 
                                   break;
                           case '\r': 
                                   escape= 'r'; 
                                   break;
                           case '\032': 
                                   escape= 'Z'; 
                                   break;
                           case '\\': 
                           case '\'': 
                           case '"': 
                                   escape= *from; 
                                   break;
                           default:
                                   *to++=*from;
                                   continue;
                           }
                           *to++= '\\';
                           *to++= escape;
                   }
                   
                   *to=0;
                 return result;                  return result;
         }          }
   
Line 281  public: Line 338  public:
   
                 bool transcode_needed=_transcode_required(connection);                  bool transcode_needed=_transcode_required(connection);
   
                 // transcode query from $request:charset to ?ClientCharset                  size_t statement_size=0;
                 if(transcode_needed){  
                         size_t length=strlen(astatement);                  if(transcode_needed) {
                         services.transcode(astatement, length,                          statement_size=strlen(astatement);
                                 astatement, length,                          // transcode query from $request:charset to ?ClientCharset
                                 services.request_charset(),                          services.transcode(astatement, statement_size, astatement, statement_size, services.request_charset(), connection.client_charset);
                                 connection.client_charset);  
                 }                  }
   
                 const char *statement;                  const char *statement;
                 if(offset || limit!=SQL_NO_LIMIT){                  if(offset || limit!=SQL_NO_LIMIT) {
                         size_t statement_size=strlen(astatement);                          if(!statement_size)
                                   statement_size=strlen(astatement);
                         char *statement_limited=(char *)services.malloc_atomic(                          char *statement_limited=(char *)services.malloc_atomic(
                                 statement_size+MAX_NUMBER*2+8/* LIMIT #,#*/+1);                                  statement_size+MAX_NUMBER*2+8/* LIMIT #,#*/+1);
                         char *cur=statement_limited;                          char *cur=statement_limited;
                         memcpy(cur, astatement, statement_size); cur+=statement_size;                          memcpy(cur, astatement, statement_size); cur+=statement_size;
                         cur+=sprintf(cur, " LIMIT ");                          cur+=sprintf(cur, " LIMIT ");
                         if(offset)                          if(offset)
                                 cur+=snprintf(cur, MAX_NUMBER+1, "%u,", offset);                                  cur+=snprintf(cur, MAX_NUMBER, "%lu,", offset);
                         if(limit!=SQL_NO_LIMIT)                          if(limit!=SQL_NO_LIMIT)
                                 cur+=snprintf(cur, MAX_NUMBER, "%u", limit);                                  cur+=snprintf(cur, MAX_NUMBER, "%lu", limit);
                         statement=statement_limited;                          statement=statement_limited;
                 } else                  } else
                         statement=astatement;                          statement=astatement;
   
                 if(mysql_query(connection.handle, statement))                   if(mysql_query(connection.handle, statement)) 
                         _throw(connection, mysql_error(connection.handle));                          _throw(connection, mysql_error(connection.handle));
                 if(!(res=mysql_store_result(connection.handle)) && mysql_field_count(connection.handle))                   if(!(res=mysql_store_result(connection.handle)) && mysql_field_count(connection.handle))
                         _throw(connection, mysql_error(connection.handle));                          _throw(connection, mysql_error(connection.handle));
                 if(!res) // empty result: insert|delete|update|...                  if(!res) // empty result: insert|delete|update|...
                         return;                          return;
                   
                 int column_count=mysql_num_fields(res);                  size_t column_count=mysql_num_fields(res);
                 if(!column_count) // old client                  if(!column_count) // old client
                         column_count=mysql_field_count(connection.handle);                          column_count=mysql_field_count(connection.handle);
   
Line 321  public: Line 378  public:
                         mysql_free_result(res);                          mysql_free_result(res);
                         services._throw("result contains no columns");                          services._throw("result contains no columns");
                 }                  }
                   
                 bool failed=false;                  bool failed=false;
                 SQL_Error sql_error;                  SQL_Error sql_error;
 #define CHECK(afailed) \  
                 if(afailed) { \  
                         failed=true; \  
                         goto cleanup; \  
                 }  
   
                 for(int i=0; i<column_count; i++){  #define CHECK(afailed)    \
                         if(MYSQL_FIELD *field=mysql_fetch_field(res)){                  if(afailed) {     \
                                 size_t length=strlen(field->name);                          failed=true;  \
                                 char* strm=(char*)services.malloc_atomic(length+1);                          goto cleanup; \
                                 memcpy(strm, field->name, length+1);  
                                 const char* str=strm;  
   
                                 // transcode column name from ?ClientCharset to $request:charset   
                                 if(transcode_needed){  
                                         services.transcode(str, length,  
                                                 str, length,  
                                                 connection.client_charset,  
                                                 services.request_charset());  
                                 }  
                                   
                                 CHECK(handlers.add_column(sql_error, str, length));  
                         } else {  
                                 // seen some broken client,   
                                 // which reported "44" for column count of response to "select 2+2"  
                                 column_count=i;  
                                 break;  
                         }  
                 }                  }
   
                 CHECK(handlers.before_rows(sql_error));  #define DO_FETCH_FIELDS(transcode_column_name) {                                                                   \
                                           for(size_t i=0; i<column_count; i++) {                                                     \
                 while(MYSQL_ROW mysql_row=mysql_fetch_row(res)){                                  if(MYSQL_FIELD *field = mysql_fetch_field(res)){                                   \
                         CHECK(handlers.add_row(sql_error));                                          size_t length=field->name_length;                                          \
                         unsigned long *lengths=mysql_fetch_lengths(res);                                          const char* str=strdup(services, field->name, length);                     \
                         for(int i=0; i<column_count; i++){                                          transcode_column_name                                                      \
                                 size_t length=(size_t)lengths[i];                                          CHECK(handlers.add_column(sql_error, str, length));                        \
                                 const char* str;                                  } else {                                                                           \
                                 if(length){                                          /* seen broken client, that reported "44" column count for "select 2+2" */ \
                                         char *strm=(char*)services.malloc_atomic(length+1);                                          column_count=i;                                                            \
                                         memcpy(strm, mysql_row[i], length);                                          break;                                                                     \
                                         strm[length]=0;                                  }                                                                                  \
                                         str=strm;                          }                                                                                          \
                   }
                                         // transcode cell value from ?ClientCharset to $request:charset  
                                         if(transcode_needed)  #define DO_FETCH_ROWS(transcode_cell_value) {                                                                      \
                                                 services.transcode(str, length,                          while(MYSQL_ROW mysql_row=mysql_fetch_row(res)) {                                          \
                                                         str, length,                                  CHECK(handlers.add_row(sql_error));                                                \
                                                         connection.client_charset,                                  unsigned long *lengths=mysql_fetch_lengths(res);                                   \
                                                         services.request_charset());                                  for(size_t i=0; i<column_count; i++) {                                             \
                                 } else                                          const char* str=0;                                                         \
                                         str=0;                                          size_t length=lengths[i];                                                  \
                                 CHECK(handlers.add_row_cell(sql_error, str, length));                                          if(length) {                                                               \
                         }                                                  str=strdup(services, mysql_row[i], length);                        \
                                                   transcode_cell_value                                               \
                                           }                                                                          \
                                           CHECK(handlers.add_row_cell(sql_error, str, length));                      \
                                   }                                                                                  \
                           }                                                                                          \
                   }
   
                   if(transcode_needed) {
                           bool transcode_column[column_count];
                           DO_FETCH_FIELDS(
                                   transcode_column[i] = is_column_transcode_required(field->type);
                                   // transcode column's name from ?ClientCharset to $request:charset
                                   services.transcode(str, length, str, length, connection.client_charset, services.request_charset());
                           )
                           CHECK(handlers.before_rows(sql_error));
                           DO_FETCH_ROWS(
                                   // transcode cell's value from ?ClientCharset to $request:charset
                                   if(transcode_column[i])
                                           services.transcode(str, length, str, length, connection.client_charset, services.request_charset());
                           )
                   } else {
                           // without transcoding
                           DO_FETCH_FIELDS()
                           CHECK(handlers.before_rows(sql_error));
                           DO_FETCH_ROWS()
                 }                  }
 cleanup:  cleanup:
                 mysql_free_result(res);                  mysql_free_result(res);
Line 395  private: Line 454  private:
         void _throw(Connection& connection, const char* aerr_msg) {          void _throw(Connection& connection, const char* aerr_msg) {
                 size_t length=strlen(aerr_msg);                  size_t length=strlen(aerr_msg);
                 if(length && _transcode_required(connection)) {                  if(length && _transcode_required(connection)) {
                         connection.services->transcode(aerr_msg, length,                          connection.services->transcode(aerr_msg, length, aerr_msg, length, connection.client_charset, connection.services->request_charset());
                                 aerr_msg, length,  
                                 connection.client_charset,  
                                 connection.services->request_charset());  
                 }                  }
                 connection.services->_throw(aerr_msg);                  connection.services->_throw(aerr_msg);
         }          }
Line 409  private: Line 465  private:
   
 private: // mysql client library funcs  private: // mysql client library funcs
   
         typedef MYSQL*  (STDCALL *t_mysql_init)(MYSQL *);       t_mysql_init mysql_init;          typedef MYSQL* (STDCALL *t_mysql_init)(MYSQL *); t_mysql_init mysql_init;
           
         typedef void    (STDCALL *t_mysql_server_end)();        t_mysql_server_end mysql_server_end;          typedef void (STDCALL *t_mysql_server_end)(); t_mysql_server_end mysql_server_end;
   
           typedef int (STDCALL *t_mysql_options)(MYSQL *mysql, enum mysql_option option, const char *arg); t_mysql_options mysql_options;
   
         typedef int             (STDCALL *t_mysql_options)(MYSQL *mysql, enum mysql_option option, const char *arg); t_mysql_options mysql_options;  
           
         typedef MYSQL_RES* (STDCALL *t_mysql_store_result)(MYSQL *); t_mysql_store_result mysql_store_result;          typedef MYSQL_RES* (STDCALL *t_mysql_store_result)(MYSQL *); t_mysql_store_result mysql_store_result;
           
         typedef int             (STDCALL *t_mysql_query)(MYSQL *, const char *q); t_mysql_query mysql_query;          typedef int (STDCALL *t_mysql_query)(MYSQL *, const char *q); t_mysql_query mysql_query;
           
         typedef char*   (STDCALL *t_mysql_error)(MYSQL *); t_mysql_error mysql_error;          typedef char* (STDCALL *t_mysql_error)(MYSQL *); t_mysql_error mysql_error;
         static char* STDCALL subst_mysql_error(MYSQL *mysql) { return (mysql)->net.last_error; }          static char* STDCALL subst_mysql_error(MYSQL *mysql) { return (mysql)->net.last_error; }
   
         typedef MYSQL*  (STDCALL *t_mysql_real_connect)(MYSQL *, const char *host,          typedef MYSQL* (STDCALL *t_mysql_real_connect)(MYSQL *, const char *host, const char *user, const char *passwd, const char *db, unsigned int port, const char *unix_socket, unsigned int clientflag); t_mysql_real_connect mysql_real_connect;
                                                 const char *user,  
                                                 const char *passwd,          typedef void (STDCALL *t_mysql_close)(MYSQL *); t_mysql_close mysql_close;
                                                 const char *db,  
                                                 unsigned int port,          typedef int (STDCALL *t_mysql_ping)(MYSQL *); t_mysql_ping mysql_ping;
                                                 const char *unix_socket,  
                                                 unsigned int clientflag); t_mysql_real_connect mysql_real_connect;          typedef unsigned long (STDCALL *t_mysql_escape_string)(char *to,const char *from, unsigned long from_length); t_mysql_escape_string mysql_escape_string;
   
         typedef void    (STDCALL *t_mysql_close)(MYSQL *); t_mysql_close mysql_close;          typedef void (STDCALL *t_mysql_free_result)(MYSQL_RES *result); t_mysql_free_result mysql_free_result;
           
         typedef int             (STDCALL *t_mysql_ping)(MYSQL *); t_mysql_ping mysql_ping;  
           
         typedef unsigned long   (STDCALL *t_mysql_escape_string)(char *to,const char *from,  
                                                 unsigned long from_length); t_mysql_escape_string mysql_escape_string;  
           
         typedef void    (STDCALL *t_mysql_free_result)(MYSQL_RES *result); t_mysql_free_result mysql_free_result;  
           
         typedef unsigned long* (STDCALL *t_mysql_fetch_lengths)(MYSQL_RES *result); t_mysql_fetch_lengths mysql_fetch_lengths;          typedef unsigned long* (STDCALL *t_mysql_fetch_lengths)(MYSQL_RES *result); t_mysql_fetch_lengths mysql_fetch_lengths;
           
         typedef MYSQL_ROW       (STDCALL *t_mysql_fetch_row)(MYSQL_RES *result); t_mysql_fetch_row mysql_fetch_row;  
           
         typedef MYSQL_FIELD*    (STDCALL *t_mysql_fetch_field)(MYSQL_RES *result); t_mysql_fetch_field mysql_fetch_field;  
           
         typedef unsigned int    (STDCALL *t_mysql_num_fields)(MYSQL_RES *); t_mysql_num_fields mysql_num_fields;  
         typedef unsigned int    (STDCALL *t_mysql_field_count)(MYSQL *); t_mysql_field_count mysql_field_count;  
   
         static unsigned int     STDCALL subst_mysql_num_fields(MYSQL_RES *res) { return res->field_count; }          typedef MYSQL_ROW (STDCALL *t_mysql_fetch_row)(MYSQL_RES *result); t_mysql_fetch_row mysql_fetch_row;
         static unsigned int     STDCALL subst_mysql_field_count(MYSQL *mysql) { return mysql->field_count; }          typedef MYSQL_FIELD* (STDCALL *t_mysql_fetch_field)(MYSQL_RES *result); t_mysql_fetch_field mysql_fetch_field;
   
           typedef unsigned int (STDCALL *t_mysql_num_fields)(MYSQL_RES *); t_mysql_num_fields mysql_num_fields;
           typedef unsigned int (STDCALL *t_mysql_field_count)(MYSQL *); t_mysql_field_count mysql_field_count;
   
           static unsigned int STDCALL subst_mysql_num_fields(MYSQL_RES *res) { return res->field_count; }
           static unsigned int STDCALL subst_mysql_field_count(MYSQL *mysql) { return mysql->field_count; }
   
 private: // mysql client library funcs linking  private: // mysql client library funcs linking
   
         const char *dlink(const char *dlopen_file_spec) {          const char *dlink(const char *dlopen_file_spec) {
                 if(lt_dlinit())                  if(lt_dlinit()){
                         return lt_dlerror();                          if(const char* result=lt_dlerror())
                                   return result;
                           return "can not prepare to dynamic loading";
                   }
   
                 lt_dlhandle handle=lt_dlopen(dlopen_file_spec);                  lt_dlhandle handle=lt_dlopen(dlopen_file_spec);
   
Removed from v.1.36  
changed lines
  Added in v.1.57

E-mail: