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_insert.cpp < prev    next >
C/C++ Source or Header  |  2000-11-18  |  37KB  |  1,373 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. /* Insert of records */
  19.  
  20. #include "mysql_priv.h"
  21. #include "sql_acl.h"
  22.  
  23. static int check_null_fields(THD *thd,TABLE *entry);
  24. static TABLE *delayed_get_table(THD *thd,TABLE_LIST *table_list);
  25. static int write_delayed(THD *thd,TABLE *table, enum_duplicates dup,
  26.              char *query, uint query_length, bool log_on);
  27. static void end_delayed_insert(THD *thd);
  28. static pthread_handler_decl(handle_delayed_insert,arg);
  29. static void unlink_blobs(register TABLE *table);
  30.  
  31. /* Define to force use of my_malloc() if the allocated memory block is big */
  32.  
  33. #ifndef HAVE_ALLOCA
  34. #define my_safe_alloca(size, min_length) my_alloca(size)
  35. #define my_safe_afree(ptr, size, min_length) my_afree(ptr)
  36. #else
  37. #define my_safe_alloca(size, min_length) ((size <= min_length) ? my_alloca(size) : my_malloc(size,MYF(0)))
  38. #define my_safe_afree(ptr, size, min_length) if (size > min_length) my_free(ptr,MYF(0))
  39. #endif
  40.  
  41.  
  42. /*
  43.   Check if insert fields are correct
  44.   Resets form->time_stamp if a timestamp value is set
  45. */
  46.  
  47. static int
  48. check_insert_fields(THD *thd,TABLE *table,List<Item> &fields,
  49.             List<Item> &values, ulong counter)
  50. {
  51.   if (fields.elements == 0 && values.elements != 0)
  52.   {
  53.     if (values.elements != table->fields)
  54.     {
  55.       my_printf_error(ER_WRONG_VALUE_COUNT_ON_ROW,
  56.               ER(ER_WRONG_VALUE_COUNT_ON_ROW),
  57.               MYF(0),counter);
  58.       return -1;
  59.     }
  60.     if (grant_option &&
  61.     check_grant_all_columns(thd,INSERT_ACL,table))
  62.       return -1;
  63.     table->time_stamp=0;            // This should be saved
  64.   }
  65.   else
  66.   {                        // Part field list
  67.     if (fields.elements != values.elements)
  68.     {
  69.       my_printf_error(ER_WRONG_VALUE_COUNT_ON_ROW,
  70.               ER(ER_WRONG_VALUE_COUNT_ON_ROW),
  71.               MYF(0),counter);
  72.       return -1;
  73.     }
  74.     TABLE_LIST table_list;
  75.     bzero((char*) &table_list,sizeof(table_list));
  76.     table_list.name=table->table_name;
  77.     table_list.table=table;
  78.     table_list.grant=table->grant;
  79.  
  80.     thd->dupp_field=0;
  81.     if (setup_fields(thd,&table_list,fields,1,0))
  82.       return -1;
  83.     if (thd->dupp_field)
  84.     {
  85.       my_error(ER_FIELD_SPECIFIED_TWICE,MYF(0), thd->dupp_field->field_name);
  86.       return -1;
  87.     }
  88.     if (table->timestamp_field &&    // Don't set timestamp if used
  89.     table->timestamp_field->query_id == thd->query_id)
  90.       table->time_stamp=0;        // This should be saved
  91.   }
  92.  // For the values we need select_priv
  93.   table->grant.want_privilege=(SELECT_ACL & ~table->grant.privilege);
  94.   return 0;
  95. }
  96.  
  97.  
  98. int mysql_insert(THD *thd,TABLE_LIST *table_list, List<Item> &fields,
  99.          List<List_item> &values_list,enum_duplicates duplic,
  100.          thr_lock_type lock_type)
  101. {
  102.   int error;
  103.   bool log_on= ((thd->options & OPTION_UPDATE_LOG) ||
  104.         !(thd->master_access & PROCESS_ACL));
  105.   uint value_count;
  106.   uint save_time_stamp;
  107.   ulong counter = 1;
  108.   ulonglong id;
  109.   COPY_INFO info;
  110.   TABLE *table;
  111.   List_iterator<List_item> its(values_list);
  112.   List_item *values;
  113.   char *query=thd->query;
  114.   DBUG_ENTER("mysql_insert");
  115.  
  116.   /*
  117.     in safe mode or with skip-new change delayed insert to be regular
  118.     if we are told to replace duplicates, the insert cannot be concurrent
  119.     delayed insert changed to regular in slave thread
  120.    */
  121.   if ((lock_type == TL_WRITE_DELAYED &&
  122.        ((specialflag & (SPECIAL_NO_NEW_FUNC | SPECIAL_SAFE_MODE)) ||
  123.     thd->slave_thread)) ||
  124.       (lock_type == TL_WRITE_CONCURRENT_INSERT && duplic == DUP_REPLACE))
  125.     lock_type=TL_WRITE;
  126.  
  127.   if (lock_type == TL_WRITE_DELAYED)
  128.   {
  129.     if (thd->locked_tables)
  130.     {
  131.       if (find_locked_table(thd,
  132.                 table_list->db ? table_list->db : thd->db,
  133.                 table_list->real_name))
  134.       {
  135.     my_printf_error(ER_DELAYED_INSERT_TABLE_LOCKED,
  136.             ER(ER_DELAYED_INSERT_TABLE_LOCKED),
  137.             MYF(0), table_list->real_name);
  138.     DBUG_RETURN(-1);
  139.       }
  140.     }
  141.     if (!(table = delayed_get_table(thd,table_list)) && !thd->fatal_error)
  142.       table = open_ltable(thd,table_list,lock_type=thd->update_lock_default);
  143.   }
  144.   else
  145.     table = open_ltable(thd,table_list,lock_type);
  146.   if (!table)
  147.     DBUG_RETURN(-1);
  148.   thd->proc_info="init";
  149.   thd->used_tables=0;
  150.   save_time_stamp=table->time_stamp;
  151.   values= its++;
  152.   if (check_insert_fields(thd,table,fields,*values,1) ||
  153.       setup_fields(thd,table_list,*values,0,0))
  154.   {
  155.     table->time_stamp=save_time_stamp;
  156.     goto abort;
  157.   }
  158.   value_count= values->elements;
  159.   while ((values = its++))
  160.   {
  161.     counter++;
  162.     if (values->elements != value_count)
  163.     {
  164.       my_printf_error(ER_WRONG_VALUE_COUNT_ON_ROW,
  165.               ER(ER_WRONG_VALUE_COUNT_ON_ROW),
  166.               MYF(0),counter);
  167.       table->time_stamp=save_time_stamp;
  168.       goto abort;
  169.     }
  170.     if (setup_fields(thd,table_list,*values,0,0))
  171.     {
  172.       table->time_stamp=save_time_stamp;
  173.       goto abort;
  174.     }
  175.   }
  176.   its.rewind ();
  177.   /*
  178.   ** Fill in the given fields and dump it to the table file
  179.   */
  180.  
  181.   info.records=info.deleted=info.copied=0;
  182.   info.handle_duplicates=duplic;
  183.   // Don't count warnings for simple inserts
  184.   if (values_list.elements > 1 || (thd->options & OPTION_WARNINGS))
  185.     thd->count_cuted_fields = 1;
  186.   thd->cuted_fields = 0L;
  187.   table->next_number_field=table->found_next_number_field;
  188.  
  189.   error=0;
  190.   id=0;
  191.   thd->proc_info="update";
  192.   while ((values = its++))
  193.   {
  194.     if (fields.elements || !value_count)
  195.     {
  196.       restore_record(table,2);            // Get empty record
  197.       if (fill_record(fields,*values) || check_null_fields(thd,table))
  198.       {
  199.     if (values_list.elements != 1)
  200.     {
  201.       info.records++;
  202.       continue;
  203.     }
  204.     error=1;
  205.     break;
  206.       }
  207.     }
  208.     else
  209.     {
  210.       if (thd->used_tables)            // Column used in values()
  211.     restore_record(table,2);        // Get empty record
  212.       else
  213.     table->record[0][0]=table->record[2][0]; // Fix delete marker
  214.       if (fill_record(table->field,*values))
  215.       {
  216.     if (values_list.elements != 1)
  217.     {
  218.       info.records++;
  219.       continue;
  220.     }
  221.     error=1;
  222.     break;
  223.       }
  224.     }
  225.     if (lock_type == TL_WRITE_DELAYED)
  226.     {
  227.       error=write_delayed(thd,table,duplic,query, thd->query_length, log_on);
  228.       query=0;
  229.     }
  230.     else
  231.       error=write_record(table,&info);
  232.     if (error)
  233.       break;
  234.     /*
  235.       If auto_increment values are used, save the first one
  236.        for LAST_INSERT_ID() and for the update log.
  237.        We can't use insert_id() as we don't want to touch the
  238.        last_insert_id_used flag.
  239.     */
  240.     if (! id && thd->insert_id_used)
  241.     {                        // Get auto increment value
  242.       id= thd->last_insert_id;
  243.     }
  244.   }
  245.   if (lock_type == TL_WRITE_DELAYED)
  246.   {
  247.     id=0;                    // No auto_increment id
  248.     info.copied=values_list.elements;
  249.     end_delayed_insert(thd);
  250.   }
  251.   else
  252.   {
  253.     if (id && values_list.elements != 1)
  254.       thd->insert_id(id);            // For update log
  255.     else if (table->next_number_field)
  256.       id=table->next_number_field->val_int();    // Return auto_increment value
  257.     if (info.copied || info.deleted)
  258.     {
  259.       mysql_update_log.write(thd, thd->query, thd->query_length);
  260.       if (mysql_bin_log.is_open())
  261.       {
  262.     Query_log_event qinfo(thd, thd->query);
  263.     mysql_bin_log.write(&qinfo);
  264.       }
  265.     }
  266.     error=ha_autocommit_or_rollback(thd,error);
  267.     if (thd->lock)
  268.     {
  269.       mysql_unlock_tables(thd, thd->lock);
  270.       thd->lock=0;
  271.     }
  272.   }
  273.   thd->proc_info="end";
  274.   table->time_stamp=save_time_stamp;        // Restore auto timestamp ptr
  275.   table->next_number_field=0;
  276.   thd->count_cuted_fields=0;
  277.   thd->next_insert_id=0;            // Reset this if wrongly used
  278.  
  279.   if (error)
  280.     goto abort;
  281.  
  282.   if (values_list.elements == 1 && (!(thd->options & OPTION_WARNINGS) ||
  283.                     !thd->cuted_fields))
  284.     send_ok(&thd->net,info.copied+info.deleted,id);
  285.   else {
  286.     char buff[160];
  287.     if (duplic == DUP_IGNORE)
  288.       sprintf(buff,ER(ER_INSERT_INFO),info.records,info.records-info.copied,
  289.           thd->cuted_fields);
  290.     else
  291.       sprintf(buff,ER(ER_INSERT_INFO),info.records,info.deleted,
  292.           thd->cuted_fields);
  293.     ::send_ok(&thd->net,info.copied+info.deleted,0L,buff);
  294.   }
  295.   DBUG_RETURN(0);
  296.  
  297. abort:
  298.   if (lock_type == TL_WRITE_DELAYED)
  299.     end_delayed_insert(thd);
  300.   DBUG_RETURN(-1);
  301. }
  302.  
  303.  
  304.     /* Check if there is more uniq keys after field */
  305.  
  306. static int last_uniq_key(TABLE *table,uint keynr)
  307. {
  308.   while (++keynr < table->keys)
  309.     if (table->key_info[keynr].flags & HA_NOSAME)
  310.       return 0;
  311.   return 1;
  312. }
  313.  
  314.  
  315. /*
  316. ** Write a record to table with optional deleting of conflicting records
  317. */
  318.  
  319.  
  320. int write_record(TABLE *table,COPY_INFO *info)
  321. {
  322.   int error;
  323.   char *key=0;
  324.  
  325.   info->records++;
  326.   if (info->handle_duplicates == DUP_REPLACE)
  327.   {
  328.     while ((error=table->file->write_row(table->record[0])))
  329.     {
  330.       if (error != HA_WRITE_SKIPP)
  331.     goto err;
  332.       uint key_nr;
  333.       if ((int) (key_nr = table->file->get_dup_key(error)) < 0)
  334.       {
  335.     error=HA_WRITE_SKIPP;            /* Database can't find key */
  336.     goto err;
  337.       }
  338.       if (table->file->option_flag() & HA_DUPP_POS)
  339.       {
  340.     if (table->file->rnd_pos(table->record[1],table->file->dupp_ref))
  341.       goto err;
  342.       }
  343.       else
  344.       {
  345.     if (table->file->extra(HA_EXTRA_FLUSH_CACHE)) /* Not neaded with NISAM */
  346.     {
  347.       error=my_errno;
  348.       goto err;
  349.     }
  350.     
  351.     if (!key)
  352.     {
  353.       if (!(key=(char*) my_safe_alloca(table->max_unique_length,
  354.                        MAX_KEY_LENGTH)))
  355.       {
  356.         error=ENOMEM;
  357.         goto err;
  358.       }
  359.     }
  360.     key_copy((byte*) key,table,key_nr,0);
  361.     if ((error=(table->file->index_read_idx(table->record[1],key_nr,
  362.                         (byte*) key,0,
  363.                         HA_READ_KEY_EXACT))))
  364.       goto err;
  365.       }
  366.       if (last_uniq_key(table,key_nr))
  367.       {
  368.     if ((error=table->file->update_row(table->record[1],table->record[0])))
  369.       goto err;
  370.     info->deleted++;
  371.     break;                    /* Update logfile and count */
  372.       }
  373.       else if ((error=table->file->delete_row(table->record[1])))
  374.     goto err;
  375.       info->deleted++;
  376.     }
  377.     info->copied++;
  378.   }
  379.   else if ((error=table->file->write_row(table->record[0])))
  380.   {
  381.     if (info->handle_duplicates != DUP_IGNORE ||
  382.     (error != HA_ERR_FOUND_DUPP_KEY && error != HA_ERR_FOUND_DUPP_UNIQUE))
  383.       goto err;
  384.   }
  385.   else
  386.     info->copied++;
  387.   if (key)
  388.     my_safe_afree(key,table->max_unique_length,MAX_KEY_LENGTH);
  389.   return 0;
  390.  
  391. err:
  392.   if (key)
  393.     my_afree(key);
  394.   table->file->print_error(error,MYF(0));
  395.   return 1;
  396. }
  397.  
  398.  
  399. /******************************************************************************
  400.     Check that all fields with arn't null_fields are used
  401.     if DONT_USE_DEFAULT_FIELDS isn't defined use default value for not
  402.     set fields.
  403. ******************************************************************************/
  404.  
  405. static int check_null_fields(THD *thd __attribute__((unused)),
  406.                  TABLE *entry __attribute__((unused)))
  407. {
  408. #ifdef DONT_USE_DEFAULT_FIELDS
  409.   for (Field **field=entry->field ; *field ; field++)
  410.   {
  411.     if ((*field)->query_id != thd->query_id && !(*field)->maybe_null() &&
  412.     *field != entry->timestamp_field &&
  413.     *field != entry->next_number_field)
  414.     {
  415.       my_printf_error(ER_BAD_NULL_ERROR, ER(ER_BAD_NULL_ERROR),MYF(0),
  416.               (*field)->field_name);
  417.       return 1;
  418.     }
  419.   }
  420. #endif
  421.   return 0;
  422. }
  423.  
  424. /*****************************************************************************
  425. ** Handling of delayed inserts
  426. **
  427. ** A thread is created for each table that one uses with the DELAYED
  428. ** attribute.
  429. *****************************************************************************/
  430.  
  431. class delayed_row :public ilink {
  432. public:
  433.   char *record,*query;
  434.   enum_duplicates dup;
  435.   time_t start_time;
  436.   bool query_start_used,last_insert_id_used,insert_id_used,log_query;
  437.   ulonglong last_insert_id;
  438.   ulong time_stamp;
  439.   uint query_length;
  440.  
  441.   delayed_row(enum_duplicates dup_arg, bool log_query_arg)
  442.     :record(0),query(0),dup(dup_arg),log_query(log_query_arg) {}
  443.   ~delayed_row()
  444.   {
  445.     x_free(record);
  446.   }
  447. };
  448.  
  449.  
  450. class delayed_insert :public ilink {
  451.   uint locks_in_memory;
  452. public:
  453.   THD thd;
  454.   TABLE *table;
  455.   pthread_mutex_t mutex;
  456.   pthread_cond_t cond,cond_client;
  457.   volatile uint tables_in_use,stacked_inserts;
  458.   volatile bool status,dead;
  459.   COPY_INFO info;
  460.   I_List<delayed_row> rows;
  461.   uint group_count;
  462.   TABLE_LIST *table_list;            // Argument
  463.  
  464.   delayed_insert()
  465.     :locks_in_memory(0),
  466.      table(0),tables_in_use(0),stacked_inserts(0), status(0), dead(0),
  467.      group_count(0)
  468.   {
  469.     thd.user=thd.host=(char*) "";
  470.     thd.current_tablenr=0;
  471.     thd.version=refresh_version;
  472.     thd.command=COM_DELAYED_INSERT;
  473.  
  474.     bzero((char*) &thd.net,sizeof(thd.net));    // Safety
  475.     thd.system_thread=1;
  476.     bzero((char*) &info,sizeof(info));
  477.     pthread_mutex_init(&mutex,NULL);
  478.     pthread_cond_init(&cond,NULL);
  479.     pthread_cond_init(&cond_client,NULL);
  480.     VOID(pthread_mutex_lock(&LOCK_thread_count));
  481.     delayed_insert_threads++;
  482.     VOID(pthread_mutex_unlock(&LOCK_thread_count));
  483.   }
  484.   ~delayed_insert()
  485.   {
  486.     /* The following is not really neaded, but just for safety */
  487.     delayed_row *row;
  488.     while ((row=rows.get()))
  489.       delete row;
  490.     pthread_mutex_destroy(&mutex);
  491.     if (table)
  492.       close_thread_tables(&thd);
  493.     VOID(pthread_mutex_lock(&LOCK_thread_count));
  494.     thd.unlink();                // Must be unlinked under lock
  495.     x_free(thd.query);
  496.     thd.user=thd.host=0;
  497.     thread_count--;
  498.     delayed_insert_threads--;
  499.     VOID(pthread_cond_broadcast(&COND_thread_count)); /* Tell main we are ready */
  500.     VOID(pthread_mutex_unlock(&LOCK_thread_count));
  501.   }
  502.  
  503.   /* The following is for checking when we can delete ourselves */
  504.   inline void lock()
  505.   {
  506.     locks_in_memory++;                // Assume LOCK_delay_insert
  507.   }
  508.   void unlock()
  509.   {
  510.     pthread_mutex_lock(&LOCK_delayed_insert);
  511.     if (!--locks_in_memory)
  512.     {
  513.       pthread_mutex_lock(&mutex);
  514.       if (thd.killed && ! stacked_inserts && ! tables_in_use)
  515.       {
  516.     pthread_cond_signal(&cond);
  517.     status=1;
  518.       }
  519.       pthread_mutex_unlock(&mutex);
  520.     }
  521.     pthread_mutex_unlock(&LOCK_delayed_insert);
  522.   }
  523.   inline uint lock_count() { return locks_in_memory; }
  524.  
  525.   TABLE* get_local_table(THD* client_thd);
  526.   bool handle_inserts(void);
  527. };
  528.  
  529.  
  530. I_List<delayed_insert> delayed_threads;
  531.  
  532.  
  533. delayed_insert *find_handler(THD *thd, TABLE_LIST *table_list)
  534. {
  535.   thd->proc_info="waiting for delay_list";
  536.   pthread_mutex_lock(&LOCK_delayed_insert);    // Protect master list
  537.   I_List_iterator<delayed_insert> it(delayed_threads);
  538.   delayed_insert *tmp;
  539.   while ((tmp=it++))
  540.   {
  541.     if (!strcmp(tmp->thd.db,table_list->db) &&
  542.     !strcmp(table_list->real_name,tmp->table->real_name))
  543.     {
  544.       tmp->lock();
  545.       break;
  546.     }
  547.   }
  548.   pthread_mutex_unlock(&LOCK_delayed_insert); // For unlink from list
  549.   return tmp;
  550. }
  551.  
  552.  
  553. static TABLE *delayed_get_table(THD *thd,TABLE_LIST *table_list)
  554. {
  555.   int error;
  556.   delayed_insert *tmp;
  557.   DBUG_ENTER("delayed_get_table");
  558.  
  559.   if (!table_list->db)
  560.     table_list->db=thd->db;
  561.  
  562.   /* no match; create a new thread to handle the table */
  563.   if (!(tmp=find_handler(thd,table_list)))
  564.   {
  565.     thd->proc_info="Creating delayed handler";
  566.     pthread_mutex_lock(&LOCK_delayed_create);
  567.     if (!(tmp=find_handler(thd,table_list)))    // Was just created
  568.     {
  569.       if (!(tmp=new delayed_insert()))
  570.       {
  571.     thd->fatal_error=1;
  572.     my_error(ER_OUTOFMEMORY,MYF(0),sizeof(delayed_insert));
  573.     pthread_mutex_unlock(&LOCK_delayed_create);
  574.     DBUG_RETURN(0);
  575.       }
  576.       pthread_mutex_lock(&LOCK_thread_count);
  577.       thread_count++;
  578.       pthread_mutex_unlock(&LOCK_thread_count);
  579.       if (!(tmp->thd.db=my_strdup(table_list->db,MYF(MY_WME))) ||
  580.       !(tmp->thd.query=my_strdup(table_list->real_name,MYF(MY_WME))))
  581.       {
  582.     delete tmp;
  583.     thd->fatal_error=1;
  584.     my_error(ER_OUT_OF_RESOURCES,MYF(0));
  585.     pthread_mutex_unlock(&LOCK_delayed_create);
  586.     DBUG_RETURN(0);
  587.       }
  588.       tmp->table_list=table_list;            // Needed to open table
  589.       tmp->lock();
  590.       pthread_mutex_lock(&tmp->mutex);
  591.       if ((error=pthread_create(&tmp->thd.real_id,&connection_attrib,
  592.                 handle_delayed_insert,(void*) tmp)))
  593.       {
  594.     DBUG_PRINT("error",
  595.            ("Can't create thread to handle delayed insert (error %d)",
  596.             error));
  597.     pthread_mutex_unlock(&tmp->mutex);
  598.     tmp->unlock();
  599.     delete tmp;
  600.     thd->fatal_error=1;
  601.     pthread_mutex_unlock(&LOCK_delayed_create);
  602.     net_printf(&thd->net,ER_CANT_CREATE_THREAD,error);
  603.     DBUG_RETURN(0);
  604.       }
  605.  
  606.       /* Wait until table is open */
  607.       thd->proc_info="waiting for handler open";
  608.       while (!tmp->thd.killed && !tmp->table && !thd->killed)
  609.       {
  610.     pthread_cond_wait(&tmp->cond_client,&tmp->mutex);
  611.       }
  612.       pthread_mutex_unlock(&tmp->mutex);
  613.       thd->proc_info="got old table";
  614.       if (tmp->thd.killed)
  615.       {
  616.     if (tmp->thd.fatal_error)
  617.     {
  618.       /* Copy error message and abort */
  619.       thd->fatal_error=1;
  620.       strmov(thd->net.last_error,tmp->thd.net.last_error);
  621.       thd->net.last_errno=thd->net.last_errno;
  622.     }
  623.     tmp->unlock();
  624.     pthread_mutex_unlock(&LOCK_delayed_create);
  625.     DBUG_RETURN(0);                // Continue with normal insert
  626.       }
  627.       if (thd->killed)
  628.       {
  629.     tmp->unlock();
  630.     pthread_mutex_unlock(&LOCK_delayed_create);
  631.     DBUG_RETURN(0);
  632.       }
  633.     }
  634.     pthread_mutex_unlock(&LOCK_delayed_create);
  635.   }
  636.  
  637.   pthread_mutex_lock(&tmp->mutex);
  638.   TABLE *table=tmp->get_local_table(thd);
  639.   pthread_mutex_unlock(&tmp->mutex);
  640.   tmp->unlock();
  641.   if (table)
  642.     thd->di=tmp;
  643.   else if (tmp->thd.fatal_error)
  644.     thd->fatal_error=1;
  645.   DBUG_RETURN((table_list->table=table));
  646. }
  647.  
  648.  
  649. /*
  650.   As we can't let many threads modify the same TABLE structure, we create
  651.   an own structure for each tread.  This includes a row buffer to save the
  652.   column values and new fields that points to the new row buffer.
  653.   The memory is allocated in the client thread and is freed automaticly.
  654. */
  655.  
  656. TABLE *delayed_insert::get_local_table(THD* client_thd)
  657. {
  658.   my_ptrdiff_t adjust_ptrs;
  659.   Field **field,**org_field;
  660.   TABLE *copy;
  661.  
  662.   /* First request insert thread to get a lock */
  663.   status=1;
  664.   tables_in_use++;
  665.   if (!thd.lock)                // Table is not locked
  666.   {
  667.     client_thd->proc_info="waiting for handler lock";
  668.     pthread_cond_signal(&cond);            // Tell handler to lock table
  669.     while (!dead && !thd.lock && ! client_thd->killed)
  670.     {
  671.       pthread_cond_wait(&cond_client,&mutex);
  672.     }
  673.     client_thd->proc_info="got handler lock";
  674.     if (client_thd->killed)
  675.       goto error;
  676.     if (dead)
  677.     {
  678.       strmov(client_thd->net.last_error,thd.net.last_error);
  679.       client_thd->net.last_errno=thd.net.last_errno;
  680.       goto error;
  681.     }
  682.   }
  683.  
  684.   client_thd->proc_info="allocating local table";
  685.   copy= (TABLE*) sql_alloc(sizeof(*copy)+
  686.                (table->fields+1)*sizeof(Field**)+
  687.                table->reclength);
  688.   if (!copy)
  689.     goto error;
  690.   *copy= *table;
  691.   bzero((char*) ©->name_hash,sizeof(copy->name_hash)); // No name hashing
  692.   /* We don't need to change the file handler here */
  693.  
  694.   field=copy->field=(Field**) (copy+1);
  695.   copy->record[0]=(byte*) (field+table->fields+1);
  696.   memcpy((char*) copy->record[0],(char*) table->record[0],table->reclength);
  697.  
  698.   /* Make a copy of all fields */
  699.  
  700.   adjust_ptrs=PTR_BYTE_DIFF(copy->record[0],table->record[0]);
  701.  
  702.   for (org_field=table->field ; *org_field ; org_field++,field++)
  703.   {
  704.     if (!(*field= (*org_field)->new_field(copy)))
  705.       return 0;
  706.     (*field)->move_field(adjust_ptrs);        // Point at copy->record[0]
  707.   }
  708.   *field=0;
  709.  
  710.   /* Adjust timestamp */
  711.   if (table->timestamp_field)
  712.   {
  713.     /* Restore offset as this may have been reset in handle_inserts */
  714.     copy->time_stamp=table->timestamp_field->offset()+1;
  715.     copy->timestamp_field=
  716.       (Field_timestamp*) copy->field[table->timestamp_field_offset];
  717.   }
  718.  
  719.   /* _rowid is not used with delayed insert */
  720.   copy->rowid_field=0;
  721.   return copy;
  722.  
  723.   /* Got fatal error */
  724.  error:
  725.   tables_in_use--;
  726.   status=1;
  727.   pthread_cond_signal(&cond);            // Inform thread about abort
  728.   return 0;
  729. }
  730.  
  731.  
  732. /* Put a question in queue */
  733.  
  734. static int write_delayed(THD *thd,TABLE *table,enum_duplicates duplic,
  735.              char *query, uint query_length, bool log_on)
  736. {
  737.   delayed_row *row=0;
  738.   delayed_insert *di=thd->di;
  739.   DBUG_ENTER("write_delayed");
  740.  
  741.   thd->proc_info="waiting for handler insert";
  742.   pthread_mutex_lock(&di->mutex);
  743.   while (di->stacked_inserts >= delayed_queue_size && !thd->killed)
  744.     pthread_cond_wait(&di->cond_client,&di->mutex);
  745.   thd->proc_info="storing row into queue";
  746.  
  747.   if (thd->killed || !(row= new delayed_row(duplic, log_on)))
  748.     goto err;
  749.  
  750.   if (!query)
  751.     query_length=0;
  752.   if (!(row->record= (char*) my_malloc(table->reclength+query_length+1,
  753.                        MYF(MY_WME))))
  754.     goto err;
  755.   memcpy(row->record,table->record[0],table->reclength);
  756.   if (query_length)
  757.   {
  758.     row->query=row->record+table->reclength;
  759.     memcpy(row->query,query,query_length+1);
  760.   }
  761.   row->query_length=        query_length;
  762.   row->start_time=        thd->start_time;
  763.   row->query_start_used=    thd->query_start_used;
  764.   row->last_insert_id_used=    thd->last_insert_id_used;
  765.   row->insert_id_used=        thd->insert_id_used;
  766.   row->last_insert_id=        thd->last_insert_id;
  767.   row->time_stamp=        table->time_stamp;
  768.  
  769.   di->rows.push_back(row);
  770.   di->stacked_inserts++;
  771.   di->status=1;
  772.   if (table->blob_fields)
  773.     unlink_blobs(table);
  774.   pthread_cond_signal(&di->cond);
  775.  
  776.   thread_safe_increment(delayed_rows_in_use,&LOCK_delayed_status);
  777.   pthread_mutex_unlock(&di->mutex);
  778.   DBUG_RETURN(0);
  779.  
  780.  err:
  781.   delete row;
  782.   pthread_mutex_unlock(&di->mutex);
  783.   DBUG_RETURN(1);
  784. }
  785.  
  786.  
  787. static void end_delayed_insert(THD *thd)
  788. {
  789.   delayed_insert *di=thd->di;
  790.   pthread_mutex_lock(&di->mutex);
  791.   if (!--di->tables_in_use || di->thd.killed)
  792.   {                        // Unlock table
  793.     di->status=1;
  794.     pthread_cond_signal(&di->cond);
  795.   }
  796.   pthread_mutex_unlock(&di->mutex);
  797. }
  798.  
  799.  
  800. /* We kill all delayed threads when doing flush-tables */
  801.  
  802. void kill_delayed_threads(void)
  803. {
  804.   VOID(pthread_mutex_lock(&LOCK_delayed_insert)); // For unlink from list
  805.  
  806.   I_List_iterator<delayed_insert> it(delayed_threads);
  807.   delayed_insert *tmp;
  808.   while ((tmp=it++))
  809.   {
  810.     pthread_mutex_lock(&tmp->mutex);
  811.     tmp->thd.killed=1;
  812.     if (tmp->thd.mysys_var)
  813.     {
  814.       pthread_mutex_lock(&tmp->thd.mysys_var->mutex);
  815.       if (tmp->thd.mysys_var->current_mutex)
  816.       {
  817.     if (&tmp->mutex != tmp->thd.mysys_var->current_mutex)
  818.       pthread_mutex_lock(tmp->thd.mysys_var->current_mutex);
  819.     pthread_cond_broadcast(tmp->thd.mysys_var->current_cond);
  820.     if (&tmp->mutex != tmp->thd.mysys_var->current_mutex)
  821.       pthread_mutex_unlock(tmp->thd.mysys_var->current_mutex);
  822.       }
  823.       pthread_mutex_unlock(&tmp->thd.mysys_var->mutex);
  824.     }
  825.     pthread_mutex_unlock(&tmp->mutex);
  826.   }
  827.   VOID(pthread_mutex_unlock(&LOCK_delayed_insert)); // For unlink from list
  828. }
  829.  
  830.  
  831. /*
  832.  * Create a new delayed insert thread
  833. */
  834.  
  835. static pthread_handler_decl(handle_delayed_insert,arg)
  836. {
  837.   delayed_insert *di=(delayed_insert*) arg;
  838.   THD *thd= &di->thd;
  839.  
  840.   pthread_detach_this_thread();
  841.   /* Add thread to THD list so that's it's visible in 'show processlist' */
  842.   pthread_mutex_lock(&LOCK_thread_count);
  843.   thd->thread_id=thread_id++;
  844.   threads.append(thd);
  845.   pthread_mutex_unlock(&LOCK_thread_count);
  846.  
  847.   pthread_mutex_lock(&di->mutex);
  848. #ifndef __WIN__    /* Win32 calls this in pthread_create */
  849.   if (my_thread_init())
  850.   {
  851.     strmov(thd->net.last_error,ER(thd->net.last_errno=ER_OUT_OF_RESOURCES));
  852.     goto end;
  853.   }
  854. #endif
  855.  
  856.   DBUG_ENTER("handle_delayed_insert");
  857.   if (init_thr_lock() ||
  858.       my_pthread_setspecific_ptr(THR_THD,  thd) ||
  859.       my_pthread_setspecific_ptr(THR_NET,  &thd->net))
  860.   {
  861.     strmov(thd->net.last_error,ER(thd->net.last_errno=ER_OUT_OF_RESOURCES));
  862.     goto end;
  863.   }
  864.   thd->mysys_var=my_thread_var;
  865.   thd->dbug_thread_id=my_thread_id();
  866. #ifndef __WIN__
  867.   sigset_t set;
  868.   VOID(sigemptyset(&set));            // Get mask in use
  869.   VOID(pthread_sigmask(SIG_UNBLOCK,&set,&thd->block_signals));
  870. #endif
  871.  
  872.   /* open table */
  873.  
  874.   if (!(di->table=open_ltable(thd,di->table_list,TL_WRITE_DELAYED)))
  875.   {
  876.     thd->fatal_error=1;                // Abort waiting inserts
  877.     goto end;
  878.   }
  879.   di->table->copy_blobs=1;
  880.  
  881.   /* One can now use this */
  882.   pthread_mutex_lock(&LOCK_delayed_insert);
  883.   delayed_threads.append(di);
  884.   pthread_mutex_unlock(&LOCK_delayed_insert);
  885.  
  886.   /* Tell client that the thread is initialized */
  887.   pthread_cond_signal(&di->cond_client);
  888.  
  889.   /* Now wait until we get an insert or lock to handle */
  890.   /* We will not abort as long as a client thread uses this thread */
  891.  
  892.   for (;;)
  893.   {
  894.     if (thd->killed)
  895.     {
  896.       uint lock_count;
  897.       /*
  898.     Remove this from delay insert list so that no one can request a
  899.     table from this
  900.       */
  901.       pthread_mutex_unlock(&di->mutex);
  902.       pthread_mutex_lock(&LOCK_delayed_insert);
  903.       di->unlink();
  904.       lock_count=di->lock_count();
  905.       pthread_mutex_unlock(&LOCK_delayed_insert);
  906.       pthread_mutex_lock(&di->mutex);
  907.       if (!lock_count && !di->tables_in_use && !di->stacked_inserts)
  908.     break;                    // Time to die
  909.     }
  910.  
  911.     if (!di->status && !di->stacked_inserts)
  912.     {
  913.       struct timespec abstime;
  914. #if defined(HAVE_TIMESPEC_TS_SEC)
  915.       abstime.ts_sec=time((time_t*) 0)+(time_t) delayed_insert_timeout;
  916.       abstime.ts_nsec=0;
  917. #elif defined(__WIN__)
  918.       abstime.tv_sec=time((time_t*) 0)+(time_t) delayed_insert_timeout;
  919.       abstime.tv_nsec=0;
  920. #else
  921.       struct timeval tv;
  922.       gettimeofday(&tv,0);
  923.       abstime.tv_sec=tv.tv_sec+(time_t) delayed_insert_timeout;
  924.       abstime.tv_nsec=tv.tv_usec*1000;
  925. #endif
  926.  
  927.       /* Information for pthread_kill */
  928.       pthread_mutex_lock(&di->thd.mysys_var->mutex);
  929.       di->thd.mysys_var->current_mutex= &di->mutex;
  930.       di->thd.mysys_var->current_cond= &di->cond;
  931.       pthread_mutex_unlock(&di->thd.mysys_var->mutex);
  932.       di->thd.proc_info=0;
  933.  
  934.       for ( ; ;)
  935.       {
  936.     int error;
  937. #if (defined(HAVE_BROKEN_COND_TIMEDWAIT) || defined(HAVE_LINUXTHREADS))
  938.     error=pthread_cond_wait(&di->cond,&di->mutex);
  939. #else
  940.     error=pthread_cond_timedwait(&di->cond,&di->mutex,&abstime);
  941. #ifdef EXTRA_DEBUG
  942.     if (error && error != EINTR)
  943.     {
  944.       fprintf(stderr, "Got error %d from pthread_cond_timedwait\n",error);
  945.       DBUG_PRINT("error",("Got error %d from pthread_cond_timedwait",
  946.                   error));
  947.     }
  948. #endif
  949. #endif
  950.     if (thd->killed || di->status)
  951.       break;
  952.     if (error == ETIME || error == ETIMEDOUT)
  953.     {
  954.       thd->killed=1;
  955.       break;
  956.     }
  957.       }
  958.       pthread_mutex_lock(&di->thd.mysys_var->mutex);
  959.       di->thd.mysys_var->current_mutex= 0;
  960.       di->thd.mysys_var->current_cond= 0;
  961.       pthread_mutex_unlock(&di->thd.mysys_var->mutex);
  962.     }
  963.  
  964.     if (di->tables_in_use && ! thd->lock)
  965.     {
  966.       /* request for new delayed insert */
  967.       if (!(thd->lock=mysql_lock_tables(thd,&di->table,1)))
  968.       {
  969.     di->dead=thd->killed=1;            // Fatal error
  970.       }
  971.       pthread_cond_broadcast(&di->cond_client);
  972.     }
  973.     if (di->stacked_inserts)
  974.     {
  975.       if (di->handle_inserts())
  976.       {
  977.     di->dead=thd->killed=1;            // Some fatal error
  978.       }
  979.     }
  980.     di->status=0;
  981.     if (!di->stacked_inserts && !di->tables_in_use && thd->lock)
  982.     {
  983.       /* No one is doing a insert delayed;
  984.      Unlock it so that other threads can use it */
  985.       MYSQL_LOCK *lock=thd->lock;
  986.       thd->lock=0;
  987.       pthread_mutex_unlock(&di->mutex);
  988.       mysql_unlock_tables(thd, lock);
  989.       di->group_count=0;
  990.       pthread_mutex_lock(&di->mutex);
  991.     }
  992.     if (di->tables_in_use)
  993.       pthread_cond_broadcast(&di->cond_client); // If waiting clients
  994.   }
  995.  
  996. end:
  997.   /*
  998.     di should be unlinked from the thread handler list and have no active
  999.     clients
  1000.   */
  1001.  
  1002.   close_thread_tables(thd);            // Free the table
  1003.   di->table=0;
  1004.   di->dead=thd->killed=1;            // If error
  1005.   pthread_cond_broadcast(&di->cond_client);    // Safety
  1006.   pthread_mutex_unlock(&di->mutex);
  1007.  
  1008.   pthread_mutex_lock(&LOCK_delayed_create);    // Because of delayed_get_table
  1009.   pthread_mutex_lock(&LOCK_delayed_insert);    
  1010.   delete di;
  1011.   pthread_mutex_unlock(&LOCK_delayed_insert);
  1012.   pthread_mutex_unlock(&LOCK_delayed_create);  
  1013.  
  1014.   my_thread_end();
  1015.   pthread_exit(0);
  1016.   DBUG_RETURN(0);
  1017. }
  1018.  
  1019.  
  1020. /* Remove pointers from temporary fields to allocated values */
  1021.  
  1022. static void unlink_blobs(register TABLE *table)
  1023. {
  1024.   for (Field **ptr=table->field ; *ptr ; ptr++)
  1025.   {
  1026.     if ((*ptr)->flags & BLOB_FLAG)
  1027.       ((Field_blob *) (*ptr))->clear_temporary();
  1028.   }
  1029. }
  1030.  
  1031. /* Free blobs stored in current row */
  1032.  
  1033. static void free_delayed_insert_blobs(register TABLE *table)
  1034. {
  1035.   for (Field **ptr=table->field ; *ptr ; ptr++)
  1036.   {
  1037.     if ((*ptr)->flags & BLOB_FLAG)
  1038.     {
  1039.       char *str;
  1040.       ((Field_blob *) (*ptr))->get_ptr(&str);
  1041.       my_free(str,MYF(MY_ALLOW_ZERO_PTR));
  1042.       ((Field_blob *) (*ptr))->reset();
  1043.     }
  1044.   }
  1045. }
  1046.  
  1047.  
  1048. bool delayed_insert::handle_inserts(void)
  1049. {
  1050.   int error;
  1051.   uint max_rows;
  1052.   DBUG_ENTER("handle_inserts");
  1053.  
  1054.   /* Allow client to insert new rows */
  1055.   pthread_mutex_unlock(&mutex);
  1056.  
  1057.   table->next_number_field=table->found_next_number_field;
  1058.  
  1059.   thd.proc_info="upgrading lock";
  1060.   if (thr_upgrade_write_delay_lock(*thd.lock->locks))
  1061.   {
  1062.     /* This can only happen if thread is killed by shutdown */
  1063.     sql_print_error(ER(ER_DELAYED_CANT_CHANGE_LOCK),table->real_name);
  1064.     goto err;
  1065.   }
  1066.  
  1067.   thd.proc_info="insert";
  1068.   max_rows=delayed_insert_limit;
  1069.   if (thd.killed || table->version != refresh_version)
  1070.   {
  1071.     thd.killed=1;
  1072.     max_rows= ~0;                // Do as much as possible
  1073.   }
  1074.  
  1075.   table->file->extra(HA_EXTRA_WRITE_CACHE);
  1076.   pthread_mutex_lock(&mutex);
  1077.   delayed_row *row;
  1078.   while ((row=rows.get()))
  1079.   {
  1080.     stacked_inserts--;
  1081.     pthread_mutex_unlock(&mutex);
  1082.     memcpy(table->record[0],row->record,table->reclength);
  1083.  
  1084.     thd.start_time=row->start_time;
  1085.     thd.query_start_used=row->query_start_used;
  1086.     thd.last_insert_id=row->last_insert_id;
  1087.     thd.last_insert_id_used=row->last_insert_id_used;
  1088.     thd.insert_id_used=row->insert_id_used;
  1089.     table->time_stamp=row->time_stamp;
  1090.  
  1091.     info.handle_duplicates= row->dup;
  1092.     thd.net.last_errno = 0; // reset error for binlog
  1093.     if (write_record(table,&info))
  1094.     {
  1095.       info.error++;                // Ignore errors
  1096.       pthread_mutex_lock(&LOCK_delayed_status);
  1097.       delayed_insert_errors++;
  1098.       pthread_mutex_unlock(&LOCK_delayed_status);
  1099.       row->log_query = 0;
  1100.     }
  1101.     if (row->query && row->log_query)
  1102.     {
  1103.       mysql_update_log.write(&thd,row->query, row->query_length);
  1104.       if (mysql_bin_log.is_open())
  1105.       {
  1106.     thd.query_length = row->query_length;
  1107.     Query_log_event qinfo(&thd, row->query);
  1108.     mysql_bin_log.write(&qinfo);
  1109.       }
  1110.     }
  1111.     if (table->blob_fields)
  1112.       free_delayed_insert_blobs(table);
  1113.     thread_safe_sub(delayed_rows_in_use,1,&LOCK_delayed_status);
  1114.     thread_safe_increment(delayed_insert_writes,&LOCK_delayed_status);
  1115.     pthread_mutex_lock(&mutex);
  1116.  
  1117.     delete row;
  1118.     /* Let READ clients do something once in a while */
  1119.     if (group_count++ == max_rows)
  1120.     {
  1121.       group_count=0;
  1122.       if (stacked_inserts || tables_in_use)    // Let these wait a while
  1123.       {
  1124.     if (tables_in_use)
  1125.       pthread_cond_broadcast(&cond_client); // If waiting clients
  1126.     thd.proc_info="reschedule";
  1127.     pthread_mutex_unlock(&mutex);
  1128.     if ((error=table->file->extra(HA_EXTRA_NO_CACHE)))
  1129.     {
  1130.       /* This should never happen */
  1131.       table->file->print_error(error,MYF(0));
  1132.       sql_print_error("%s",thd.net.last_error);
  1133.       goto err;
  1134.     }
  1135.     if (thr_reschedule_write_lock(*thd.lock->locks))
  1136.     {
  1137.       /* This should never happen */
  1138.       sql_print_error(ER(ER_DELAYED_CANT_CHANGE_LOCK),table->real_name);
  1139.     }
  1140.     table->file->extra(HA_EXTRA_WRITE_CACHE);
  1141.     pthread_mutex_lock(&mutex);
  1142.     thd.proc_info="insert";
  1143.       }
  1144.       if (tables_in_use)
  1145.     pthread_cond_broadcast(&cond_client);    // If waiting clients
  1146.     }
  1147.   }
  1148.  
  1149.   thd.proc_info=0;
  1150.   table->next_number_field=0;
  1151.   pthread_mutex_unlock(&mutex);
  1152.   if ((error=table->file->extra(HA_EXTRA_NO_CACHE)))
  1153.   {                        // This shouldn't happen
  1154.     table->file->print_error(error,MYF(0));
  1155.     sql_print_error("%s",thd.net.last_error);
  1156.     goto err;
  1157.   }
  1158.   pthread_mutex_lock(&mutex);
  1159.   DBUG_RETURN(0);
  1160.  
  1161.  err:
  1162.   thread_safe_increment(delayed_insert_errors, &LOCK_delayed_status);
  1163.   pthread_mutex_lock(&mutex);
  1164.   DBUG_RETURN(1);
  1165. }
  1166.  
  1167.  
  1168.  
  1169. /***************************************************************************
  1170. ** store records in INSERT ... SELECT *
  1171. ***************************************************************************/
  1172.  
  1173. int
  1174. select_insert::prepare(List<Item> &values)
  1175. {
  1176.   DBUG_ENTER("select_insert::prepare");
  1177.  
  1178.   save_time_stamp=table->time_stamp;
  1179.   if (check_insert_fields(thd,table,*fields,values,1))
  1180.     DBUG_RETURN(1);
  1181.  
  1182.   restore_record(table,2);            // Get empty record
  1183.   table->next_number_field=table->found_next_number_field;
  1184.   thd->count_cuted_fields=1;            /* calc cuted fields */
  1185.   thd->cuted_fields=0;
  1186.   if (info.handle_duplicates != DUP_REPLACE)
  1187.     table->file->extra(HA_EXTRA_WRITE_CACHE);
  1188.   table->file->deactivate_non_unique_index((ha_rows) 0);
  1189.   DBUG_RETURN(0);
  1190. }
  1191.  
  1192. select_insert::~select_insert()
  1193. {
  1194.   if (table)
  1195.   {
  1196.     if (save_time_stamp)
  1197.       table->time_stamp=save_time_stamp;
  1198.     table->next_number_field=0;
  1199.   }
  1200.   thd->count_cuted_fields=0;
  1201. }
  1202.  
  1203.  
  1204. bool select_insert::send_data(List<Item> &values)
  1205. {
  1206.   if (thd->offset_limit)
  1207.   {                        // using limit offset,count
  1208.     thd->offset_limit--;
  1209.     return 0;
  1210.   }
  1211.   if (fields->elements)
  1212.     fill_record(*fields,values);
  1213.   else
  1214.     fill_record(table->field,values);
  1215.   if (write_record(table,&info))
  1216.     return 1;
  1217.   if (table->next_number_field)        // Clear for next record
  1218.   {
  1219.     table->next_number_field->reset();
  1220.     if (! last_insert_id && thd->insert_id_used)
  1221.       last_insert_id=thd->insert_id();
  1222.   }
  1223.   return 0;
  1224. }
  1225.  
  1226.  
  1227. void select_insert::send_error(uint errcode,const char *err)
  1228. {
  1229.   ::send_error(&thd->net,errcode,err);
  1230.   table->file->extra(HA_EXTRA_NO_CACHE);
  1231.   table->file->activate_all_index(thd);
  1232.   ha_rollback(thd);
  1233. }
  1234.  
  1235.  
  1236. bool select_insert::send_eof()
  1237. {
  1238.   int error,error2;
  1239.   if (!(error=table->file->extra(HA_EXTRA_NO_CACHE)))
  1240.     error=table->file->activate_all_index(thd);
  1241.   if ((error2=ha_autocommit_or_rollback(thd,error)) && ! error)
  1242.     error=error2;
  1243.  
  1244.   if (error)
  1245.   {
  1246.     table->file->print_error(error,MYF(0));
  1247.     ::send_error(&thd->net);
  1248.     return 1;
  1249.   }
  1250.   else
  1251.   {
  1252.     char buff[160];
  1253.     if (info.handle_duplicates == DUP_IGNORE)
  1254.       sprintf(buff,ER(ER_INSERT_INFO),info.records,info.records-info.copied,
  1255.           thd->cuted_fields);
  1256.     else
  1257.       sprintf(buff,ER(ER_INSERT_INFO),info.records,info.deleted,
  1258.           thd->cuted_fields);
  1259.     if (last_insert_id)
  1260.       thd->insert_id(last_insert_id);        // For update log
  1261.     ::send_ok(&thd->net,info.copied,last_insert_id,buff);
  1262.     mysql_update_log.write(thd,thd->query,thd->query_length);
  1263.     if (mysql_bin_log.is_open())
  1264.     {
  1265.       Query_log_event qinfo(thd, thd->query);
  1266.       mysql_bin_log.write(&qinfo);
  1267.     }
  1268.     return 0;
  1269.   }
  1270. }
  1271.  
  1272.  
  1273. /***************************************************************************
  1274. ** CREATE TABLE (SELECT) ...
  1275. ***************************************************************************/
  1276.  
  1277. int
  1278. select_create::prepare(List<Item> &values)
  1279. {
  1280.   DBUG_ENTER("select_create::prepare");
  1281.  
  1282.   table=create_table_from_items(thd, create_info, db, name,
  1283.                 extra_fields, keys, &values, &lock);
  1284.   if (!table)
  1285.     DBUG_RETURN(-1);                // abort() deletes table
  1286.  
  1287.   /* First field to copy */
  1288.   field=table->field+table->fields - values.elements;
  1289.  
  1290.   save_time_stamp=table->time_stamp;
  1291.   if (table->timestamp_field)            // Don't set timestamp if used
  1292.   {
  1293.     table->timestamp_field->set_time();
  1294.     table->time_stamp=0;            // This should be saved
  1295.   }
  1296.   table->next_number_field=table->found_next_number_field;
  1297.  
  1298.   restore_record(table,2);            // Get empty record
  1299.   thd->count_cuted_fields=1;            // count warnings
  1300.   thd->cuted_fields=0;
  1301.   DBUG_RETURN(0);
  1302. }
  1303.  
  1304.  
  1305. bool select_create::send_data(List<Item> &values)
  1306. {
  1307.   if (thd->offset_limit)
  1308.   {                        // using limit offset,count
  1309.     thd->offset_limit--;
  1310.     return 0;
  1311.   }
  1312.   fill_record(field,values);
  1313.   if (write_record(table,&info))
  1314.     return 1;
  1315.   if (table->next_number_field)        // Clear for next record
  1316.   {
  1317.     table->next_number_field->reset();
  1318.     if (! last_insert_id && thd->insert_id_used)
  1319.       last_insert_id=thd->insert_id();
  1320.   }
  1321.   return 0;
  1322. }
  1323.  
  1324. extern HASH open_cache;
  1325.  
  1326. bool select_create::send_eof()
  1327. {
  1328.   bool tmp=select_insert::send_eof();
  1329.   if (tmp)
  1330.     abort();
  1331.   else
  1332.   {
  1333.     VOID(pthread_mutex_lock(&LOCK_open));
  1334.     mysql_unlock_tables(thd, lock);
  1335.     if (!table->tmp_table)
  1336.       hash_delete(&open_cache,(byte*) table);
  1337.     lock=0; table=0;
  1338.     VOID(pthread_mutex_unlock(&LOCK_open));
  1339.   }
  1340.   return tmp;
  1341. }
  1342.  
  1343. void select_create::abort()
  1344. {
  1345.   VOID(pthread_mutex_lock(&LOCK_open));
  1346.   if (lock)
  1347.   {
  1348.     mysql_unlock_tables(thd, lock);
  1349.     lock=0;
  1350.   }
  1351.   if (table)
  1352.   {
  1353.     enum db_type table_type=table->db_type;
  1354.     if (!table->tmp_table)
  1355.       hash_delete(&open_cache,(byte*) table);
  1356.     quick_rm_table(table_type,db,name);
  1357.     table=0;
  1358.   }
  1359.   VOID(pthread_mutex_unlock(&LOCK_open));
  1360. }
  1361.  
  1362.  
  1363. /*****************************************************************************
  1364. ** Instansiate templates
  1365. *****************************************************************************/
  1366.  
  1367. #ifdef __GNUC__
  1368. template class List_iterator<List_item>;
  1369. template class I_List<delayed_insert>;
  1370. template class I_List_iterator<delayed_insert>;
  1371. template class I_List<delayed_row>;
  1372. #endif
  1373.