sql_class.cpp
上传用户:romrleung
上传日期:2022-05-23
资源大小:18897k
文件大小:43k
源码类别:

MySQL数据库

开发平台:

Visual C++

  1. /* Copyright (C) 2000 MySQL AB & MySQL Finland AB & TCX DataKonsult AB
  2.    This program is free software; you can redistribute it and/or modify
  3.    it under the terms of the GNU General Public License as published by
  4.    the Free Software Foundation; either version 2 of the License, or
  5.    (at your option) any later version.
  6.    This program is distributed in the hope that it will be useful,
  7.    but WITHOUT ANY WARRANTY; without even the implied warranty of
  8.    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  9.    GNU General Public License for more details.
  10.    You should have received a copy of the GNU General Public License
  11.    along with this program; if not, write to the Free Software
  12.    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA */
  13. /*****************************************************************************
  14. **
  15. ** This file implements classes defined in sql_class.h
  16. ** Especially the classes to handle a result from a select
  17. **
  18. *****************************************************************************/
  19. #ifdef USE_PRAGMA_IMPLEMENTATION
  20. #pragma implementation // gcc: Class implementation
  21. #endif
  22. #include "mysql_priv.h"
  23. #include <m_ctype.h>
  24. #include <sys/stat.h>
  25. #include <thr_alarm.h>
  26. #ifdef __WIN__
  27. #include <io.h>
  28. #endif
  29. #include <mysys_err.h>
  30. /*
  31.   The following is used to initialise Table_ident with a internal
  32.   table name
  33. */
  34. char internal_table_name[2]= "*";
  35. /*****************************************************************************
  36. ** Instansiate templates
  37. *****************************************************************************/
  38. #ifdef __GNUC__
  39. /* Used templates */
  40. template class List<Key>;
  41. template class List_iterator<Key>;
  42. template class List<key_part_spec>;
  43. template class List_iterator<key_part_spec>;
  44. template class List<Alter_drop>;
  45. template class List_iterator<Alter_drop>;
  46. template class List<Alter_column>;
  47. template class List_iterator<Alter_column>;
  48. #endif
  49. /****************************************************************************
  50. ** User variables
  51. ****************************************************************************/
  52. extern "C" byte *get_var_key(user_var_entry *entry, uint *length,
  53.      my_bool not_used __attribute__((unused)))
  54. {
  55.   *length=(uint) entry->name.length;
  56.   return (byte*) entry->name.str;
  57. }
  58. extern "C" void free_user_var(user_var_entry *entry)
  59. {
  60.   char *pos= (char*) entry+ALIGN_SIZE(sizeof(*entry));
  61.   if (entry->value && entry->value != pos)
  62.     my_free(entry->value, MYF(0));
  63.   my_free((char*) entry,MYF(0));
  64. }
  65. bool key_part_spec::operator==(const key_part_spec& other) const
  66. {
  67.   return length == other.length && !strcmp(field_name, other.field_name);
  68. }
  69. /*
  70.   Test if a foreign key (= generated key) is a prefix of the given key
  71.   (ignoring key name, key type and order of columns)
  72.   NOTES:
  73.     This is only used to test if an index for a FOREIGN KEY exists
  74.   IMPLEMENTATION
  75.     We only compare field names
  76.   RETURN
  77.     0 Generated key is a prefix of other key
  78.     1 Not equal
  79. */
  80. bool foreign_key_prefix(Key *a, Key *b)
  81. {
  82.   /* Ensure that 'a' is the generated key */
  83.   if (a->generated)
  84.   {
  85.     if (b->generated && a->columns.elements > b->columns.elements)
  86.       swap_variables(Key*, a, b);               // Put shorter key in 'a'
  87.   }
  88.   else
  89.   {
  90.     if (!b->generated)
  91.       return TRUE;                              // No foreign key
  92.     swap_variables(Key*, a, b);                 // Put generated key in 'a'
  93.   }
  94.   /* Test if 'a' is a prefix of 'b' */
  95.   if (a->columns.elements > b->columns.elements)
  96.     return TRUE;                                // Can't be prefix
  97.   List_iterator<key_part_spec> col_it1(a->columns);
  98.   List_iterator<key_part_spec> col_it2(b->columns);
  99.   const key_part_spec *col1, *col2;
  100. #ifdef ENABLE_WHEN_INNODB_CAN_HANDLE_SWAPED_FOREIGN_KEY_COLUMNS
  101.   while ((col1= col_it1++))
  102.   {
  103.     bool found= 0;
  104.     col_it2.rewind();
  105.     while ((col2= col_it2++))
  106.     {
  107.       if (*col1 == *col2)
  108.       {
  109.         found= TRUE;
  110. break;
  111.       }
  112.     }
  113.     if (!found)
  114.       return TRUE;                              // Error
  115.   }
  116.   return FALSE;                                 // Is prefix
  117. #else
  118.   while ((col1= col_it1++))
  119.   {
  120.     col2= col_it2++;
  121.     if (!(*col1 == *col2))
  122.       return TRUE;
  123.   }
  124.   return FALSE;                                 // Is prefix
  125. #endif
  126. }
  127. /****************************************************************************
  128. ** Thread specific functions
  129. ****************************************************************************/
  130. THD::THD()
  131.   :user_time(0), global_read_lock(0), is_fatal_error(0),
  132.    last_insert_id_used(0),
  133.    insert_id_used(0), rand_used(0), time_zone_used(0),
  134.    in_lock_tables(0), bootstrap(0)
  135. {
  136.   current_arena= this;
  137.   host= user= priv_user= db= ip=0;
  138.   host_or_ip= "connecting host";
  139.   locked=some_tables_deleted=no_errors=password= 0;
  140.   killed=0;
  141.   query_start_used= 0;
  142.   count_cuted_fields= CHECK_FIELD_IGNORE;
  143.   db_length= col_access= 0;
  144.   query_error= tmp_table_used= 0;
  145.   next_insert_id=last_insert_id=0;
  146.   open_tables= temporary_tables= handler_tables= derived_tables= 0;
  147.   hash_clear(&handler_tables_hash);
  148.   tmp_table=0;
  149.   lock=locked_tables=0;
  150.   used_tables=0;
  151.   cuted_fields= sent_row_count= 0L;
  152.   limit_found_rows= 0;
  153.   statement_id_counter= 0UL;
  154.   // Must be reset to handle error with THD's created for init of mysqld
  155.   lex->current_select= 0;
  156.   start_time=(time_t) 0;
  157.   current_linfo =  0;
  158.   slave_thread = 0;
  159.   variables.pseudo_thread_id= 0;
  160.   one_shot_set= 0;
  161.   file_id = 0;
  162.   query_id= 0;
  163.   warn_id= 0;
  164.   db_charset= global_system_variables.collation_database;
  165.   mysys_var=0;
  166. #ifndef DBUG_OFF
  167.   dbug_sentry=THD_SENTRY_MAGIC;
  168. #endif
  169. #ifndef EMBEDDED_LIBRARY  
  170.   net.vio=0;
  171. #endif
  172.   net.last_error[0]=0; // If error on boot
  173.   client_capabilities= 0;                       // minimalistic client
  174.   ull=0;
  175.   system_thread=cleanup_done=0;
  176.   peer_port= 0; // For SHOW PROCESSLIST
  177.   transaction.changed_tables = 0;
  178. #ifdef __WIN__
  179.   real_id = 0;
  180. #endif
  181. #ifdef SIGNAL_WITH_VIO_CLOSE
  182.   active_vio = 0;
  183. #endif  
  184.   pthread_mutex_init(&LOCK_delete, MY_MUTEX_INIT_FAST);
  185.   /* Variables with default values */
  186.   proc_info="login";
  187.   where="field list";
  188.   server_id = ::server_id;
  189.   slave_net = 0;
  190.   command=COM_CONNECT;
  191. #ifndef NO_EMBEDDED_ACCESS_CHECKS
  192.   db_access=NO_ACCESS;
  193. #endif
  194.   version=refresh_version; // For boot
  195.   *scramble= '';
  196.   init();
  197.   /* Initialize sub structures */
  198.   init_sql_alloc(&warn_root, WARN_ALLOC_BLOCK_SIZE, WARN_ALLOC_PREALLOC_SIZE);
  199.   user_connect=(USER_CONN *)0;
  200.   hash_init(&user_vars, &my_charset_bin, USER_VARS_HASH_SIZE, 0, 0,
  201.     (hash_get_key) get_var_key,
  202.     (hash_free_key) free_user_var,0);
  203.   /* For user vars replication*/
  204.   if (opt_bin_log)
  205.     my_init_dynamic_array(&user_var_events,
  206.   sizeof(BINLOG_USER_VAR_EVENT *),
  207.   16,
  208.   16);
  209.   else
  210.     bzero((char*) &user_var_events, sizeof(user_var_events));
  211.   /* Protocol */
  212.   protocol= &protocol_simple; // Default protocol
  213.   protocol_simple.init(this);
  214.   protocol_prep.init(this);
  215.   tablespace_op=FALSE;
  216. #ifdef USING_TRANSACTIONS
  217.   bzero((char*) &transaction,sizeof(transaction));
  218.   /*
  219.     Binlog is always open (if needed) before a THD is created (including
  220.     bootstrap).
  221.   */
  222.   if (opt_using_transactions && mysql_bin_log.is_open())
  223.   {
  224.     if (open_cached_file(&transaction.trans_log,
  225.  mysql_tmpdir, LOG_PREFIX, binlog_cache_size,
  226.  MYF(MY_WME)))
  227.       killed=1;
  228.     transaction.trans_log.end_of_file= max_binlog_cache_size;
  229.   }
  230. #endif
  231.   init_sql_alloc(&transaction.mem_root, ALLOC_ROOT_MIN_BLOCK_SIZE, 0);
  232.   {
  233.     ulong tmp=sql_rnd_with_mutex();
  234.     randominit(&rand, tmp + (ulong) &rand, tmp + (ulong) ::query_id);
  235.   }
  236. }
  237. /*
  238.   Init common variables that has to be reset on start and on change_user
  239. */
  240. void THD::init(void)
  241. {
  242.   pthread_mutex_lock(&LOCK_global_system_variables);
  243.   variables= global_system_variables;
  244.   variables.time_format= date_time_format_copy((THD*) 0,
  245.        variables.time_format);
  246.   variables.date_format= date_time_format_copy((THD*) 0,
  247.        variables.date_format);
  248.   variables.datetime_format= date_time_format_copy((THD*) 0,
  249.    variables.datetime_format);
  250. #ifdef HAVE_NDBCLUSTER_DB
  251.   variables.ndb_use_transactions= 1;
  252. #endif
  253.   pthread_mutex_unlock(&LOCK_global_system_variables);
  254.   server_status= SERVER_STATUS_AUTOCOMMIT;
  255.   options= thd_startup_options;
  256.   open_options=ha_open_options;
  257.   update_lock_default= (variables.low_priority_updates ?
  258. TL_WRITE_LOW_PRIORITY :
  259. TL_WRITE);
  260.   session_tx_isolation= (enum_tx_isolation) variables.tx_isolation;
  261.   warn_list.empty();
  262.   bzero((char*) warn_count, sizeof(warn_count));
  263.   total_warn_count= 0;
  264.   update_charset();
  265. }
  266. /*
  267.   Init THD for query processing.
  268.   This has to be called once before we call mysql_parse.
  269.   See also comments in sql_class.h.
  270. */
  271. void THD::init_for_queries()
  272. {
  273.   ha_enable_transaction(this,TRUE);
  274.   reset_root_defaults(mem_root, variables.query_alloc_block_size,
  275.                       variables.query_prealloc_size);
  276.   reset_root_defaults(&transaction.mem_root,
  277.                       variables.trans_alloc_block_size,
  278.                       variables.trans_prealloc_size);
  279. }
  280. /*
  281.   Do what's needed when one invokes change user
  282.   SYNOPSIS
  283.     change_user()
  284.   IMPLEMENTATION
  285.     Reset all resources that are connection specific
  286. */
  287. void THD::change_user(void)
  288. {
  289.   cleanup();
  290.   cleanup_done= 0;
  291.   init();
  292.   stmt_map.reset();
  293.   hash_init(&user_vars, &my_charset_bin, USER_VARS_HASH_SIZE, 0, 0,
  294.     (hash_get_key) get_var_key,
  295.     (hash_free_key) free_user_var, 0);
  296. }
  297. /* Do operations that may take a long time */
  298. void THD::cleanup(void)
  299. {
  300.   DBUG_ENTER("THD::cleanup");
  301.   ha_rollback(this);
  302.   if (locked_tables)
  303.   {
  304.     lock=locked_tables; locked_tables=0;
  305.     close_thread_tables(this);
  306.   }
  307.   mysql_ha_flush(this, (TABLE_LIST*) 0,
  308.                  MYSQL_HA_CLOSE_FINAL | MYSQL_HA_FLUSH_ALL, FALSE);
  309.   hash_free(&handler_tables_hash);
  310.   delete_dynamic(&user_var_events);
  311.   hash_free(&user_vars);
  312.   close_temporary_tables(this);
  313.   my_free((char*) variables.time_format, MYF(MY_ALLOW_ZERO_PTR));
  314.   my_free((char*) variables.date_format, MYF(MY_ALLOW_ZERO_PTR));
  315.   my_free((char*) variables.datetime_format, MYF(MY_ALLOW_ZERO_PTR));
  316.   if (global_read_lock)
  317.     unlock_global_read_lock(this);
  318.   if (ull)
  319.   {
  320.     pthread_mutex_lock(&LOCK_user_locks);
  321.     item_user_lock_release(ull);
  322.     pthread_mutex_unlock(&LOCK_user_locks);
  323.     ull= 0;
  324.   }
  325.   cleanup_done=1;
  326.   DBUG_VOID_RETURN;
  327. }
  328. THD::~THD()
  329. {
  330.   THD_CHECK_SENTRY(this);
  331.   DBUG_ENTER("~THD()");
  332.   /* Ensure that no one is using THD */
  333.   pthread_mutex_lock(&LOCK_delete);
  334.   pthread_mutex_unlock(&LOCK_delete);
  335.   /* Close connection */
  336. #ifndef EMBEDDED_LIBRARY  
  337.   if (net.vio)
  338.   {
  339.     vio_delete(net.vio);
  340.     net_end(&net); 
  341.   }
  342. #endif
  343.   if (!cleanup_done)
  344.     cleanup();
  345. #ifdef USING_TRANSACTIONS
  346.   if (opt_using_transactions)
  347.   {
  348.     close_cached_file(&transaction.trans_log);
  349.     ha_close_connection(this);
  350.   }
  351. #endif
  352.   DBUG_PRINT("info", ("freeing host"));
  353.   if (host != my_localhost) // If not pointer to constant
  354.     safeFree(host);
  355.   if (user != delayed_user)
  356.     safeFree(user);
  357.   safeFree(ip);
  358.   safeFree(db);
  359.   free_root(&warn_root,MYF(0));
  360.   free_root(&transaction.mem_root,MYF(0));
  361.   mysys_var=0; // Safety (shouldn't be needed)
  362.   pthread_mutex_destroy(&LOCK_delete);
  363. #ifndef DBUG_OFF
  364.   dbug_sentry = THD_SENTRY_GONE;
  365. #endif  
  366.   /* Reset stmt_backup.mem_root to not double-free memory from thd.mem_root */
  367.   clear_alloc_root(&stmt_backup.main_mem_root);
  368.   DBUG_VOID_RETURN;
  369. }
  370. void THD::awake(bool prepare_to_die)
  371. {
  372.   THD_CHECK_SENTRY(this);
  373.   safe_mutex_assert_owner(&LOCK_delete); 
  374.   if (prepare_to_die)
  375.     killed = 1;
  376.   thr_alarm_kill(real_id);
  377. #ifdef SIGNAL_WITH_VIO_CLOSE
  378.   close_active_vio();
  379. #endif    
  380.   if (mysys_var)
  381.   {
  382.     pthread_mutex_lock(&mysys_var->mutex);
  383.     if (!system_thread) // Don't abort locks
  384.       mysys_var->abort=1;
  385.     /*
  386.       This broadcast could be up in the air if the victim thread
  387.       exits the cond in the time between read and broadcast, but that is
  388.       ok since all we want to do is to make the victim thread get out
  389.       of waiting on current_cond.
  390.       If we see a non-zero current_cond: it cannot be an old value (because
  391.       then exit_cond() should have run and it can't because we have mutex); so
  392.       it is the true value but maybe current_mutex is not yet non-zero (we're
  393.       in the middle of enter_cond() and there is a "memory order
  394.       inversion"). So we test the mutex too to not lock 0.
  395.       Note that there is a small chance we fail to kill. If victim has locked
  396.       current_mutex, but hasn't yet entered enter_cond() (which means that
  397.       current_cond and current_mutex are 0), then the victim will not get
  398.       a signal and it may wait "forever" on the cond (until
  399.       we issue a second KILL or the status it's waiting for happens).
  400.       It's true that we have set its thd->killed but it may not
  401.       see it immediately and so may have time to reach the cond_wait().
  402.     */
  403.     if (mysys_var->current_cond && mysys_var->current_mutex)
  404.     {
  405.       pthread_mutex_lock(mysys_var->current_mutex);
  406.       pthread_cond_broadcast(mysys_var->current_cond);
  407.       pthread_mutex_unlock(mysys_var->current_mutex);
  408.     }
  409.     pthread_mutex_unlock(&mysys_var->mutex);
  410.   }
  411. }
  412. /*
  413.   Remember the location of thread info, the structure needed for
  414.   sql_alloc() and the structure for the net buffer
  415. */
  416. bool THD::store_globals()
  417. {
  418.   if (my_pthread_setspecific_ptr(THR_THD,  this) ||
  419.       my_pthread_setspecific_ptr(THR_MALLOC, &mem_root))
  420.     return 1;
  421.   mysys_var=my_thread_var;
  422.   dbug_thread_id=my_thread_id();
  423.   /*
  424.     By default 'slave_proxy_id' is 'thread_id'. They may later become different
  425.     if this is the slave SQL thread.
  426.   */
  427.   variables.pseudo_thread_id= thread_id;
  428.   return 0;
  429. }
  430. /*
  431.   Convert a string to another character set
  432.   SYNOPSIS
  433.     convert_string()
  434.     to Store new allocated string here
  435.     to_cs New character set for allocated string
  436.     from String to convert
  437.     from_length Length of string to convert
  438.     from_cs Original character set
  439.   NOTES
  440.     to will be 0-terminated to make it easy to pass to system funcs
  441.   RETURN
  442.     0 ok
  443.     1 End of memory.
  444.         In this case to->str will point to 0 and to->length will be 0.
  445. */
  446. bool THD::convert_string(LEX_STRING *to, CHARSET_INFO *to_cs,
  447.  const char *from, uint from_length,
  448.  CHARSET_INFO *from_cs)
  449. {
  450.   DBUG_ENTER("convert_string");
  451.   size_s new_length= to_cs->mbmaxlen * from_length;
  452.   uint dummy_errors;
  453.   if (!(to->str= alloc(new_length+1)))
  454.   {
  455.     to->length= 0; // Safety fix
  456.     DBUG_RETURN(1); // EOM
  457.   }
  458.   to->length= copy_and_convert((char*) to->str, new_length, to_cs,
  459.        from, from_length, from_cs, &dummy_errors);
  460.   to->str[to->length]=0; // Safety
  461.   DBUG_RETURN(0);
  462. }
  463. /*
  464.   Convert string from source character set to target character set inplace.
  465.   SYNOPSIS
  466.     THD::convert_string
  467.   DESCRIPTION
  468.     Convert string using convert_buffer - buffer for character set 
  469.     conversion shared between all protocols.
  470.   RETURN
  471.     0   ok
  472.    !0   out of memory
  473. */
  474. bool THD::convert_string(String *s, CHARSET_INFO *from_cs, CHARSET_INFO *to_cs)
  475. {
  476.   uint dummy_errors;
  477.   if (convert_buffer.copy(s->ptr(), s->length(), from_cs, to_cs, &dummy_errors))
  478.     return TRUE;
  479.   /* If convert_buffer >> s copying is more efficient long term */
  480.   if (convert_buffer.alloced_length() >= convert_buffer.length() * 2 ||
  481.       !s->is_alloced())
  482.   {
  483.     return s->copy(convert_buffer);
  484.   }
  485.   s->swap(convert_buffer);
  486.   return FALSE;
  487. }
  488. /*
  489.   Update some cache variables when character set changes
  490. */
  491. void THD::update_charset()
  492. {
  493.   uint32 not_used;
  494.   charset_is_system_charset= !String::needs_conversion(0,charset(),
  495.                                                        system_charset_info,
  496.                                                        &not_used);
  497.   charset_is_collation_connection= 
  498.     !String::needs_conversion(0,charset(),variables.collation_connection,
  499.                               &not_used);
  500. }
  501. /* routings to adding tables to list of changed in transaction tables */
  502. inline static void list_include(CHANGED_TABLE_LIST** prev,
  503. CHANGED_TABLE_LIST* curr,
  504. CHANGED_TABLE_LIST* new_table)
  505. {
  506.   if (new_table)
  507.   {
  508.     *prev = new_table;
  509.     (*prev)->next = curr;
  510.   }
  511. }
  512. /* add table to list of changed in transaction tables */
  513. void THD::add_changed_table(TABLE *table)
  514. {
  515.   DBUG_ENTER("THD::add_changed_table(table)");
  516.   DBUG_ASSERT((options & (OPTION_NOT_AUTOCOMMIT | OPTION_BEGIN)) &&
  517.       table->file->has_transactions());
  518.   add_changed_table(table->table_cache_key, table->key_length);
  519.   DBUG_VOID_RETURN;
  520. }
  521. void THD::add_changed_table(const char *key, long key_length)
  522. {
  523.   DBUG_ENTER("THD::add_changed_table(key)");
  524.   CHANGED_TABLE_LIST **prev_changed = &transaction.changed_tables;
  525.   CHANGED_TABLE_LIST *curr = transaction.changed_tables;
  526.   for (; curr; prev_changed = &(curr->next), curr = curr->next)
  527.   {
  528.     int cmp =  (long)curr->key_length - (long)key_length;
  529.     if (cmp < 0)
  530.     {
  531.       list_include(prev_changed, curr, changed_table_dup(key, key_length));
  532.       DBUG_PRINT("info", 
  533.  ("key_length %u %u", key_length, (*prev_changed)->key_length));
  534.       DBUG_VOID_RETURN;
  535.     }
  536.     else if (cmp == 0)
  537.     {
  538.       cmp = memcmp(curr->key, key, curr->key_length);
  539.       if (cmp < 0)
  540.       {
  541. list_include(prev_changed, curr, changed_table_dup(key, key_length));
  542. DBUG_PRINT("info", 
  543.    ("key_length %u %u", key_length,
  544.     (*prev_changed)->key_length));
  545. DBUG_VOID_RETURN;
  546.       }
  547.       else if (cmp == 0)
  548.       {
  549. DBUG_PRINT("info", ("already in list"));
  550. DBUG_VOID_RETURN;
  551.       }
  552.     }
  553.   }
  554.   *prev_changed = changed_table_dup(key, key_length);
  555.   DBUG_PRINT("info", ("key_length %u %u", key_length,
  556.       (*prev_changed)->key_length));
  557.   DBUG_VOID_RETURN;
  558. }
  559. CHANGED_TABLE_LIST* THD::changed_table_dup(const char *key, long key_length)
  560. {
  561.   CHANGED_TABLE_LIST* new_table = 
  562.     (CHANGED_TABLE_LIST*) trans_alloc(ALIGN_SIZE(sizeof(CHANGED_TABLE_LIST))+
  563.       key_length + 1);
  564.   if (!new_table)
  565.   {
  566.     my_error(EE_OUTOFMEMORY, MYF(ME_BELL),
  567.      ALIGN_SIZE(sizeof(TABLE_LIST)) + key_length + 1);
  568.     killed= 1;
  569.     return 0;
  570.   }
  571.   new_table->key = (char *) (((byte*)new_table)+
  572.      ALIGN_SIZE(sizeof(CHANGED_TABLE_LIST)));
  573.   new_table->next = 0;
  574.   new_table->key_length = key_length;
  575.   ::memcpy(new_table->key, key, key_length);
  576.   return new_table;
  577. }
  578. int THD::send_explain_fields(select_result *result)
  579. {
  580.   List<Item> field_list;
  581.   Item *item;
  582.   CHARSET_INFO *cs= system_charset_info;
  583.   field_list.push_back(new Item_return_int("id",3, MYSQL_TYPE_LONGLONG));
  584.   field_list.push_back(new Item_empty_string("select_type", 19, cs));
  585.   field_list.push_back(item= new Item_empty_string("table", NAME_LEN, cs));
  586.   item->maybe_null= 1;
  587.   field_list.push_back(item= new Item_empty_string("type", 10, cs));
  588.   item->maybe_null= 1;
  589.   field_list.push_back(item=new Item_empty_string("possible_keys",
  590.   NAME_LEN*MAX_KEY, cs));
  591.   item->maybe_null=1;
  592.   field_list.push_back(item=new Item_empty_string("key", NAME_LEN, cs));
  593.   item->maybe_null=1;
  594.   field_list.push_back(item=new Item_return_int("key_len",3,
  595. MYSQL_TYPE_LONGLONG));
  596.   item->maybe_null=1;
  597.   field_list.push_back(item=new Item_empty_string("ref",
  598.   NAME_LEN*MAX_REF_PARTS, cs));
  599.   item->maybe_null=1;
  600.   field_list.push_back(item= new Item_return_int("rows", 10,
  601.                                                  MYSQL_TYPE_LONGLONG));
  602.   item->maybe_null= 1;
  603.   field_list.push_back(new Item_empty_string("Extra", 255, cs));
  604.   return (result->send_fields(field_list,1));
  605. }
  606. #ifdef SIGNAL_WITH_VIO_CLOSE
  607. void THD::close_active_vio()
  608. {
  609.   DBUG_ENTER("close_active_vio");
  610.   safe_mutex_assert_owner(&LOCK_delete); 
  611. #ifndef EMBEDDED_LIBRARY
  612.   if (active_vio)
  613.   {
  614.     vio_close(active_vio);
  615.     active_vio = 0;
  616.   }
  617. #endif
  618.   DBUG_VOID_RETURN;
  619. }
  620. #endif
  621. struct Item_change_record: public ilink
  622. {
  623.   Item **place;
  624.   Item *old_value;
  625.   /* Placement new was hidden by `new' in ilink (TODO: check): */
  626.   static void *operator new(size_t size, void *mem) { return mem; }
  627.   static void operator delete(void *ptr, size_t size) {}
  628.   static void operator delete(void *ptr, void *mem) { /* never called */ }
  629. };
  630. /*
  631.   Register an item tree tree transformation, performed by the query
  632.   optimizer. We need a pointer to runtime_memroot because it may be !=
  633.   thd->mem_root (due to possible set_n_backup_item_arena called for thd).
  634. */
  635. void THD::nocheck_register_item_tree_change(Item **place, Item *old_value,
  636.                                             MEM_ROOT *runtime_memroot)
  637. {
  638.   Item_change_record *change;
  639.   /*
  640.     Now we use one node per change, which adds some memory overhead,
  641.     but still is rather fast as we use alloc_root for allocations.
  642.     A list of item tree changes of an average query should be short.
  643.   */
  644.   void *change_mem= alloc_root(runtime_memroot, sizeof(*change));
  645.   if (change_mem == 0)
  646.   {
  647.     fatal_error();
  648.     return;
  649.   }
  650.   change= new (change_mem) Item_change_record;
  651.   change->place= place;
  652.   change->old_value= old_value;
  653.   change_list.append(change);
  654. }
  655. void THD::rollback_item_tree_changes()
  656. {
  657.   I_List_iterator<Item_change_record> it(change_list);
  658.   Item_change_record *change;
  659.   while ((change= it++))
  660.     *change->place= change->old_value;
  661.   /* We can forget about changes memory: it's allocated in runtime memroot */
  662.   change_list.empty();
  663. }
  664. /*****************************************************************************
  665. ** Functions to provide a interface to select results
  666. *****************************************************************************/
  667. select_result::select_result()
  668. {
  669.   thd=current_thd;
  670. }
  671. void select_result::send_error(uint errcode,const char *err)
  672. {
  673.   ::send_error(thd, errcode, err);
  674. }
  675. void select_result::cleanup()
  676. {
  677.   /* do nothing */
  678. }
  679. static String default_line_term("n",default_charset_info);
  680. static String default_escaped("\",default_charset_info);
  681. static String default_field_term("t",default_charset_info);
  682. sql_exchange::sql_exchange(char *name,bool flag)
  683.   :file_name(name), opt_enclosed(0), dumpfile(flag), skip_lines(0)
  684. {
  685.   field_term= &default_field_term;
  686.   enclosed=   line_start= &my_empty_string;
  687.   line_term=  &default_line_term;
  688.   escaped=    &default_escaped;
  689. }
  690. bool select_send::send_fields(List<Item> &list,uint flag)
  691. {
  692.   return thd->protocol->send_fields(&list,flag);
  693. }
  694. /* Send data to client. Returns 0 if ok */
  695. bool select_send::send_data(List<Item> &items)
  696. {
  697.   if (unit->offset_limit_cnt)
  698.   { // using limit offset,count
  699.     unit->offset_limit_cnt--;
  700.     return 0;
  701.   }
  702. #ifdef HAVE_INNOBASE_DB
  703.   /*
  704.     We may be passing the control from mysqld to the client: release the
  705.     InnoDB adaptive hash S-latch to avoid thread deadlocks if it was reserved
  706.     by thd
  707.   */
  708.   if (thd->transaction.all.innobase_tid)
  709.     ha_release_temporary_latches(thd);
  710. #endif
  711.   List_iterator_fast<Item> li(items);
  712.   Protocol *protocol= thd->protocol;
  713.   char buff[MAX_FIELD_WIDTH];
  714.   String buffer(buff, sizeof(buff), &my_charset_bin);
  715.   DBUG_ENTER("send_data");
  716.   protocol->prepare_for_resend();
  717.   Item *item;
  718.   while ((item=li++))
  719.   {
  720.     if (item->send(protocol, &buffer))
  721.     {
  722.       protocol->free(); // Free used buffer
  723.       my_message(ER_OUT_OF_RESOURCES, ER(ER_OUT_OF_RESOURCES), MYF(0));
  724.       break;
  725.     }
  726.   }
  727.   thd->sent_row_count++;
  728.   if (!thd->vio_ok())
  729.     DBUG_RETURN(0);
  730.   if (!thd->net.report_error)
  731.     DBUG_RETURN(protocol->write());
  732.   DBUG_RETURN(1);
  733. }
  734. bool select_send::send_eof()
  735. {
  736. #ifdef HAVE_INNOBASE_DB
  737.   /* We may be passing the control from mysqld to the client: release the
  738.      InnoDB adaptive hash S-latch to avoid thread deadlocks if it was reserved
  739.      by thd */
  740.   if (thd->transaction.all.innobase_tid)
  741.     ha_release_temporary_latches(thd);
  742. #endif
  743.   /* Unlock tables before sending packet to gain some speed */
  744.   if (thd->lock)
  745.   {
  746.     mysql_unlock_tables(thd, thd->lock);
  747.     thd->lock=0;
  748.   }
  749.   if (!thd->net.report_error)
  750.   {
  751.     ::send_eof(thd);
  752.     return 0;
  753.   }
  754.   else
  755.     return 1;
  756. }
  757. /************************************************************************
  758.   Handling writing to file
  759. ************************************************************************/
  760. void select_to_file::send_error(uint errcode,const char *err)
  761. {
  762.   ::send_error(thd,errcode,err);
  763.   if (file > 0)
  764.   {
  765.     (void) end_io_cache(&cache);
  766.     (void) my_close(file,MYF(0));
  767.     (void) my_delete(path,MYF(0)); // Delete file on error
  768.     file= -1;
  769.   }
  770. }
  771. bool select_to_file::send_eof()
  772. {
  773.   int error= test(end_io_cache(&cache));
  774.   if (my_close(file,MYF(MY_WME)))
  775.     error= 1;
  776.   if (!error)
  777.     ::send_ok(thd,row_count);
  778.   file= -1;
  779.   return error;
  780. }
  781. void select_to_file::cleanup()
  782. {
  783.   /* In case of error send_eof() may be not called: close the file here. */
  784.   if (file >= 0)
  785.   {
  786.     (void) end_io_cache(&cache);
  787.     (void) my_close(file,MYF(0));
  788.     file= -1;
  789.   }
  790.   path[0]= '';
  791.   row_count= 0;
  792. }
  793. select_to_file::~select_to_file()
  794. {
  795.   if (file >= 0)
  796.   { // This only happens in case of error
  797.     (void) end_io_cache(&cache);
  798.     (void) my_close(file,MYF(0));
  799.     file= -1;
  800.   }
  801. }
  802. /***************************************************************************
  803. ** Export of select to textfile
  804. ***************************************************************************/
  805. select_export::~select_export()
  806. {
  807.   thd->sent_row_count=row_count;
  808. }
  809. /*
  810.   Create file with IO cache
  811.   SYNOPSIS
  812.     create_file()
  813.     thd Thread handle
  814.     path File name
  815.     exchange Excange class
  816.     cache IO cache
  817.   RETURN
  818.     >= 0  File handle
  819.    -1 Error
  820. */
  821. static File create_file(THD *thd, char *path, sql_exchange *exchange,
  822. IO_CACHE *cache)
  823. {
  824.   File file;
  825.   uint option= MY_UNPACK_FILENAME;
  826. #ifdef DONT_ALLOW_FULL_LOAD_DATA_PATHS
  827.   option|= MY_REPLACE_DIR; // Force use of db directory
  828. #endif
  829.   if (!dirname_length(exchange->file_name))
  830.   {
  831.     strxnmov(path, FN_REFLEN, mysql_real_data_home, thd->db ? thd->db : "", NullS);
  832.     (void) fn_format(path, exchange->file_name, path, "", option);
  833.   }
  834.   else
  835.     (void) fn_format(path, exchange->file_name, mysql_real_data_home, "", option);
  836.     
  837.   if (!access(path, F_OK))
  838.   {
  839.     my_error(ER_FILE_EXISTS_ERROR, MYF(0), exchange->file_name);
  840.     return -1;
  841.   }
  842.   /* Create the file world readable */
  843.   if ((file= my_create(path, 0666, O_WRONLY|O_EXCL, MYF(MY_WME))) < 0)
  844.     return file;
  845. #ifdef HAVE_FCHMOD
  846.   (void) fchmod(file, 0666); // Because of umask()
  847. #else
  848.   (void) chmod(path, 0666);
  849. #endif
  850.   if (init_io_cache(cache, file, 0L, WRITE_CACHE, 0L, 1, MYF(MY_WME)))
  851.   {
  852.     my_close(file, MYF(0));
  853.     my_delete(path, MYF(0));  // Delete file on error, it was just created 
  854.     return -1;
  855.   }
  856.   return file;
  857. }
  858. int
  859. select_export::prepare(List<Item> &list, SELECT_LEX_UNIT *u)
  860. {
  861.   bool blob_flag=0;
  862.   unit= u;
  863.   if ((uint) strlen(exchange->file_name) + NAME_LEN >= FN_REFLEN)
  864.     strmake(path,exchange->file_name,FN_REFLEN-1);
  865.   if ((file= create_file(thd, path, exchange, &cache)) < 0)
  866.     return 1;
  867.   /* Check if there is any blobs in data */
  868.   {
  869.     List_iterator_fast<Item> li(list);
  870.     Item *item;
  871.     while ((item=li++))
  872.     {
  873.       if (item->max_length >= MAX_BLOB_WIDTH)
  874.       {
  875. blob_flag=1;
  876. break;
  877.       }
  878.     }
  879.   }
  880.   field_term_length=exchange->field_term->length();
  881.   if (!exchange->line_term->length())
  882.     exchange->line_term=exchange->field_term; // Use this if it exists
  883.   field_sep_char= (exchange->enclosed->length() ? (*exchange->enclosed)[0] :
  884.    field_term_length ? (*exchange->field_term)[0] : INT_MAX);
  885.   escape_char= (exchange->escaped->length() ? (*exchange->escaped)[0] : -1);
  886.   line_sep_char= (exchange->line_term->length() ?
  887.   (*exchange->line_term)[0] : INT_MAX);
  888.   if (!field_term_length)
  889.     exchange->opt_enclosed=0;
  890.   if (!exchange->enclosed->length())
  891.     exchange->opt_enclosed=1; // A little quicker loop
  892.   fixed_row_size= (!field_term_length && !exchange->enclosed->length() &&
  893.    !blob_flag);
  894.   return 0;
  895. }
  896. bool select_export::send_data(List<Item> &items)
  897. {
  898.   DBUG_ENTER("send_data");
  899.   char buff[MAX_FIELD_WIDTH],null_buff[2],space[MAX_FIELD_WIDTH];
  900.   bool space_inited=0;
  901.   String tmp(buff,sizeof(buff),&my_charset_bin),*res;
  902.   tmp.length(0);
  903.   if (unit->offset_limit_cnt)
  904.   { // using limit offset,count
  905.     unit->offset_limit_cnt--;
  906.     DBUG_RETURN(0);
  907.   }
  908.   row_count++;
  909.   Item *item;
  910.   char *buff_ptr=buff;
  911.   uint used_length=0,items_left=items.elements;
  912.   List_iterator_fast<Item> li(items);
  913.   if (my_b_write(&cache,(byte*) exchange->line_start->ptr(),
  914.  exchange->line_start->length()))
  915.     goto err;
  916.   while ((item=li++))
  917.   {
  918.     Item_result result_type=item->result_type();
  919.     res=item->str_result(&tmp);
  920.     if (res && (!exchange->opt_enclosed || result_type == STRING_RESULT))
  921.     {
  922.       if (my_b_write(&cache,(byte*) exchange->enclosed->ptr(),
  923.      exchange->enclosed->length()))
  924. goto err;
  925.     }
  926.     if (!res)
  927.     { // NULL
  928.       if (!fixed_row_size)
  929.       {
  930. if (escape_char != -1) // Use N syntax
  931. {
  932.   null_buff[0]=escape_char;
  933.   null_buff[1]='N';
  934.   if (my_b_write(&cache,(byte*) null_buff,2))
  935.     goto err;
  936. }
  937. else if (my_b_write(&cache,(byte*) "NULL",4))
  938.   goto err;
  939.       }
  940.       else
  941.       {
  942. used_length=0; // Fill with space
  943.       }
  944.     }
  945.     else
  946.     {
  947.       if (fixed_row_size)
  948. used_length=min(res->length(),item->max_length);
  949.       else
  950. used_length=res->length();
  951.       if (result_type == STRING_RESULT && escape_char != -1)
  952.       {
  953. char *pos,*start,*end;
  954. for (start=pos=(char*) res->ptr(),end=pos+used_length ;
  955.      pos != end ;
  956.      pos++)
  957. {
  958. #ifdef USE_MB
  959.           CHARSET_INFO *res_charset=res->charset();
  960.   if (use_mb(res_charset))
  961.   {
  962.     int l;
  963.     if ((l=my_ismbchar(res_charset, pos, end)))
  964.     {
  965.       pos += l-1;
  966.       continue;
  967.     }
  968.   }
  969. #endif
  970.   if ((int) *pos == escape_char || (int) *pos == field_sep_char ||
  971.       (int) *pos == line_sep_char || !*pos)
  972.   {
  973.     char tmp_buff[2];
  974.     tmp_buff[0]= escape_char;
  975.     tmp_buff[1]= *pos ? *pos : '0';
  976.     if (my_b_write(&cache,(byte*) start,(uint) (pos-start)) ||
  977. my_b_write(&cache,(byte*) tmp_buff,2))
  978.       goto err;
  979.     start=pos+1;
  980.   }
  981. }
  982. if (my_b_write(&cache,(byte*) start,(uint) (pos-start)))
  983.   goto err;
  984.       }
  985.       else if (my_b_write(&cache,(byte*) res->ptr(),used_length))
  986. goto err;
  987.     }
  988.     if (fixed_row_size)
  989.     { // Fill with space
  990.       if (item->max_length > used_length)
  991.       {
  992. /* QQ:  Fix by adding a my_b_fill() function */
  993. if (!space_inited)
  994. {
  995.   space_inited=1;
  996.   bfill(space,sizeof(space),' ');
  997. }
  998. uint length=item->max_length-used_length;
  999. for (; length > sizeof(space) ; length-=sizeof(space))
  1000. {
  1001.   if (my_b_write(&cache,(byte*) space,sizeof(space)))
  1002.     goto err;
  1003. }
  1004. if (my_b_write(&cache,(byte*) space,length))
  1005.   goto err;
  1006.       }
  1007.     }
  1008.     buff_ptr=buff; // Place separators here
  1009.     if (res && (!exchange->opt_enclosed || result_type == STRING_RESULT))
  1010.     {
  1011.       memcpy(buff_ptr,exchange->enclosed->ptr(),exchange->enclosed->length());
  1012.       buff_ptr+=exchange->enclosed->length();
  1013.     }
  1014.     if (--items_left)
  1015.     {
  1016.       memcpy(buff_ptr,exchange->field_term->ptr(),field_term_length);
  1017.       buff_ptr+=field_term_length;
  1018.     }
  1019.     if (my_b_write(&cache,(byte*) buff,(uint) (buff_ptr-buff)))
  1020.       goto err;
  1021.   }
  1022.   if (my_b_write(&cache,(byte*) exchange->line_term->ptr(),
  1023.  exchange->line_term->length()))
  1024.     goto err;
  1025.   DBUG_RETURN(0);
  1026. err:
  1027.   DBUG_RETURN(1);
  1028. }
  1029. /***************************************************************************
  1030. ** Dump  of select to a binary file
  1031. ***************************************************************************/
  1032. int
  1033. select_dump::prepare(List<Item> &list __attribute__((unused)),
  1034.      SELECT_LEX_UNIT *u)
  1035. {
  1036.   unit= u;
  1037.   return (int) ((file= create_file(thd, path, exchange, &cache)) < 0);
  1038. }
  1039. bool select_dump::send_data(List<Item> &items)
  1040. {
  1041.   List_iterator_fast<Item> li(items);
  1042.   char buff[MAX_FIELD_WIDTH];
  1043.   String tmp(buff,sizeof(buff),&my_charset_bin),*res;
  1044.   tmp.length(0);
  1045.   Item *item;
  1046.   DBUG_ENTER("send_data");
  1047.   if (unit->offset_limit_cnt)
  1048.   { // using limit offset,count
  1049.     unit->offset_limit_cnt--;
  1050.     DBUG_RETURN(0);
  1051.   }
  1052.   if (row_count++ > 1) 
  1053.   {
  1054.     my_error(ER_TOO_MANY_ROWS, MYF(0));
  1055.     goto err;
  1056.   }
  1057.   while ((item=li++))
  1058.   {
  1059.     res=item->str_result(&tmp);
  1060.     if (!res) // If NULL
  1061.     {
  1062.       if (my_b_write(&cache,(byte*) "",1))
  1063. goto err;
  1064.     }
  1065.     else if (my_b_write(&cache,(byte*) res->ptr(),res->length()))
  1066.     {
  1067.       my_error(ER_ERROR_ON_WRITE,MYF(0), path, my_errno);
  1068.       goto err;
  1069.     }
  1070.   }
  1071.   DBUG_RETURN(0);
  1072. err:
  1073.   DBUG_RETURN(1);
  1074. }
  1075. select_subselect::select_subselect(Item_subselect *item_arg)
  1076. {
  1077.   item= item_arg;
  1078. }
  1079. bool select_singlerow_subselect::send_data(List<Item> &items)
  1080. {
  1081.   DBUG_ENTER("select_singlerow_subselect::send_data");
  1082.   Item_singlerow_subselect *it= (Item_singlerow_subselect *)item;
  1083.   if (it->assigned())
  1084.   {
  1085.     my_message(ER_SUBQUERY_NO_1_ROW, ER(ER_SUBQUERY_NO_1_ROW), MYF(0));
  1086.     DBUG_RETURN(1);
  1087.   }
  1088.   if (unit->offset_limit_cnt)
  1089.   {           // Using limit offset,count
  1090.     unit->offset_limit_cnt--;
  1091.     DBUG_RETURN(0);
  1092.   }
  1093.   List_iterator_fast<Item> li(items);
  1094.   Item *val_item;
  1095.   for (uint i= 0; (val_item= li++); i++)
  1096.     it->store(i, val_item);
  1097.   it->assigned(1);
  1098.   DBUG_RETURN(0);
  1099. }
  1100. void select_max_min_finder_subselect::cleanup()
  1101. {
  1102.   DBUG_ENTER("select_max_min_finder_subselect::cleanup");
  1103.   cache= 0;
  1104.   DBUG_VOID_RETURN;
  1105. }
  1106. bool select_max_min_finder_subselect::send_data(List<Item> &items)
  1107. {
  1108.   DBUG_ENTER("select_max_min_finder_subselect::send_data");
  1109.   Item_maxmin_subselect *it= (Item_maxmin_subselect *)item;
  1110.   List_iterator_fast<Item> li(items);
  1111.   Item *val_item= li++;
  1112.   it->register_value();
  1113.   if (it->assigned())
  1114.   {
  1115.     cache->store(val_item);
  1116.     if ((this->*op)())
  1117.       it->store(0, cache);
  1118.   }
  1119.   else
  1120.   {
  1121.     if (!cache)
  1122.     {
  1123.       cache= Item_cache::get_cache(val_item->result_type());
  1124.       switch (val_item->result_type())
  1125.       {
  1126.       case REAL_RESULT:
  1127. op= &select_max_min_finder_subselect::cmp_real;
  1128. break;
  1129.       case INT_RESULT:
  1130. op= &select_max_min_finder_subselect::cmp_int;
  1131. break;
  1132.       case STRING_RESULT:
  1133. op= &select_max_min_finder_subselect::cmp_str;
  1134. break;
  1135.       case ROW_RESULT:
  1136.         // This case should never be choosen
  1137. DBUG_ASSERT(0);
  1138. op= 0;
  1139.       }
  1140.     }
  1141.     cache->store(val_item);
  1142.     it->store(0, cache);
  1143.   }
  1144.   it->assigned(1);
  1145.   DBUG_RETURN(0);
  1146. }
  1147. bool select_max_min_finder_subselect::cmp_real()
  1148. {
  1149.   Item *maxmin= ((Item_singlerow_subselect *)item)->el(0);
  1150.   double val1= cache->val(), val2= maxmin->val();
  1151.   if (fmax)
  1152.     return (cache->null_value && !maxmin->null_value) ||
  1153.       (!cache->null_value && !maxmin->null_value &&
  1154.        val1 > val2);
  1155.   else
  1156.     return (maxmin->null_value && !cache->null_value) ||
  1157.       (!cache->null_value && !maxmin->null_value &&
  1158.        val1 < val2);
  1159. }
  1160. bool select_max_min_finder_subselect::cmp_int()
  1161. {
  1162.   Item *maxmin= ((Item_singlerow_subselect *)item)->el(0);
  1163.   longlong val1= cache->val_int(), val2= maxmin->val_int();
  1164.   if (fmax)
  1165.     return (cache->null_value && !maxmin->null_value) ||
  1166.       (!cache->null_value && !maxmin->null_value &&
  1167.        val1 > val2);
  1168.   else
  1169.     return (maxmin->null_value && !cache->null_value) ||
  1170.       (!cache->null_value && !maxmin->null_value &&
  1171.        val1 < val2);
  1172. }
  1173. bool select_max_min_finder_subselect::cmp_str()
  1174. {
  1175.   String *val1, *val2, buf1, buf2;
  1176.   Item *maxmin= ((Item_singlerow_subselect *)item)->el(0);
  1177.   /*
  1178.     as far as both operand is Item_cache buf1 & buf2 will not be used,
  1179.     but added for safety
  1180.   */
  1181.   val1= cache->val_str(&buf1);
  1182.   val2= maxmin->val_str(&buf1);
  1183.   if (fmax)
  1184.     return (cache->null_value && !maxmin->null_value) ||
  1185.       (!cache->null_value && !maxmin->null_value &&
  1186.        sortcmp(val1, val2, cache->collation.collation) > 0) ;
  1187.   else
  1188.     return (maxmin->null_value && !cache->null_value) ||
  1189.       (!cache->null_value && !maxmin->null_value &&
  1190.        sortcmp(val1, val2, cache->collation.collation) < 0);
  1191. }
  1192. bool select_exists_subselect::send_data(List<Item> &items)
  1193. {
  1194.   DBUG_ENTER("select_exists_subselect::send_data");
  1195.   Item_exists_subselect *it= (Item_exists_subselect *)item;
  1196.   if (unit->offset_limit_cnt)
  1197.   {           // Using limit offset,count
  1198.     unit->offset_limit_cnt--;
  1199.     DBUG_RETURN(0);
  1200.   }
  1201.   it->value= 1;
  1202.   it->assigned(1);
  1203.   DBUG_RETURN(0);
  1204. }
  1205. /***************************************************************************
  1206.   Dump of select to variables
  1207. ***************************************************************************/
  1208. int select_dumpvar::prepare(List<Item> &list, SELECT_LEX_UNIT *u)
  1209. {
  1210.   List_iterator_fast<Item> li(list);
  1211.   List_iterator_fast<LEX_STRING> gl(var_list);
  1212.   Item *item;
  1213.   LEX_STRING *ls;
  1214.   if (var_list.elements != list.elements)
  1215.   {
  1216.     my_error(ER_WRONG_NUMBER_OF_COLUMNS_IN_SELECT, MYF(0));
  1217.     return 1;
  1218.   }
  1219.   unit=u;
  1220.   while ((item=li++))
  1221.   {
  1222.     ls= gl++;
  1223.     Item_func_set_user_var *xx = new Item_func_set_user_var(*ls,item);
  1224.     /*
  1225.       Item_func_set_user_var can't substitute something else on its place =>
  1226.       0 can be passed as last argument (reference on item)
  1227.     */
  1228.     xx->fix_fields(thd,(TABLE_LIST*) thd->lex->select_lex.table_list.first,
  1229.    0);
  1230.     xx->fix_length_and_dec();
  1231.     vars.push_back(xx);
  1232.   }
  1233.   return 0;
  1234. }
  1235. void select_dumpvar::cleanup()
  1236. {
  1237.   vars.empty();
  1238.   row_count=0;
  1239. }
  1240. /*
  1241.   Create arena for already constructed THD.
  1242.   SYNOPSYS
  1243.     Item_arena()
  1244.       thd - thread for which arena is created
  1245.   DESCRIPTION
  1246.     Create arena for already existing THD using its variables as parameters
  1247.     for memory root initialization.
  1248. */
  1249. Item_arena::Item_arena(THD* thd)
  1250.   :free_list(0), mem_root(&main_mem_root),
  1251.    state(INITIALIZED)
  1252. {
  1253.   init_sql_alloc(&main_mem_root,
  1254.                  thd->variables.query_alloc_block_size,
  1255.                  thd->variables.query_prealloc_size);
  1256. }
  1257. /*
  1258.   Create arena and optionally initialize memory root.
  1259.   SYNOPSYS
  1260.     Item_arena()
  1261.       init_mem_root - whenever we need to initialize memory root
  1262.   DESCRIPTION
  1263.     Create arena and optionally initialize memory root with minimal
  1264.     possible parameters.
  1265.   NOTE
  1266.     We use this constructor when arena is part of THD, but reinitialize
  1267.     its memory root in THD::init_for_queries() before execution of real
  1268.     statements.
  1269. */
  1270. Item_arena::Item_arena(bool init_mem_root)
  1271.   :free_list(0), mem_root(&main_mem_root),
  1272.   state(CONVENTIONAL_EXECUTION)
  1273. {
  1274.   if (init_mem_root)
  1275.     init_sql_alloc(&main_mem_root, ALLOC_ROOT_MIN_BLOCK_SIZE, 0);
  1276. }
  1277. Item_arena::Type Item_arena::type() const
  1278. {
  1279.   DBUG_ASSERT("Item_arena::type()" == "abstract");
  1280.   return STATEMENT;
  1281. }
  1282. /*
  1283.   Statement functions 
  1284. */
  1285. Statement::Statement(THD *thd)
  1286.   :Item_arena(thd),
  1287.   id(++thd->statement_id_counter),
  1288.   set_query_id(1),
  1289.   allow_sum_func(0),
  1290.   lex(&main_lex),
  1291.   query(0),
  1292.   query_length(0)
  1293. {
  1294.   name.str= NULL;
  1295. }
  1296. /*
  1297.   This constructor is called when statement is a subobject of THD:
  1298.   Some variables are initialized in THD::init due to locking problems
  1299.   This statement object will be used to 
  1300. */
  1301. Statement::Statement()
  1302.   :Item_arena((bool)TRUE),
  1303.   id(0),
  1304.   set_query_id(1),
  1305.   allow_sum_func(0),                            /* initialized later */
  1306.   lex(&main_lex),
  1307.   query(0),                                     /* these two are set */ 
  1308.   query_length(0)                               /* in alloc_query() */
  1309. {
  1310. }
  1311. Item_arena::Type Statement::type() const
  1312. {
  1313.   return STATEMENT;
  1314. }
  1315. void Statement::set_statement(Statement *stmt)
  1316. {
  1317.   id=             stmt->id;
  1318.   set_query_id=   stmt->set_query_id;
  1319.   allow_sum_func= stmt->allow_sum_func;
  1320.   lex=            stmt->lex;
  1321.   query=          stmt->query;
  1322.   query_length=   stmt->query_length;
  1323. }
  1324. void
  1325. Statement::set_n_backup_statement(Statement *stmt, Statement *backup)
  1326. {
  1327.   backup->set_statement(this);
  1328.   set_statement(stmt);
  1329. }
  1330. void Statement::restore_backup_statement(Statement *stmt, Statement *backup)
  1331. {
  1332.   stmt->set_statement(this);
  1333.   set_statement(backup);
  1334. }
  1335. void THD::end_statement()
  1336. {
  1337.   /* Cleanup SQL processing state to resuse this statement in next query. */
  1338.   lex_end(lex);
  1339.   delete lex->result;
  1340.   lex->result= 0;
  1341.   free_items(free_list);
  1342.   free_list= 0;
  1343.   /*
  1344.     Don't free mem_root, as mem_root is freed in the end of dispatch_command
  1345.     (once for any command).
  1346.   */
  1347. }
  1348. void Item_arena::set_n_backup_item_arena(Item_arena *set, Item_arena *backup)
  1349. {
  1350.   DBUG_ENTER("Item_arena::set_n_backup_item_arena");
  1351.   backup->set_item_arena(this);
  1352.   set_item_arena(set);
  1353.   DBUG_VOID_RETURN;
  1354. }
  1355. void Item_arena::restore_backup_item_arena(Item_arena *set, Item_arena *backup)
  1356. {
  1357.   DBUG_ENTER("Item_arena::restore_backup_item_arena");
  1358.   set->set_item_arena(this);
  1359.   set_item_arena(backup);
  1360. #ifdef NOT_NEEDED_NOW
  1361.   /*
  1362.     Reset backup mem_root to avoid its freeing.
  1363.     Since Item_arena's mem_root is freed only when it is part of Statement
  1364.     we need this only if we use some Statement's arena as backup storage.
  1365.     But we do this only with THD::stmt_backup and this Statement is specially
  1366.     handled in this respect. So this code is not really needed now.
  1367.   */
  1368.   clear_alloc_root(&backup->mem_root);
  1369. #endif
  1370.   DBUG_VOID_RETURN;
  1371. }
  1372. void Item_arena::set_item_arena(Item_arena *set)
  1373. {
  1374.   mem_root=  set->mem_root;
  1375.   free_list= set->free_list;
  1376.   state= set->state;
  1377. }
  1378. Statement::~Statement()
  1379. {
  1380.   free_root(&main_mem_root, MYF(0));
  1381. }
  1382. C_MODE_START
  1383. static byte *
  1384. get_statement_id_as_hash_key(const byte *record, uint *key_length,
  1385.                              my_bool not_used __attribute__((unused)))
  1386. {
  1387.   const Statement *statement= (const Statement *) record; 
  1388.   *key_length= sizeof(statement->id);
  1389.   return (byte *) &((const Statement *) statement)->id;
  1390. }
  1391. static void delete_statement_as_hash_key(void *key)
  1392. {
  1393.   delete (Statement *) key;
  1394. }
  1395. static byte *get_stmt_name_hash_key(Statement *entry, uint *length,
  1396.                                     my_bool not_used __attribute__((unused)))
  1397. {
  1398.   *length=(uint) entry->name.length;
  1399.   return (byte*) entry->name.str;
  1400. }
  1401. C_MODE_END
  1402. Statement_map::Statement_map() :
  1403.   last_found_statement(0)
  1404. {
  1405.   enum
  1406.   {
  1407.     START_STMT_HASH_SIZE = 16,
  1408.     START_NAME_HASH_SIZE = 16
  1409.   };
  1410.   hash_init(&st_hash, &my_charset_bin, START_STMT_HASH_SIZE, 0, 0,
  1411.             get_statement_id_as_hash_key,
  1412.             delete_statement_as_hash_key, MYF(0));
  1413.   hash_init(&names_hash, system_charset_info, START_NAME_HASH_SIZE, 0, 0,
  1414.             (hash_get_key) get_stmt_name_hash_key,
  1415.             NULL,MYF(0));
  1416. }
  1417. int Statement_map::insert(Statement *statement)
  1418. {
  1419.   int rc= my_hash_insert(&st_hash, (byte *) statement);
  1420.   if (rc == 0)
  1421.     last_found_statement= statement;
  1422.   if (statement->name.str)
  1423.   {
  1424.     /*
  1425.       If there is a statement with the same name, remove it. It is ok to 
  1426.       remove old and fail to insert new one at the same time.
  1427.     */
  1428.     Statement *old_stmt;
  1429.     if ((old_stmt= find_by_name(&statement->name)))
  1430.       erase(old_stmt); 
  1431.     if ((rc= my_hash_insert(&names_hash, (byte*)statement)))
  1432.       hash_delete(&st_hash, (byte*)statement);
  1433.   }
  1434.   return rc;
  1435. }
  1436. bool select_dumpvar::send_data(List<Item> &items)
  1437. {
  1438.   List_iterator_fast<Item_func_set_user_var> li(vars);
  1439.   Item_func_set_user_var *xx;
  1440.   DBUG_ENTER("send_data");
  1441.   if (unit->offset_limit_cnt)
  1442.   {           // Using limit offset,count
  1443.     unit->offset_limit_cnt--;
  1444.     DBUG_RETURN(0);
  1445.   }
  1446.   if (row_count++) 
  1447.   {
  1448.     my_error(ER_TOO_MANY_ROWS, MYF(0));
  1449.     DBUG_RETURN(1);
  1450.   }
  1451.   while ((xx=li++))
  1452.   {
  1453.     xx->check();
  1454.     xx->update();
  1455.   }
  1456.   DBUG_RETURN(0);
  1457. }
  1458. bool select_dumpvar::send_eof()
  1459. {
  1460.   if (row_count)
  1461.   {
  1462.     ::send_ok(thd,row_count);
  1463.     return 0;
  1464.   }
  1465.   else
  1466.   {
  1467.     my_error(ER_EMPTY_QUERY,MYF(0));
  1468.     return 1;
  1469.   }
  1470. }
  1471. /****************************************************************************
  1472.   TMP_TABLE_PARAM
  1473. ****************************************************************************/
  1474. void TMP_TABLE_PARAM::init()
  1475. {
  1476.   field_count= sum_func_count= func_count= hidden_field_count= 0;
  1477.   group_parts= group_length= group_null_parts= 0;
  1478.   quick_group= 1;
  1479. }