home *** CD-ROM | disk | FTP | other *** search
/ Chip 2001 January / Chip_2001-01_cd1.bin / tema / mysql / mysql-3.23.28g-win-source.exe / sql / sql_class.h < prev    next >
C/C++ Source or Header  |  2000-11-16  |  14KB  |  492 lines
  1. /* Copyright (C) 2000 MySQL AB & MySQL Finland AB & TCX DataKonsult AB
  2.    
  3.    This program is free software; you can redistribute it and/or modify
  4.    it under the terms of the GNU General Public License as published by
  5.    the Free Software Foundation; either version 2 of the License, or
  6.    (at your option) any later version.
  7.    
  8.    This program is distributed in the hope that it will be useful,
  9.    but WITHOUT ANY WARRANTY; without even the implied warranty of
  10.    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  11.    GNU General Public License for more details.
  12.    
  13.    You should have received a copy of the GNU General Public License
  14.    along with this program; if not, write to the Free Software
  15.    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA */
  16.  
  17.  
  18. /* Classes in mysql */
  19.  
  20. #ifdef __GNUC__
  21. #pragma interface            /* gcc class implementation */
  22. #endif
  23.  
  24.  
  25. class Query_log_event;
  26. class Load_log_event;
  27.  
  28.  
  29. enum enum_duplicates { DUP_ERROR, DUP_REPLACE, DUP_IGNORE };
  30. enum enum_log_type { LOG_CLOSED, LOG_NORMAL, LOG_NEW, LOG_BIN };
  31.  
  32. // log info errors 
  33. #define LOG_INFO_EOF -1
  34. #define LOG_INFO_IO  -2
  35. #define LOG_INFO_INVALID -3
  36. #define LOG_INFO_SEEK -4
  37. #define LOG_INFO_PURGE_NO_ROTATE -5
  38. #define LOG_INFO_MEM -6
  39. #define LOG_INFO_FATAL -7
  40. #define LOG_INFO_IN_USE -8
  41.  
  42. typedef struct st_log_info
  43. {
  44.   char log_file_name[FN_REFLEN];
  45.   my_off_t index_file_offset;
  46.   my_off_t pos;
  47.   bool fatal; // if the purge happens to give us a negative offset
  48.   pthread_mutex_t lock;
  49.   st_log_info():fatal(0) { pthread_mutex_init(&lock, NULL);}
  50.   ~st_log_info() { pthread_mutex_destroy(&lock);}
  51. } LOG_INFO;
  52.  
  53.  
  54. class MYSQL_LOG {
  55.  private:
  56.   pthread_mutex_t LOCK_log, LOCK_index;
  57.   time_t last_time,query_start;
  58.   IO_CACHE log_file;
  59.   File index_file;
  60.   char *name;
  61.   volatile enum_log_type log_type;
  62.   char time_buff[20],db[NAME_LEN+1];
  63.   char log_file_name[FN_REFLEN],index_file_name[FN_REFLEN];
  64.   bool write_error,inited,opened;
  65.   bool no_rotate; // for binlog - if log name can never change
  66.   // we should not try to rotate it or write any rotation events
  67.   // the user should use FLUSH MASTER instead of FLUSH LOGS for
  68.   // purging
  69.  
  70. public:
  71.   MYSQL_LOG();
  72.   ~MYSQL_LOG();
  73.   pthread_mutex_t* get_log_lock() { return &LOCK_log; }
  74.   void set_index_file_name(const char* index_file_name = 0);
  75.   void open(const char *log_name,enum_log_type log_type,
  76.         const char *new_name=0);
  77.   void new_file(void);
  78.   void write(THD *thd, enum enum_server_command command,const char *format,...);
  79.   void write(THD *thd, const char *query, uint query_length,
  80.          time_t query_start=0);
  81.   void write(Query_log_event* event_info); // binary log write
  82.   void write(Load_log_event* event_info);
  83.  
  84.   int generate_new_name(char *new_name,const char *old_name);
  85.   void make_log_name(char* buf, const char* log_ident);
  86.   bool is_active(const char* log_file_name);
  87.   int purge_logs(THD* thd, const char* to_log);
  88.   void close(bool exiting = 0); // if we are exiting, we also want to close the
  89.   // index file
  90.  
  91.   // iterating through the log index file
  92.   int find_first_log(LOG_INFO* linfo, const char* log_name);
  93.   int find_next_log(LOG_INFO* linfo);
  94.   int get_current_log(LOG_INFO* linfo);
  95.  
  96.   inline bool is_open() { return log_type != LOG_CLOSED; }
  97.   char* get_index_fname() { return index_file_name;}
  98.   char* get_log_fname() { return log_file_name; }
  99.   void lock_index() { pthread_mutex_lock(&LOCK_index);}
  100.   void unlock_index() { pthread_mutex_unlock(&LOCK_index);}
  101.   File get_index_file() { return index_file;}
  102. };
  103.  
  104. /* character conversion tables */
  105.  
  106. class CONVERT
  107. {
  108.   const uchar *from_map,*to_map;
  109.   void convert_array(const uchar *mapping,uchar *buff,uint length);
  110. public:
  111.   const char *name;
  112.   CONVERT(const char *name_par,uchar *from_par,uchar *to_par)
  113.     :from_map(from_par),to_map(to_par),name(name_par) {}
  114.   friend CONVERT *get_convert_set(const char *name_ptr);
  115.   inline void convert(char *a,uint length)
  116.   {
  117.     convert_array(from_map, (uchar*) a,length);
  118.   }
  119.   bool store(String *, const char *,uint);
  120. };
  121.  
  122. typedef struct st_copy_info {
  123.   ha_rows records;
  124.   ha_rows deleted;
  125.   ha_rows copied;
  126.   ha_rows error;
  127.   enum enum_duplicates handle_duplicates;
  128.   int escape_char;
  129. } COPY_INFO;
  130.  
  131.  
  132. class key_part_spec :public Sql_alloc {
  133. public:
  134.   const char *field_name;
  135.   uint length;
  136.   key_part_spec(const char *name,uint len=0) :field_name(name), length(len) {}
  137. };
  138.  
  139.  
  140. class Alter_drop :public Sql_alloc {
  141. public:
  142.   enum drop_type {KEY, COLUMN };
  143.   const char *name;
  144.   enum drop_type type;
  145.   Alter_drop(enum drop_type par_type,const char *par_name)
  146.     :name(par_name), type(par_type) {}
  147. };
  148.  
  149.  
  150. class Alter_column :public Sql_alloc {
  151. public:
  152.   const char *name;
  153.   Item *def;
  154.   Alter_column(const char *par_name,Item *literal)
  155.     :name(par_name), def(literal) {}
  156. };
  157.  
  158.  
  159. class Key :public Sql_alloc {
  160. public:
  161.   enum Keytype { PRIMARY, UNIQUE, MULTIPLE, FULLTEXT };
  162.   enum Keytype type;
  163.   List<key_part_spec> columns;
  164.   const char *Name;
  165.  
  166.   Key(enum Keytype type_par,const char *name_arg,List<key_part_spec> &cols)
  167.     :type(type_par), columns(cols),Name(name_arg) {}
  168.   ~Key() {}
  169.   const char *name() { return Name; }
  170. };
  171.  
  172.  
  173. typedef struct st_mysql_lock
  174. {
  175.   TABLE **table;
  176.   uint table_count,lock_count;
  177.   THR_LOCK_DATA **locks;
  178. } MYSQL_LOCK;
  179.  
  180.  
  181. class LEX_COLUMN : public Sql_alloc
  182. {
  183. public:
  184.   String column;
  185.   uint rights;
  186.   LEX_COLUMN (const String& x,const  uint& y ): column (x),rights (y) {}
  187. };
  188.  
  189. #include "sql_lex.h"                /* Must be here */
  190.  
  191. // needed to be able to have an I_List of char* strings.in mysqld.cc where we cannot use String
  192. // because it is Sql_alloc'ed
  193. class i_string: public ilink
  194. {
  195. public:
  196.   char* ptr;
  197.   i_string():ptr(0) { }
  198.   i_string(char* s) : ptr(s) {}
  199. };
  200.  
  201. //needed for linked list of two strings for replicate-rewrite-db
  202. class i_string_pair: public ilink
  203. {
  204. public:
  205.   char* key;
  206.   char* val;
  207.   i_string_pair():key(0),val(0) { }
  208.   i_string_pair(char* key, char* val) : key(key),val(val) {}
  209. };
  210.  
  211.  
  212. /****************************************************************************
  213. ** every connection is handle by a thread with a THD
  214. ****************************************************************************/
  215.  
  216. class delayed_insert;
  217.  
  218. class THD :public ilink {
  219. public:
  220.   NET      net;
  221.   LEX      lex;
  222.   MEM_ROOT mem_root;
  223.   HASH     user_vars;
  224.   String  packet;                /* Room for 1 row */
  225.   struct  sockaddr_in remote;
  226.   struct  rand_struct rand;
  227.   char      *query,*thread_stack;
  228.   char      *host,*user,*priv_user,*db,*ip;
  229.   const   char *proc_info;
  230.   uint      client_capabilities,max_packet_length;
  231.   uint      master_access,db_access;
  232.   TABLE   *open_tables,*temporary_tables;
  233.   MYSQL_LOCK *lock,*locked_tables;
  234.   ULL      *ull;
  235.   struct st_my_thread_var *mysys_var;
  236.   enum enum_server_command command;
  237.   uint32 server_id;
  238.   const char *where;
  239.   char* last_nx_table; // last non-existent table, we need this for replication
  240.   char* last_nx_db; // database of the last nx table
  241.   time_t  start_time,time_after_lock,user_time;
  242.   time_t  connect_time,thr_create_time; // track down slow pthread_create
  243.   thr_lock_type update_lock_default;
  244.   delayed_insert *di;
  245.   struct st_transactions {
  246.     IO_CACHE trans_log;
  247.     void *bdb_tid;
  248.     uint bdb_lock_count;
  249.   } transaction;
  250.   Item         *free_list;
  251.   CONVERT    *convert_set;
  252.   Field      *dupp_field;
  253. #ifndef __WIN__
  254.   sigset_t signals,block_signals;
  255. #endif
  256.   ulonglong  next_insert_id,last_insert_id,current_insert_id;
  257.   ha_rows select_limit,offset_limit,default_select_limit,cuted_fields,
  258.           max_join_size,sent_row_count;
  259.   table_map    used_tables;
  260.   ulong query_id,version, inactive_timeout,options,thread_id;
  261.   long  dbug_thread_id;
  262.   pthread_t  real_id;
  263.   uint    current_tablenr,tmp_table,cond_count,col_access,query_length;
  264.   uint  server_status,open_options;
  265.   bool       slave_thread;
  266.   char         scramble[9];
  267.   bool         set_query_id,locked,count_cuted_fields,some_tables_deleted;
  268.   bool         no_errors, allow_sum_func, password, fatal_error;
  269.   bool         query_start_used,last_insert_id_used,insert_id_used;
  270.   bool         volatile killed,bootstrap;
  271.   bool         system_thread,in_lock_tables,global_read_lock;
  272.   bool       query_error;
  273.   LOG_INFO*  current_linfo;
  274.   // if we do a purge of binary logs, log index info of the threads
  275.   // that are currently reading it needs to be adjusted. To do that
  276.   // each thread that is using LOG_INFO needs to adjust the pointer to it
  277.   THD();
  278.   ~THD();
  279.   bool store_globals();
  280.   inline time_t query_start() { query_start_used=1; return start_time; }
  281.   inline void    set_time()    { if (user_time) start_time=time_after_lock=user_time; else time_after_lock=time(&start_time); }
  282.   inline void    end_time()    { time(&start_time); }
  283.   inline void    set_time(time_t t) { time_after_lock=start_time=user_time=t; }
  284.   inline void    lock_time()   { time(&time_after_lock); }
  285.   inline void    insert_id(ulonglong id)
  286.   { last_insert_id=id; insert_id_used=1; }
  287.   inline ulonglong insert_id(void)
  288.   {
  289.     if (!last_insert_id_used)
  290.     {      
  291.       last_insert_id_used=1;
  292.       current_insert_id=last_insert_id;
  293.     }
  294.     return last_insert_id;
  295.   }
  296.   inline bool active_transaction() { return transaction.bdb_tid != 0; }
  297.   inline gptr alloc(unsigned int size) { return alloc_root(&mem_root,size); }
  298.   inline gptr calloc(unsigned int size)
  299.   {
  300.     gptr ptr;
  301.     if ((ptr=alloc_root(&mem_root,size)))
  302.       bzero((char*) ptr,size);
  303.     return ptr;
  304.   }
  305.   inline char *strdup(const char *str)
  306.   { return strdup_root(&mem_root,str); }
  307.   inline char *memdup(const char *str, unsigned int size)
  308.   { return memdup_root(&mem_root,str,size); }
  309. };
  310.  
  311.  
  312. class sql_exchange :public Sql_alloc
  313. {
  314. public:
  315.   char *file_name;
  316.   String *field_term,*enclosed,*line_term,*line_start,*escaped;
  317.   bool opt_enclosed;
  318.   bool dumpfile;
  319.   uint skip_lines;
  320.   sql_exchange(char *name,bool dumpfile_flag);
  321.   ~sql_exchange() {}
  322. };
  323.  
  324. #include "log_event.h"
  325.  
  326. /*
  327. ** This is used to get result from a select
  328. */
  329.  
  330. class select_result :public Sql_alloc {
  331. protected:
  332.   THD *thd;
  333. public:
  334.   select_result();
  335.   virtual ~select_result() {};
  336.   virtual int prepare(List<Item> &list) { return 0; }
  337.   virtual bool send_fields(List<Item> &list,uint flag)=0;
  338.   virtual bool send_data(List<Item> &items)=0;
  339.   virtual void send_error(uint errcode,const char *err)=0;
  340.   virtual bool send_eof()=0;
  341.   virtual void abort() {}
  342. };
  343.  
  344.  
  345. class select_send :public select_result {
  346. public:
  347.   select_send() {}
  348.   bool send_fields(List<Item> &list,uint flag);
  349.   bool send_data(List<Item> &items);
  350.   void send_error(uint errcode,const char *err);
  351.   bool send_eof();
  352. };
  353.  
  354.  
  355. class select_export :public select_result {
  356.   sql_exchange *exchange;
  357.   File file;
  358.   IO_CACHE cache;
  359.   ha_rows row_count;
  360.   uint field_term_length;
  361.   int field_sep_char,escape_char,line_sep_char;
  362.   bool fixed_row_size;
  363. public:
  364.   select_export(sql_exchange *ex) :exchange(ex),file(-1),row_count(0L) {}
  365.   ~select_export();
  366.   int prepare(List<Item> &list);
  367.   bool send_fields(List<Item> &list,
  368.            uint flag) { return 0; }
  369.   bool send_data(List<Item> &items);
  370.   void send_error(uint errcode,const char *err);
  371.   bool send_eof();
  372. };
  373.  
  374. class select_dump :public select_result {
  375.   sql_exchange *exchange;
  376.   File file;
  377.   IO_CACHE cache;
  378.   ha_rows row_count;
  379.   char path[FN_REFLEN];
  380. public:
  381.   select_dump(sql_exchange *ex) :exchange(ex),file(-1),row_count(0L)
  382.   { path[0]=0; }
  383.   ~select_dump();
  384.   int prepare(List<Item> &list);
  385.   bool send_fields(List<Item> &list,
  386.            uint flag) { return 0; }
  387.   bool send_data(List<Item> &items);
  388.   void send_error(uint errcode,const char *err);
  389.   bool send_eof();
  390. };
  391.  
  392.  
  393. class select_insert :public select_result {
  394.  protected:
  395.   TABLE *table;
  396.   List<Item> *fields;
  397.   uint save_time_stamp;
  398.   ulonglong last_insert_id;
  399.   COPY_INFO info;
  400.  
  401. public:
  402.   select_insert(TABLE *table_par,List<Item> *fields_par,enum_duplicates duplic)
  403.     :table(table_par),fields(fields_par), save_time_stamp(0),last_insert_id(0)
  404.     {
  405.       bzero((char*) &info,sizeof(info));
  406.       info.handle_duplicates=duplic;
  407.     }
  408.   ~select_insert();
  409.   int prepare(List<Item> &list);
  410.   bool send_fields(List<Item> &list,
  411.            uint flag) { return 0; }
  412.   bool send_data(List<Item> &items);
  413.   void send_error(uint errcode,const char *err);
  414.   bool send_eof();
  415. };
  416.  
  417. class select_create: public select_insert {
  418.   ORDER *group;
  419.   const char *db;
  420.   const char *name;
  421.   List<create_field> *extra_fields;
  422.   List<Key> *keys;
  423.   HA_CREATE_INFO *create_info;
  424.   MYSQL_LOCK *lock;
  425.   Field **field;
  426. public:
  427.   select_create (const char *db_name, const char *table_name,
  428.          HA_CREATE_INFO *create_info_par,
  429.          List<create_field> &fields_par,
  430.          List<Key> &keys_par,
  431.          List<Item> &select_fields,enum_duplicates duplic)
  432.     :select_insert (NULL, &select_fields, duplic), db(db_name),
  433.     name(table_name), extra_fields(&fields_par),keys(&keys_par),
  434.     create_info(create_info_par),
  435.     lock(0)
  436.     {}
  437.   int prepare(List<Item> &list);
  438.   bool send_data(List<Item> &values);
  439.   bool send_eof();
  440.   void abort();
  441. };
  442.  
  443. /* Structs used when sorting */
  444.  
  445. typedef struct st_sort_field {
  446.   Field *field;                /* Field to sort */
  447.   Item    *item;                /* Item if not sorting fields */
  448.   uint     length;            /* Length of sort field */
  449.   my_bool reverse;            /* if descending sort */
  450.   Item_result result_type;        /* Type of item */
  451. } SORT_FIELD;
  452.  
  453.  
  454. typedef struct st_sort_buffer {
  455.   uint index;                    /* 0 or 1 */
  456.   uint sort_orders;
  457.   uint change_pos;                /* If sort-fields changed */
  458.   char **buff;
  459.   SORT_FIELD *sortorder;
  460. } SORT_BUFFER;
  461.  
  462.  
  463. /* Structure for db & table in sql_yacc */
  464.  
  465. class Table_ident :public Sql_alloc {
  466.  public:
  467.   LEX_STRING db;
  468.   LEX_STRING table;
  469.   inline Table_ident(LEX_STRING db_arg,LEX_STRING table_arg,bool force)
  470.     :table(table_arg)
  471.   {
  472.     if (!force && (current_thd->client_capabilities & CLIENT_NO_SCHEMA))
  473.       db.str=0;
  474.     else
  475.       db= db_arg;
  476.   }
  477.   inline Table_ident(LEX_STRING table_arg) :table(table_arg) {db.str=0;}
  478.   inline void change_db(char *db_name)
  479.   { db.str= db_name; db.length=(uint) strlen(db_name); }
  480. };
  481.  
  482. // this is needed for user_vars hash
  483. class user_var_entry
  484. {
  485.  public:
  486.   LEX_STRING name;
  487.   char *value;
  488.   ulong length;
  489.   Item_result type;
  490. };
  491.  
  492.