← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to drizzled/sql_insert.cc

  • Committer: Brian Aker
  • Date: 2008-10-12 01:59:02 UTC
  • Revision ID: brian@tangent.org-20081012015902-prhy6wsimdqr28om
Dead code around unsigned (first pass)

Show diffs side-by-side

added added

removed removed

Lines of Context:
drizzled/sql_insert.cc
11
11
 
12
12
   You should have received a copy of the GNU General Public License
13
13
   along with this program; if not, write to the Free Software
14
 
   Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA */
 
14
   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA */
15
15
 
16
16
 
17
17
/* Insert of records */
18
18
 
19
 
#include "config.h"
20
 
#include <cstdio>
 
19
/*
 
20
  INSERT DELAYED
 
21
 
 
22
  Drizzle has a different form of DELAYED then MySQL. DELAYED is just
 
23
  a hint to the the sorage engine (which can then do whatever it likes.
 
24
*/
 
25
#include <drizzled/server_includes.h>
21
26
#include <drizzled/sql_select.h>
22
 
#include <drizzled/show.h>
23
 
#include <drizzled/error.h>
24
 
#include <drizzled/name_resolution_context_state.h>
25
 
#include <drizzled/probes.h>
26
 
#include <drizzled/sql_base.h>
27
 
#include <drizzled/sql_load.h>
28
 
#include <drizzled/field/timestamp.h>
29
 
#include <drizzled/lock.h>
30
 
#include "drizzled/sql_table.h"
31
 
#include "drizzled/pthread_globals.h"
32
 
#include "drizzled/transaction_services.h"
33
 
#include "drizzled/plugin/transactional_storage_engine.h"
34
 
 
35
 
#include "drizzled/table/shell.h"
36
 
 
37
 
namespace drizzled
38
 
{
39
 
 
40
 
extern plugin::StorageEngine *heap_engine;
41
 
extern plugin::StorageEngine *myisam_engine;
 
27
#include <drizzled/sql_show.h>
 
28
#include "rpl_mi.h"
 
29
#include <drizzled/drizzled_error_messages.h>
 
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) : malloc(size))
 
38
#define my_safe_afree(ptr, size, min_length) if (size > min_length) free(ptr)
 
39
#endif
 
40
 
 
41
 
42
42
 
43
43
/*
44
44
  Check if insert fields are correct.
45
45
 
46
46
  SYNOPSIS
47
47
    check_insert_fields()
48
 
    session                         The current thread.
 
48
    thd                         The current thread.
49
49
    table                       The table for insert.
50
50
    fields                      The insert fields.
51
51
    values                      The insert values.
61
61
    -1          Error
62
62
*/
63
63
 
64
 
static int check_insert_fields(Session *session, TableList *table_list,
 
64
static int check_insert_fields(THD *thd, TableList *table_list,
65
65
                               List<Item> &fields, List<Item> &values,
66
66
                               bool check_unique,
67
 
                               table_map *)
 
67
                               table_map *map __attribute__((unused)))
68
68
{
69
69
  Table *table= table_list->table;
70
70
 
71
71
  if (fields.elements == 0 && values.elements != 0)
72
72
  {
73
 
    if (values.elements != table->getShare()->sizeFields())
 
73
    if (values.elements != table->s->fields)
74
74
    {
75
75
      my_error(ER_WRONG_VALUE_COUNT_ON_ROW, MYF(0), 1L);
76
76
      return -1;
81
81
      No fields are provided so all fields must be provided in the values.
82
82
      Thus we set all bits in the write set.
83
83
    */
84
 
    table->setWriteSet();
 
84
    bitmap_set_all(table->write_set);
85
85
  }
86
86
  else
87
87
  {                                             // Part field list
88
 
    Select_Lex *select_lex= &session->lex->select_lex;
 
88
    SELECT_LEX *select_lex= &thd->lex->select_lex;
89
89
    Name_resolution_context *context= &select_lex->context;
90
90
    Name_resolution_context_state ctx_state;
91
91
    int res;
96
96
      return -1;
97
97
    }
98
98
 
99
 
    session->dup_field= 0;
 
99
    thd->dup_field= 0;
100
100
 
101
101
    /* Save the state of the current name resolution context. */
102
102
    ctx_state.save_state(context, table_list);
107
107
    */
108
108
    table_list->next_local= 0;
109
109
    context->resolve_in_table_list_only(table_list);
110
 
    res= setup_fields(session, 0, fields, MARK_COLUMNS_WRITE, 0, 0);
 
110
    res= setup_fields(thd, 0, fields, MARK_COLUMNS_WRITE, 0, 0);
111
111
 
112
112
    /* Restore the current context. */
113
113
    ctx_state.restore_state(context, table_list);
115
115
    if (res)
116
116
      return -1;
117
117
 
118
 
    if (check_unique && session->dup_field)
 
118
    if (check_unique && thd->dup_field)
119
119
    {
120
 
      my_error(ER_FIELD_SPECIFIED_TWICE, MYF(0), session->dup_field->field_name);
 
120
      my_error(ER_FIELD_SPECIFIED_TWICE, MYF(0), thd->dup_field->field_name);
121
121
      return -1;
122
122
    }
123
123
    if (table->timestamp_field) // Don't automaticly set timestamp if used
124
124
    {
125
 
      if (table->timestamp_field->isWriteSet())
126
 
      {
 
125
      if (bitmap_is_set(table->write_set,
 
126
                        table->timestamp_field->field_index))
127
127
        clear_timestamp_auto_bits(table->timestamp_field_type,
128
128
                                  TIMESTAMP_AUTO_SET_ON_INSERT);
129
 
      }
130
129
      else
131
130
      {
132
 
        table->setWriteSet(table->timestamp_field->position());
 
131
        bitmap_set_bit(table->write_set,
 
132
                       table->timestamp_field->field_index);
133
133
      }
134
134
    }
135
135
  }
143
143
 
144
144
  SYNOPSIS
145
145
    check_update_fields()
146
 
    session                         The current thread.
 
146
    thd                         The current thread.
147
147
    insert_table_list           The insert table list.
148
148
    table                       The table for update.
149
149
    update_fields               The update fields.
157
157
    -1          Error
158
158
*/
159
159
 
160
 
static int check_update_fields(Session *session, TableList *insert_table_list,
 
160
static int check_update_fields(THD *thd, TableList *insert_table_list,
161
161
                               List<Item> &update_fields,
162
 
                               table_map *)
 
162
                               table_map *map __attribute__((unused)))
163
163
{
164
164
  Table *table= insert_table_list->table;
165
165
  bool timestamp_mark= false;
170
170
      Unmark the timestamp field so that we can check if this is modified
171
171
      by update_fields
172
172
    */
173
 
    timestamp_mark= table->write_set->test(table->timestamp_field->position());
174
 
    table->write_set->reset(table->timestamp_field->position());
 
173
    timestamp_mark= bitmap_test_and_clear(table->write_set,
 
174
                                          table->timestamp_field->field_index);
175
175
  }
176
176
 
177
177
  /* Check the fields we are going to modify */
178
 
  if (setup_fields(session, 0, update_fields, MARK_COLUMNS_WRITE, 0, 0))
 
178
  if (setup_fields(thd, 0, update_fields, MARK_COLUMNS_WRITE, 0, 0))
179
179
    return -1;
180
180
 
181
181
  if (table->timestamp_field)
182
182
  {
183
183
    /* Don't set timestamp column if this is modified. */
184
 
    if (table->timestamp_field->isWriteSet())
185
 
    {
 
184
    if (bitmap_is_set(table->write_set,
 
185
                      table->timestamp_field->field_index))
186
186
      clear_timestamp_auto_bits(table->timestamp_field_type,
187
187
                                TIMESTAMP_AUTO_SET_ON_UPDATE);
188
 
    }
189
 
 
190
188
    if (timestamp_mark)
191
 
    {
192
 
      table->setWriteSet(table->timestamp_field->position());
193
 
    }
 
189
      bitmap_set_bit(table->write_set,
 
190
                     table->timestamp_field->field_index);
194
191
  }
195
192
  return 0;
196
193
}
205
202
*/
206
203
 
207
204
static
208
 
void upgrade_lock_type(Session *,
 
205
void upgrade_lock_type(THD *thd __attribute__((unused)),
209
206
                       thr_lock_type *lock_type,
210
207
                       enum_duplicates duplic,
211
 
                       bool )
 
208
                       bool is_multi_insert __attribute__((unused)))
212
209
{
213
210
  if (duplic == DUP_UPDATE ||
214
211
      (duplic == DUP_REPLACE && *lock_type == TL_WRITE_CONCURRENT_INSERT))
227
224
  end of dispatch_command().
228
225
*/
229
226
 
230
 
bool mysql_insert(Session *session,TableList *table_list,
 
227
bool mysql_insert(THD *thd,TableList *table_list,
231
228
                  List<Item> &fields,
232
229
                  List<List_item> &values_list,
233
230
                  List<Item> &update_fields,
238
235
  int error;
239
236
  bool transactional_table, joins_freed= false;
240
237
  bool changed;
 
238
  bool was_insert_delayed= (table_list->lock_type ==  TL_WRITE_DELAYED);
241
239
  uint32_t value_count;
242
240
  ulong counter = 1;
243
241
  uint64_t id;
244
 
  CopyInfo info;
 
242
  COPY_INFO info;
245
243
  Table *table= 0;
246
244
  List_iterator_fast<List_item> its(values_list);
247
245
  List_item *values;
249
247
  Name_resolution_context_state ctx_state;
250
248
  thr_lock_type lock_type;
251
249
  Item *unused_conds= 0;
252
 
 
 
250
  
253
251
 
254
252
  /*
255
253
    Upgrade lock type if the requested lock is incompatible with
256
254
    the current connection mode or table operation.
257
255
  */
258
 
  upgrade_lock_type(session, &table_list->lock_type, duplic,
 
256
  upgrade_lock_type(thd, &table_list->lock_type, duplic,
259
257
                    values_list.elements > 1);
260
258
 
261
 
  if (session->openTablesLock(table_list))
 
259
  /*
 
260
    We can't write-delayed into a table locked with LOCK TABLES:
 
261
    this will lead to a deadlock, since the delayed thread will
 
262
    never be able to get a lock on the table. QQQ: why not
 
263
    upgrade the lock here instead?
 
264
  */
 
265
  if (table_list->lock_type == TL_WRITE_DELAYED && thd->locked_tables &&
 
266
      find_locked_table(thd, table_list->db, table_list->table_name))
262
267
  {
263
 
    DRIZZLE_INSERT_DONE(1, 0);
264
 
    return true;
 
268
    my_error(ER_DELAYED_INSERT_TABLE_LOCKED, MYF(0),
 
269
             table_list->table_name);
 
270
    return(true);
265
271
  }
266
272
 
 
273
  {
 
274
    if (open_and_lock_tables(thd, table_list))
 
275
      return(true);
 
276
  }
267
277
  lock_type= table_list->lock_type;
268
278
 
269
 
  session->set_proc_info("init");
270
 
  session->used_tables=0;
 
279
  thd->set_proc_info("init");
 
280
  thd->used_tables=0;
271
281
  values= its++;
272
282
  value_count= values->elements;
273
283
 
274
 
  if (mysql_prepare_insert(session, table_list, table, fields, values,
 
284
  if (mysql_prepare_insert(thd, table_list, table, fields, values,
275
285
                           update_fields, update_values, duplic, &unused_conds,
276
286
                           false,
277
287
                           (fields.elements || !value_count ||
278
288
                            (0) != 0), !ignore))
279
 
  {
280
 
    if (table != NULL)
281
 
      table->cursor->ha_release_auto_increment();
282
 
    if (!joins_freed)
283
 
      free_underlaid_joins(session, &session->lex->select_lex);
284
 
    session->abort_on_warning= 0;
285
 
    DRIZZLE_INSERT_DONE(1, 0);
286
 
    return true;
287
 
  }
 
289
    goto abort;
288
290
 
289
291
  /* mysql_prepare_insert set table_list->table if it was not set */
290
292
  table= table_list->table;
291
293
 
292
 
  context= &session->lex->select_lex.context;
 
294
  context= &thd->lex->select_lex.context;
293
295
  /*
294
296
    These three asserts test the hypothesis that the resetting of the name
295
297
    resolution context below is not necessary at all since the list of local
315
317
    if (values->elements != value_count)
316
318
    {
317
319
      my_error(ER_WRONG_VALUE_COUNT_ON_ROW, MYF(0), counter);
318
 
 
319
 
      if (table != NULL)
320
 
        table->cursor->ha_release_auto_increment();
321
 
      if (!joins_freed)
322
 
        free_underlaid_joins(session, &session->lex->select_lex);
323
 
      session->abort_on_warning= 0;
324
 
      DRIZZLE_INSERT_DONE(1, 0);
325
 
 
326
 
      return true;
327
 
    }
328
 
    if (setup_fields(session, 0, *values, MARK_COLUMNS_READ, 0, 0))
329
 
    {
330
 
      if (table != NULL)
331
 
        table->cursor->ha_release_auto_increment();
332
 
      if (!joins_freed)
333
 
        free_underlaid_joins(session, &session->lex->select_lex);
334
 
      session->abort_on_warning= 0;
335
 
      DRIZZLE_INSERT_DONE(1, 0);
336
 
      return true;
337
 
    }
 
320
      goto abort;
 
321
    }
 
322
    if (setup_fields(thd, 0, *values, MARK_COLUMNS_READ, 0, 0))
 
323
      goto abort;
338
324
  }
339
325
  its.rewind ();
340
 
 
 
326
 
341
327
  /* Restore the current context. */
342
328
  ctx_state.restore_state(context, table_list);
343
329
 
344
330
  /*
345
 
    Fill in the given fields and dump it to the table cursor
 
331
    Fill in the given fields and dump it to the table file
346
332
  */
 
333
  memset(&info, 0, sizeof(info));
347
334
  info.ignore= ignore;
348
335
  info.handle_duplicates=duplic;
349
336
  info.update_fields= &update_fields;
354
341
    For single line insert, generate an error if try to set a NOT NULL field
355
342
    to NULL.
356
343
  */
357
 
  session->count_cuted_fields= ignore ? CHECK_FIELD_WARN : CHECK_FIELD_ERROR_FOR_NULL;
358
 
 
359
 
  session->cuted_fields = 0L;
 
344
  thd->count_cuted_fields= ((values_list.elements == 1 &&
 
345
                             !ignore) ?
 
346
                            CHECK_FIELD_ERROR_FOR_NULL :
 
347
                            CHECK_FIELD_WARN);
 
348
  thd->cuted_fields = 0L;
360
349
  table->next_number_field=table->found_next_number_field;
361
350
 
 
351
  if (thd->slave_thread &&
 
352
      (info.handle_duplicates == DUP_UPDATE) &&
 
353
      (table->next_number_field != NULL) &&
 
354
      rpl_master_has_bug(&active_mi->rli, 24432))
 
355
    goto abort;
 
356
 
362
357
  error=0;
363
 
  session->set_proc_info("update");
 
358
  thd->set_proc_info("update");
364
359
  if (duplic == DUP_REPLACE)
365
 
    table->cursor->extra(HA_EXTRA_WRITE_CAN_REPLACE);
 
360
    table->file->extra(HA_EXTRA_WRITE_CAN_REPLACE);
366
361
  if (duplic == DUP_UPDATE)
367
 
    table->cursor->extra(HA_EXTRA_INSERT_WITH_UPDATE);
 
362
    table->file->extra(HA_EXTRA_INSERT_WITH_UPDATE);
368
363
  {
369
364
    if (duplic != DUP_ERROR || ignore)
370
 
      table->cursor->extra(HA_EXTRA_IGNORE_DUP_KEY);
371
 
    table->cursor->ha_start_bulk_insert(values_list.elements);
 
365
      table->file->extra(HA_EXTRA_IGNORE_DUP_KEY);
 
366
    table->file->ha_start_bulk_insert(values_list.elements);
372
367
  }
373
368
 
374
369
 
375
 
  session->abort_on_warning= !ignore;
 
370
  thd->abort_on_warning= !ignore;
376
371
 
377
372
  table->mark_columns_needed_for_insert();
378
373
 
380
375
  {
381
376
    if (fields.elements || !value_count)
382
377
    {
383
 
      table->restoreRecordAsDefault();  // Get empty record
384
 
      if (fill_record(session, fields, *values))
 
378
      restore_record(table,s->default_values);  // Get empty record
 
379
      if (fill_record(thd, fields, *values, 0))
385
380
      {
386
 
        if (values_list.elements != 1 && ! session->is_error())
 
381
        if (values_list.elements != 1 && ! thd->is_error())
387
382
        {
388
383
          info.records++;
389
384
          continue;
390
385
        }
391
386
        /*
392
 
          TODO: set session->abort_on_warning if values_list.elements == 1
 
387
          TODO: set thd->abort_on_warning if values_list.elements == 1
393
388
          and check that all items return warning in case of problem with
394
389
          storing field.
395
390
        */
399
394
    }
400
395
    else
401
396
    {
402
 
      table->restoreRecordAsDefault();  // Get empty record
403
 
 
404
 
      if (fill_record(session, table->getFields(), *values))
405
 
      {
406
 
        if (values_list.elements != 1 && ! session->is_error())
 
397
      if (thd->used_tables)                     // Column used in values()
 
398
        restore_record(table,s->default_values);        // Get empty record
 
399
      else
 
400
      {
 
401
        /*
 
402
          Fix delete marker. No need to restore rest of record since it will
 
403
          be overwritten by fill_record() anyway (and fill_record() does not
 
404
          use default values in this case).
 
405
        */
 
406
        table->record[0][0]= table->s->default_values[0];
 
407
      }
 
408
      if (fill_record(thd, table->field, *values, 0))
 
409
      {
 
410
        if (values_list.elements != 1 && ! thd->is_error())
407
411
        {
408
412
          info.records++;
409
413
          continue;
413
417
      }
414
418
    }
415
419
 
416
 
    // Release latches in case bulk insert takes a long time
417
 
    plugin::TransactionalStorageEngine::releaseTemporaryLatches(session);
418
 
 
419
 
    error=write_record(session, table ,&info);
 
420
    error=write_record(thd, table ,&info);
420
421
    if (error)
421
422
      break;
422
 
    session->row_count++;
 
423
    thd->row_count++;
423
424
  }
424
425
 
425
 
  free_underlaid_joins(session, &session->lex->select_lex);
 
426
  free_underlaid_joins(thd, &thd->lex->select_lex);
426
427
  joins_freed= true;
427
428
 
428
429
  /*
434
435
      Do not do this release if this is a delayed insert, it would steal
435
436
      auto_inc values from the delayed_insert thread as they share Table.
436
437
    */
437
 
    table->cursor->ha_release_auto_increment();
438
 
    if (table->cursor->ha_end_bulk_insert() && !error)
 
438
    table->file->ha_release_auto_increment();
 
439
    if (table->file->ha_end_bulk_insert() && !error)
439
440
    {
440
 
      table->print_error(errno,MYF(0));
 
441
      table->file->print_error(my_errno,MYF(0));
441
442
      error=1;
442
443
    }
443
444
    if (duplic != DUP_ERROR || ignore)
444
 
      table->cursor->extra(HA_EXTRA_NO_IGNORE_DUP_KEY);
445
 
 
446
 
    transactional_table= table->cursor->has_transactions();
447
 
 
448
 
    changed= (info.copied || info.deleted || info.updated);
449
 
    if ((changed && error <= 0) || session->transaction.stmt.hasModifiedNonTransData())
450
 
    {
451
 
      if (session->transaction.stmt.hasModifiedNonTransData())
452
 
        session->transaction.all.markModifiedNonTransData();
453
 
    }
454
 
    assert(transactional_table || !changed || session->transaction.stmt.hasModifiedNonTransData());
 
445
      table->file->extra(HA_EXTRA_NO_IGNORE_DUP_KEY);
 
446
 
 
447
    transactional_table= table->file->has_transactions();
 
448
 
 
449
    if ((changed= (info.copied || info.deleted || info.updated)))
 
450
    {
 
451
      /*
 
452
        Invalidate the table in the query cache if something changed.
 
453
        For the transactional algorithm to work the invalidation must be
 
454
        before binlog writing and ha_autocommit_or_rollback
 
455
      */
 
456
    }
 
457
    if ((changed && error <= 0) || thd->transaction.stmt.modified_non_trans_table || was_insert_delayed)
 
458
    {
 
459
      if (mysql_bin_log.is_open())
 
460
      {
 
461
        if (error <= 0)
 
462
        {
 
463
          /*
 
464
            [Guilhem wrote] Temporary errors may have filled
 
465
            thd->net.last_error/errno.  For example if there has
 
466
            been a disk full error when writing the row, and it was
 
467
            MyISAM, then thd->net.last_error/errno will be set to
 
468
            "disk full"... and the my_pwrite() will wait until free
 
469
            space appears, and so when it finishes then the
 
470
            write_row() was entirely successful
 
471
          */
 
472
          /* todo: consider removing */
 
473
          thd->clear_error();
 
474
        }
 
475
        /* bug#22725:
 
476
 
 
477
        A query which per-row-loop can not be interrupted with
 
478
        KILLED, like INSERT, and that does not invoke stored
 
479
        routines can be binlogged with neglecting the KILLED error.
 
480
        
 
481
        If there was no error (error == zero) until after the end of
 
482
        inserting loop the KILLED flag that appeared later can be
 
483
        disregarded since previously possible invocation of stored
 
484
        routines did not result in any error due to the KILLED.  In
 
485
        such case the flag is ignored for constructing binlog event.
 
486
        */
 
487
        assert(thd->killed != THD::KILL_BAD_DATA || error > 0);
 
488
        if (thd->binlog_query(THD::ROW_QUERY_TYPE,
 
489
                              thd->query, thd->query_length,
 
490
                              transactional_table, false,
 
491
                              (error>0) ? thd->killed : THD::NOT_KILLED) &&
 
492
            transactional_table)
 
493
        {
 
494
          error=1;
 
495
        }
 
496
      }
 
497
      if (thd->transaction.stmt.modified_non_trans_table)
 
498
        thd->transaction.all.modified_non_trans_table= true;
 
499
    }
 
500
    assert(transactional_table || !changed || 
 
501
                thd->transaction.stmt.modified_non_trans_table);
455
502
 
456
503
  }
457
 
  session->set_proc_info("end");
 
504
  thd->set_proc_info("end");
458
505
  /*
459
506
    We'll report to the client this id:
460
507
    - if the table contains an autoincrement column and we successfully
465
512
    inserted, the id of the last "inserted" row (if IGNORE, that value may not
466
513
    have been really inserted but ignored).
467
514
  */
468
 
  id= (session->first_successful_insert_id_in_cur_stmt > 0) ?
469
 
    session->first_successful_insert_id_in_cur_stmt :
470
 
    (session->arg_of_last_insert_id_function ?
471
 
     session->first_successful_insert_id_in_prev_stmt :
 
515
  id= (thd->first_successful_insert_id_in_cur_stmt > 0) ?
 
516
    thd->first_successful_insert_id_in_cur_stmt :
 
517
    (thd->arg_of_last_insert_id_function ?
 
518
     thd->first_successful_insert_id_in_prev_stmt :
472
519
     ((table->next_number_field && info.copied) ?
473
520
     table->next_number_field->val_int() : 0));
474
521
  table->next_number_field=0;
475
 
  session->count_cuted_fields= CHECK_FIELD_IGNORE;
 
522
  thd->count_cuted_fields= CHECK_FIELD_IGNORE;
476
523
  table->auto_increment_field_not_null= false;
477
524
  if (duplic == DUP_REPLACE)
478
 
    table->cursor->extra(HA_EXTRA_WRITE_CANNOT_REPLACE);
 
525
    table->file->extra(HA_EXTRA_WRITE_CANNOT_REPLACE);
479
526
 
480
527
  if (error)
481
 
  {
482
 
    if (table != NULL)
483
 
      table->cursor->ha_release_auto_increment();
484
 
    if (!joins_freed)
485
 
      free_underlaid_joins(session, &session->lex->select_lex);
486
 
    session->abort_on_warning= 0;
487
 
    DRIZZLE_INSERT_DONE(1, 0);
488
 
    return true;
489
 
  }
490
 
 
491
 
  if (values_list.elements == 1 && (!(session->options & OPTION_WARNINGS) ||
492
 
                                    !session->cuted_fields))
493
 
  {
494
 
    session->row_count_func= info.copied + info.deleted + info.updated;
495
 
    session->my_ok((ulong) session->row_count_func,
496
 
                   info.copied + info.deleted + info.touched, id);
 
528
    goto abort;
 
529
  if (values_list.elements == 1 && (!(thd->options & OPTION_WARNINGS) ||
 
530
                                    !thd->cuted_fields))
 
531
  {
 
532
    thd->row_count_func= info.copied + info.deleted +
 
533
                         ((thd->client_capabilities & CLIENT_FOUND_ROWS) ?
 
534
                          info.touched : info.updated);
 
535
    my_ok(thd, (ulong) thd->row_count_func, id);
497
536
  }
498
537
  else
499
538
  {
500
539
    char buff[160];
 
540
    ha_rows updated=((thd->client_capabilities & CLIENT_FOUND_ROWS) ?
 
541
                     info.touched : info.updated);
501
542
    if (ignore)
502
 
      snprintf(buff, sizeof(buff), ER(ER_INSERT_INFO), (ulong) info.records,
503
 
              (ulong) (info.records - info.copied), (ulong) session->cuted_fields);
 
543
      sprintf(buff, ER(ER_INSERT_INFO), (ulong) info.records,
 
544
              (ulong) (info.records - info.copied), (ulong) thd->cuted_fields);
504
545
    else
505
 
      snprintf(buff, sizeof(buff), ER(ER_INSERT_INFO), (ulong) info.records,
506
 
              (ulong) (info.deleted + info.updated), (ulong) session->cuted_fields);
507
 
    session->row_count_func= info.copied + info.deleted + info.updated;
508
 
    session->my_ok((ulong) session->row_count_func,
509
 
                   info.copied + info.deleted + info.touched, id, buff);
 
546
      sprintf(buff, ER(ER_INSERT_INFO), (ulong) info.records,
 
547
              (ulong) (info.deleted + updated), (ulong) thd->cuted_fields);
 
548
    thd->row_count_func= info.copied + info.deleted + updated;
 
549
    ::my_ok(thd, (ulong) thd->row_count_func, id, buff);
510
550
  }
511
 
  session->status_var.inserted_row_count+= session->row_count_func;
512
 
  session->abort_on_warning= 0;
513
 
  DRIZZLE_INSERT_DONE(0, session->row_count_func);
 
551
  thd->abort_on_warning= 0;
 
552
  DRIZZLE_INSERT_END();
 
553
  return(false);
514
554
 
515
 
  return false;
 
555
abort:
 
556
  if (table != NULL)
 
557
    table->file->ha_release_auto_increment();
 
558
  if (!joins_freed)
 
559
    free_underlaid_joins(thd, &thd->lex->select_lex);
 
560
  thd->abort_on_warning= 0;
 
561
  DRIZZLE_INSERT_END();
 
562
  return(true);
516
563
}
517
564
 
518
565
 
521
568
 
522
569
  SYNOPSIS
523
570
     mysql_prepare_insert_check_table()
524
 
     session            Thread handle
 
571
     thd                Thread handle
525
572
     table_list         Table list
526
573
     fields             List of fields to be updated
527
574
     where              Pointer to where clause
532
579
     true  ERROR
533
580
*/
534
581
 
535
 
static bool mysql_prepare_insert_check_table(Session *session, TableList *table_list,
536
 
                                             List<Item> &,
 
582
static bool mysql_prepare_insert_check_table(THD *thd, TableList *table_list,
 
583
                                             List<Item> &fields __attribute__((unused)),
537
584
                                             bool select_insert)
538
585
{
539
 
 
 
586
  
540
587
 
541
588
  /*
542
589
     first table in list is the one we'll INSERT into, requires INSERT_ACL.
545
592
     than INSERT.
546
593
  */
547
594
 
548
 
  if (setup_tables_and_check_access(session, &session->lex->select_lex.context,
549
 
                                    &session->lex->select_lex.top_join_list,
 
595
  if (setup_tables_and_check_access(thd, &thd->lex->select_lex.context,
 
596
                                    &thd->lex->select_lex.top_join_list,
550
597
                                    table_list,
551
 
                                    &session->lex->select_lex.leaf_tables,
 
598
                                    &thd->lex->select_lex.leaf_tables,
552
599
                                    select_insert))
553
600
    return(true);
554
601
 
561
608
 
562
609
  SYNOPSIS
563
610
    mysql_prepare_insert()
564
 
    session                     Thread handler
 
611
    thd                 Thread handler
565
612
    table_list          Global/local table list
566
613
    table               Table to insert into (can be NULL if table should
567
 
                        be taken from table_list->table)
 
614
                        be taken from table_list->table)    
568
615
    where               Where clause (for insert ... select)
569
616
    select_insert       true if INSERT ... SELECT statement
570
 
    check_fields        true if need to check that all INSERT fields are
 
617
    check_fields        true if need to check that all INSERT fields are 
571
618
                        given values.
572
 
    abort_on_warning    whether to report if some INSERT field is not
 
619
    abort_on_warning    whether to report if some INSERT field is not 
573
620
                        assigned as an error (true) or as a warning (false).
574
621
 
575
622
  TODO (in far future)
581
628
  WARNING
582
629
    You MUST set table->insert_values to 0 after calling this function
583
630
    before releasing the table object.
584
 
 
 
631
  
585
632
  RETURN VALUE
586
633
    false OK
587
634
    true  error
588
635
*/
589
636
 
590
 
bool mysql_prepare_insert(Session *session, TableList *table_list,
 
637
bool mysql_prepare_insert(THD *thd, TableList *table_list,
591
638
                          Table *table, List<Item> &fields, List_item *values,
592
639
                          List<Item> &update_fields, List<Item> &update_values,
593
640
                          enum_duplicates duplic,
594
 
                          COND **,
 
641
                          COND **where __attribute__((unused)),
595
642
                          bool select_insert,
596
643
                          bool check_fields, bool abort_on_warning)
597
644
{
598
 
  Select_Lex *select_lex= &session->lex->select_lex;
 
645
  SELECT_LEX *select_lex= &thd->lex->select_lex;
599
646
  Name_resolution_context *context= &select_lex->context;
600
647
  Name_resolution_context_state ctx_state;
601
648
  bool insert_into_view= (0 != 0);
602
649
  bool res= 0;
603
650
  table_map map= 0;
604
 
 
 
651
  
605
652
  /* INSERT should have a SELECT or VALUES clause */
606
653
  assert (!select_insert || !values);
607
654
 
608
655
  /*
609
656
    For subqueries in VALUES() we should not see the table in which we are
610
657
    inserting (for INSERT ... SELECT this is done by changing table_list,
611
 
    because INSERT ... SELECT share Select_Lex it with SELECT.
 
658
    because INSERT ... SELECT share SELECT_LEX it with SELECT.
612
659
  */
613
660
  if (!select_insert)
614
661
  {
615
 
    for (Select_Lex_Unit *un= select_lex->first_inner_unit();
 
662
    for (SELECT_LEX_UNIT *un= select_lex->first_inner_unit();
616
663
         un;
617
664
         un= un->next_unit())
618
665
    {
619
 
      for (Select_Lex *sl= un->first_select();
 
666
      for (SELECT_LEX *sl= un->first_select();
620
667
           sl;
621
668
           sl= sl->next_select())
622
669
      {
628
675
  if (duplic == DUP_UPDATE)
629
676
  {
630
677
    /* it should be allocated before Item::fix_fields() */
631
 
    if (table_list->set_insert_values(session->mem_root))
 
678
    if (table_list->set_insert_values(thd->mem_root))
632
679
      return(true);
633
680
  }
634
681
 
635
 
  if (mysql_prepare_insert_check_table(session, table_list, fields, select_insert))
 
682
  if (mysql_prepare_insert_check_table(thd, table_list, fields, select_insert))
636
683
    return(true);
637
684
 
638
685
 
652
699
    table_list->next_local= 0;
653
700
    context->resolve_in_table_list_only(table_list);
654
701
 
655
 
    res= check_insert_fields(session, context->table_list, fields, *values,
 
702
    res= check_insert_fields(thd, context->table_list, fields, *values,
656
703
                             !insert_into_view, &map) ||
657
 
      setup_fields(session, 0, *values, MARK_COLUMNS_READ, 0, 0);
 
704
      setup_fields(thd, 0, *values, MARK_COLUMNS_READ, 0, 0);
658
705
 
659
706
    if (!res && check_fields)
660
707
    {
661
 
      bool saved_abort_on_warning= session->abort_on_warning;
662
 
      session->abort_on_warning= abort_on_warning;
663
 
      res= check_that_all_fields_are_given_values(session,
664
 
                                                  table ? table :
 
708
      bool saved_abort_on_warning= thd->abort_on_warning;
 
709
      thd->abort_on_warning= abort_on_warning;
 
710
      res= check_that_all_fields_are_given_values(thd, 
 
711
                                                  table ? table : 
665
712
                                                  context->table_list->table,
666
713
                                                  context->table_list);
667
 
      session->abort_on_warning= saved_abort_on_warning;
 
714
      thd->abort_on_warning= saved_abort_on_warning;
668
715
    }
669
716
 
670
717
    if (!res && duplic == DUP_UPDATE)
671
718
    {
672
 
      res= check_update_fields(session, context->table_list, update_fields, &map);
 
719
      res= check_update_fields(thd, context->table_list, update_fields, &map);
673
720
    }
674
721
 
675
722
    /* Restore the current context. */
676
723
    ctx_state.restore_state(context, table_list);
677
724
 
678
725
    if (!res)
679
 
      res= setup_fields(session, 0, update_values, MARK_COLUMNS_READ, 0, 0);
 
726
      res= setup_fields(thd, 0, update_values, MARK_COLUMNS_READ, 0, 0);
680
727
  }
681
728
 
682
729
  if (res)
688
735
  if (!select_insert)
689
736
  {
690
737
    TableList *duplicate;
691
 
    if ((duplicate= unique_table(table_list, table_list->next_global, true)))
 
738
    if ((duplicate= unique_table(thd, table_list, table_list->next_global, 1)))
692
739
    {
693
 
      my_error(ER_UPDATE_TABLE_USED, MYF(0), table_list->alias);
694
 
 
695
 
      return true;
 
740
      update_non_unique_table_error(table_list, "INSERT", duplicate);
 
741
      return(true);
696
742
    }
697
743
  }
698
744
  if (duplic == DUP_UPDATE || duplic == DUP_REPLACE)
699
745
    table->prepare_for_position();
700
 
 
701
 
  return false;
 
746
  return(false);
702
747
}
703
748
 
704
749
 
706
751
 
707
752
static int last_uniq_key(Table *table,uint32_t keynr)
708
753
{
709
 
  while (++keynr < table->getShare()->sizeKeys())
 
754
  while (++keynr < table->s->keys)
710
755
    if (table->key_info[keynr].flags & HA_NOSAME)
711
756
      return 0;
712
757
  return 1;
719
764
 
720
765
  SYNOPSIS
721
766
     write_record()
722
 
      session   - thread context
 
767
      thd   - thread context
723
768
      table - table to which record should be written
724
 
      info  - CopyInfo structure describing handling of duplicates
 
769
      info  - COPY_INFO structure describing handling of duplicates
725
770
              and which is used for counting number of records inserted
726
771
              and deleted.
727
772
 
731
776
    then both on update triggers will work instead. Similarly both on
732
777
    delete triggers will be invoked if we will delete conflicting records.
733
778
 
734
 
    Sets session->transaction.stmt.modified_non_trans_data to true if table which is updated didn't have
 
779
    Sets thd->transaction.stmt.modified_non_trans_table to true if table which is updated didn't have
735
780
    transactions.
736
781
 
737
782
  RETURN VALUE
740
785
*/
741
786
 
742
787
 
743
 
int write_record(Session *session, Table *table,CopyInfo *info)
 
788
int write_record(THD *thd, Table *table,COPY_INFO *info)
744
789
{
745
790
  int error;
746
 
  std::vector<unsigned char> key;
747
 
  boost::dynamic_bitset<> *save_read_set, *save_write_set;
748
 
  uint64_t prev_insert_id= table->cursor->next_insert_id;
 
791
  char *key=0;
 
792
  MY_BITMAP *save_read_set, *save_write_set;
 
793
  uint64_t prev_insert_id= table->file->next_insert_id;
749
794
  uint64_t insert_id_for_cur_row= 0;
750
 
 
 
795
  
751
796
 
752
797
  info->records++;
753
798
  save_read_set=  table->read_set;
754
799
  save_write_set= table->write_set;
755
800
 
756
 
  if (info->handle_duplicates == DUP_REPLACE || info->handle_duplicates == DUP_UPDATE)
 
801
  if (info->handle_duplicates == DUP_REPLACE ||
 
802
      info->handle_duplicates == DUP_UPDATE)
757
803
  {
758
 
    while ((error=table->cursor->insertRecord(table->getInsertRecord())))
 
804
    while ((error=table->file->ha_write_row(table->record[0])))
759
805
    {
760
806
      uint32_t key_nr;
761
807
      /*
762
808
        If we do more than one iteration of this loop, from the second one the
763
809
        row will have an explicit value in the autoinc field, which was set at
764
810
        the first call of handler::update_auto_increment(). So we must save
765
 
        the autogenerated value to avoid session->insert_id_for_cur_row to become
 
811
        the autogenerated value to avoid thd->insert_id_for_cur_row to become
766
812
        0.
767
813
      */
768
 
      if (table->cursor->insert_id_for_cur_row > 0)
769
 
        insert_id_for_cur_row= table->cursor->insert_id_for_cur_row;
 
814
      if (table->file->insert_id_for_cur_row > 0)
 
815
        insert_id_for_cur_row= table->file->insert_id_for_cur_row;
770
816
      else
771
 
        table->cursor->insert_id_for_cur_row= insert_id_for_cur_row;
 
817
        table->file->insert_id_for_cur_row= insert_id_for_cur_row;
772
818
      bool is_duplicate_key_error;
773
 
      if (table->cursor->is_fatal_error(error, HA_CHECK_DUP))
 
819
      if (table->file->is_fatal_error(error, HA_CHECK_DUP))
774
820
        goto err;
775
 
      is_duplicate_key_error= table->cursor->is_fatal_error(error, 0);
 
821
      is_duplicate_key_error= table->file->is_fatal_error(error, 0);
776
822
      if (!is_duplicate_key_error)
777
823
      {
778
824
        /*
784
830
          goto gok_or_after_err; /* Ignoring a not fatal error, return 0 */
785
831
        goto err;
786
832
      }
787
 
      if ((int) (key_nr = table->get_dup_key(error)) < 0)
 
833
      if ((int) (key_nr = table->file->get_dup_key(error)) < 0)
788
834
      {
789
835
        error= HA_ERR_FOUND_DUPP_KEY;         /* Database can't find key */
790
836
        goto err;
798
844
      */
799
845
      if (info->handle_duplicates == DUP_REPLACE &&
800
846
          table->next_number_field &&
801
 
          key_nr == table->getShare()->next_number_index &&
 
847
          key_nr == table->s->next_number_index &&
802
848
          (insert_id_for_cur_row > 0))
803
849
        goto err;
804
 
      if (table->cursor->getEngine()->check_flag(HTON_BIT_DUPLICATE_POS))
 
850
      if (table->file->ha_table_flags() & HA_DUPLICATE_POS)
805
851
      {
806
 
        if (table->cursor->rnd_pos(table->getUpdateRecord(),table->cursor->dup_ref))
 
852
        if (table->file->rnd_pos(table->record[1],table->file->dup_ref))
807
853
          goto err;
808
854
      }
809
855
      else
810
856
      {
811
 
        if (table->cursor->extra(HA_EXTRA_FLUSH_CACHE)) /* Not needed with NISAM */
 
857
        if (table->file->extra(HA_EXTRA_FLUSH_CACHE)) /* Not needed with NISAM */
812
858
        {
813
 
          error=errno;
 
859
          error=my_errno;
814
860
          goto err;
815
861
        }
816
862
 
817
 
        if (not key.size())
 
863
        if (!key)
818
864
        {
819
 
          key.resize(table->getShare()->max_unique_length);
 
865
          if (!(key=(char*) my_safe_alloca(table->s->max_unique_length,
 
866
                                           MAX_KEY_LENGTH)))
 
867
          {
 
868
            error=ENOMEM;
 
869
            goto err;
 
870
          }
820
871
        }
821
 
        key_copy(&key[0], table->getInsertRecord(), table->key_info+key_nr, 0);
822
 
        if ((error=(table->cursor->index_read_idx_map(table->getUpdateRecord(),key_nr,
823
 
                                                    &key[0], HA_WHOLE_KEY,
 
872
        key_copy((unsigned char*) key,table->record[0],table->key_info+key_nr,0);
 
873
        if ((error=(table->file->index_read_idx_map(table->record[1],key_nr,
 
874
                                                    (unsigned char*) key, HA_WHOLE_KEY,
824
875
                                                    HA_READ_KEY_EXACT))))
825
876
          goto err;
826
877
      }
831
882
          that matches, is updated. If update causes a conflict again,
832
883
          an error is returned
833
884
        */
834
 
        assert(table->insert_values.size());
835
 
        table->storeRecordAsInsert();
836
 
        table->restoreRecord();
 
885
        assert(table->insert_values != NULL);
 
886
        store_record(table,insert_values);
 
887
        restore_record(table,record[1]);
837
888
        assert(info->update_fields->elements ==
838
889
                    info->update_values->elements);
839
 
        if (fill_record(session, *info->update_fields,
 
890
        if (fill_record(thd, *info->update_fields,
840
891
                                                 *info->update_values,
841
892
                                                 info->ignore))
842
893
          goto before_err;
843
894
 
844
 
        table->cursor->restore_auto_increment(prev_insert_id);
 
895
        table->file->restore_auto_increment(prev_insert_id);
845
896
        if (table->next_number_field)
846
 
          table->cursor->adjust_next_insert_id_after_explicit_value(
 
897
          table->file->adjust_next_insert_id_after_explicit_value(
847
898
            table->next_number_field->val_int());
848
899
        info->touched++;
849
 
 
850
 
        if (! table->records_are_comparable() || table->compare_records())
 
900
        if ((table->file->ha_table_flags() & HA_PARTIAL_COLUMN_READ &&
 
901
             !bitmap_is_subset(table->write_set, table->read_set)) ||
 
902
            table->compare_record())
851
903
        {
852
 
          if ((error=table->cursor->updateRecord(table->getUpdateRecord(),
853
 
                                                table->getInsertRecord())) &&
 
904
          if ((error=table->file->ha_update_row(table->record[1],
 
905
                                                table->record[0])) &&
854
906
              error != HA_ERR_RECORD_IS_THE_SAME)
855
907
          {
856
908
            if (info->ignore &&
857
 
                !table->cursor->is_fatal_error(error, HA_CHECK_DUP_KEY))
 
909
                !table->file->is_fatal_error(error, HA_CHECK_DUP_KEY))
858
910
            {
859
911
              goto gok_or_after_err;
860
912
            }
870
922
            like a regular UPDATE statement: it should not affect the value of a
871
923
            next SELECT LAST_INSERT_ID() or mysql_insert_id().
872
924
            Except if LAST_INSERT_ID(#) was in the INSERT query, which is
873
 
            handled separately by Session::arg_of_last_insert_id_function.
 
925
            handled separately by THD::arg_of_last_insert_id_function.
874
926
          */
875
 
          insert_id_for_cur_row= table->cursor->insert_id_for_cur_row= 0;
 
927
          insert_id_for_cur_row= table->file->insert_id_for_cur_row= 0;
876
928
          info->copied++;
877
929
        }
878
930
 
879
931
        if (table->next_number_field)
880
 
          table->cursor->adjust_next_insert_id_after_explicit_value(
 
932
          table->file->adjust_next_insert_id_after_explicit_value(
881
933
            table->next_number_field->val_int());
882
934
        info->touched++;
883
935
 
890
942
          an INSERT or DELETE(s) + INSERT; FOREIGN KEY checks in
891
943
          InnoDB do not function in the defined way if we allow MySQL
892
944
          to convert the latter operation internally to an UPDATE.
893
 
          We also should not perform this conversion if we have
 
945
          We also should not perform this conversion if we have 
894
946
          timestamp field with ON UPDATE which is different from DEFAULT.
895
947
          Another case when conversion should not be performed is when
896
948
          we have ON DELETE trigger on table so user may notice that
900
952
          ON UPDATE triggers.
901
953
        */
902
954
        if (last_uniq_key(table,key_nr) &&
903
 
            !table->cursor->referenced_by_foreign_key() &&
 
955
            !table->file->referenced_by_foreign_key() &&
904
956
            (table->timestamp_field_type == TIMESTAMP_NO_AUTO_SET ||
905
957
             table->timestamp_field_type == TIMESTAMP_AUTO_SET_ON_BOTH))
906
958
        {
907
 
          if ((error=table->cursor->updateRecord(table->getUpdateRecord(),
908
 
                                                table->getInsertRecord())) &&
 
959
          if ((error=table->file->ha_update_row(table->record[1],
 
960
                                                table->record[0])) &&
909
961
              error != HA_ERR_RECORD_IS_THE_SAME)
910
962
            goto err;
911
963
          if (error != HA_ERR_RECORD_IS_THE_SAME)
912
964
            info->deleted++;
913
965
          else
914
966
            error= 0;
915
 
          session->record_first_successful_insert_id_in_cur_stmt(table->cursor->insert_id_for_cur_row);
 
967
          thd->record_first_successful_insert_id_in_cur_stmt(table->file->insert_id_for_cur_row);
916
968
          /*
917
969
            Since we pretend that we have done insert we should call
918
970
            its after triggers.
921
973
        }
922
974
        else
923
975
        {
924
 
          if ((error=table->cursor->deleteRecord(table->getUpdateRecord())))
 
976
          if ((error=table->file->ha_delete_row(table->record[1])))
925
977
            goto err;
926
978
          info->deleted++;
927
 
          if (!table->cursor->has_transactions())
928
 
            session->transaction.stmt.markModifiedNonTransData();
 
979
          if (!table->file->has_transactions())
 
980
            thd->transaction.stmt.modified_non_trans_table= true;
929
981
          /* Let us attempt do write_row() once more */
930
982
        }
931
983
      }
932
984
    }
933
 
    session->record_first_successful_insert_id_in_cur_stmt(table->cursor->insert_id_for_cur_row);
 
985
    thd->record_first_successful_insert_id_in_cur_stmt(table->file->insert_id_for_cur_row);
934
986
    /*
935
987
      Restore column maps if they where replaced during an duplicate key
936
988
      problem.
937
989
    */
938
990
    if (table->read_set != save_read_set ||
939
991
        table->write_set != save_write_set)
940
 
      table->column_bitmaps_set(*save_read_set, *save_write_set);
 
992
      table->column_bitmaps_set(save_read_set, save_write_set);
941
993
  }
942
 
  else if ((error=table->cursor->insertRecord(table->getInsertRecord())))
 
994
  else if ((error=table->file->ha_write_row(table->record[0])))
943
995
  {
944
996
    if (!info->ignore ||
945
 
        table->cursor->is_fatal_error(error, HA_CHECK_DUP))
 
997
        table->file->is_fatal_error(error, HA_CHECK_DUP))
946
998
      goto err;
947
 
    table->cursor->restore_auto_increment(prev_insert_id);
 
999
    table->file->restore_auto_increment(prev_insert_id);
948
1000
    goto gok_or_after_err;
949
1001
  }
950
1002
 
951
1003
after_n_copied_inc:
952
1004
  info->copied++;
953
 
  session->record_first_successful_insert_id_in_cur_stmt(table->cursor->insert_id_for_cur_row);
 
1005
  thd->record_first_successful_insert_id_in_cur_stmt(table->file->insert_id_for_cur_row);
954
1006
 
955
1007
gok_or_after_err:
956
 
  if (!table->cursor->has_transactions())
957
 
    session->transaction.stmt.markModifiedNonTransData();
 
1008
  if (key)
 
1009
    my_safe_afree(key,table->s->max_unique_length,MAX_KEY_LENGTH);
 
1010
  if (!table->file->has_transactions())
 
1011
    thd->transaction.stmt.modified_non_trans_table= true;
958
1012
  return(0);
959
1013
 
960
1014
err:
961
1015
  info->last_errno= error;
962
1016
  /* current_select is NULL if this is a delayed insert */
963
 
  if (session->lex->current_select)
964
 
    session->lex->current_select->no_error= 0;        // Give error
965
 
  table->print_error(error,MYF(0));
966
 
 
 
1017
  if (thd->lex->current_select)
 
1018
    thd->lex->current_select->no_error= 0;        // Give error
 
1019
  table->file->print_error(error,MYF(0));
 
1020
  
967
1021
before_err:
968
 
  table->cursor->restore_auto_increment(prev_insert_id);
969
 
  table->column_bitmaps_set(*save_read_set, *save_write_set);
970
 
  return 1;
 
1022
  table->file->restore_auto_increment(prev_insert_id);
 
1023
  if (key)
 
1024
    my_safe_afree(key, table->s->max_unique_length, MAX_KEY_LENGTH);
 
1025
  table->column_bitmaps_set(save_read_set, save_write_set);
 
1026
  return(1);
971
1027
}
972
1028
 
973
1029
 
975
1031
  Check that all fields with arn't null_fields are used
976
1032
******************************************************************************/
977
1033
 
978
 
int check_that_all_fields_are_given_values(Session *session, Table *entry,
979
 
                                           TableList *)
 
1034
int check_that_all_fields_are_given_values(THD *thd, Table *entry,
 
1035
                                           TableList *table_list)
980
1036
{
981
1037
  int err= 0;
 
1038
  MY_BITMAP *write_set= entry->write_set;
982
1039
 
983
 
  for (Field **field=entry->getFields() ; *field ; field++)
 
1040
  for (Field **field=entry->field ; *field ; field++)
984
1041
  {
985
 
    if (((*field)->isWriteSet()) == false)
986
 
    {
987
 
      /*
988
 
       * If the field doesn't have any default value
989
 
       * and there is no actual value specified in the
990
 
       * INSERT statement, throw error ER_NO_DEFAULT_FOR_FIELD.
991
 
       */
992
 
      if (((*field)->flags & NO_DEFAULT_VALUE_FLAG) &&
 
1042
    if (!bitmap_is_set(write_set, (*field)->field_index) &&
 
1043
        ((*field)->flags & NO_DEFAULT_VALUE_FLAG) &&
993
1044
        ((*field)->real_type() != DRIZZLE_TYPE_ENUM))
994
 
      {
995
 
        my_error(ER_NO_DEFAULT_FOR_FIELD, MYF(0), (*field)->field_name);
996
 
        err= 1;
997
 
      }
998
 
    }
999
 
    else
1000
1045
    {
1001
 
      /*
1002
 
       * However, if an actual NULL value was specified
1003
 
       * for the field and the field is a NOT NULL field, 
1004
 
       * throw ER_BAD_NULL_ERROR.
1005
 
       *
1006
 
       * Per the SQL standard, inserting NULL into a NOT NULL
1007
 
       * field requires an error to be thrown.
1008
 
       */
1009
 
      if (((*field)->flags & NOT_NULL_FLAG) &&
1010
 
          (*field)->is_null())
1011
 
      {
1012
 
        my_error(ER_BAD_NULL_ERROR, MYF(0), (*field)->field_name);
1013
 
        err= 1;
1014
 
      }
 
1046
      bool view= false;
 
1047
      if (table_list)
 
1048
      {
 
1049
        table_list= table_list->top_table();
 
1050
        view= test(0);
 
1051
      }
 
1052
      {
 
1053
        push_warning_printf(thd, DRIZZLE_ERROR::WARN_LEVEL_WARN,
 
1054
                            ER_NO_DEFAULT_FOR_FIELD,
 
1055
                            ER(ER_NO_DEFAULT_FOR_FIELD),
 
1056
                            (*field)->field_name);
 
1057
      }
 
1058
      err= 1;
1015
1059
    }
1016
1060
  }
1017
 
  return session->abort_on_warning ? err : 0;
 
1061
  return thd->abort_on_warning ? err : 0;
1018
1062
}
1019
1063
 
1020
1064
/***************************************************************************
1027
1071
 
1028
1072
  SYNOPSIS
1029
1073
    mysql_insert_select_prepare()
1030
 
    session         thread handler
 
1074
    thd         thread handler
1031
1075
 
1032
1076
  RETURN
1033
1077
    false OK
1034
1078
    true  Error
1035
1079
*/
1036
1080
 
1037
 
bool mysql_insert_select_prepare(Session *session)
 
1081
bool mysql_insert_select_prepare(THD *thd)
1038
1082
{
1039
 
  LEX *lex= session->lex;
1040
 
  Select_Lex *select_lex= &lex->select_lex;
1041
 
 
1042
 
  /*
1043
 
    Select_Lex do not belong to INSERT statement, so we can't add WHERE
 
1083
  LEX *lex= thd->lex;
 
1084
  SELECT_LEX *select_lex= &lex->select_lex;
 
1085
  
 
1086
 
 
1087
  /*
 
1088
    Statement-based replication of INSERT ... SELECT ... LIMIT is not safe
 
1089
    as order of rows is not defined, so in mixed mode we go to row-based.
 
1090
 
 
1091
    Note that we may consider a statement as safe if ORDER BY primary_key
 
1092
    is present or we SELECT a constant. However it may confuse users to
 
1093
    see very similiar statements replicated differently.
 
1094
  */
 
1095
  if (lex->current_select->select_limit)
 
1096
  {
 
1097
    lex->set_stmt_unsafe();
 
1098
    thd->set_current_stmt_binlog_row_based_if_mixed();
 
1099
  }
 
1100
  /*
 
1101
    SELECT_LEX do not belong to INSERT statement, so we can't add WHERE
1044
1102
    clause if table is VIEW
1045
1103
  */
1046
 
 
1047
 
  if (mysql_prepare_insert(session, lex->query_tables,
 
1104
  
 
1105
  if (mysql_prepare_insert(thd, lex->query_tables,
1048
1106
                           lex->query_tables->table, lex->field_list, 0,
1049
1107
                           lex->update_list, lex->value_list,
1050
1108
                           lex->duplicates,
1068
1126
                             List<Item> *update_fields,
1069
1127
                             List<Item> *update_values,
1070
1128
                             enum_duplicates duplic,
1071
 
                             bool ignore_check_option_errors) :
1072
 
  table_list(table_list_par), table(table_par), fields(fields_par),
1073
 
  autoinc_value_of_last_inserted_row(0),
1074
 
  insert_into_view(table_list_par && 0 != 0)
 
1129
                             bool ignore_check_option_errors)
 
1130
  :table_list(table_list_par), table(table_par), fields(fields_par),
 
1131
   autoinc_value_of_last_inserted_row(0),
 
1132
   insert_into_view(table_list_par && 0 != 0)
1075
1133
{
 
1134
  memset(&info, 0, sizeof(info));
1076
1135
  info.handle_duplicates= duplic;
1077
1136
  info.ignore= ignore_check_option_errors;
1078
1137
  info.update_fields= update_fields;
1081
1140
 
1082
1141
 
1083
1142
int
1084
 
select_insert::prepare(List<Item> &values, Select_Lex_Unit *u)
 
1143
select_insert::prepare(List<Item> &values, SELECT_LEX_UNIT *u)
1085
1144
{
1086
 
  LEX *lex= session->lex;
 
1145
  LEX *lex= thd->lex;
1087
1146
  int res;
1088
1147
  table_map map= 0;
1089
 
  Select_Lex *lex_current_select_save= lex->current_select;
1090
 
 
 
1148
  SELECT_LEX *lex_current_select_save= lex->current_select;
 
1149
  
1091
1150
 
1092
1151
  unit= u;
1093
1152
 
1097
1156
    we are fixing fields from insert list.
1098
1157
  */
1099
1158
  lex->current_select= &lex->select_lex;
1100
 
  res= check_insert_fields(session, table_list, *fields, values,
 
1159
  res= check_insert_fields(thd, table_list, *fields, values,
1101
1160
                           !insert_into_view, &map) ||
1102
 
       setup_fields(session, 0, values, MARK_COLUMNS_READ, 0, 0);
 
1161
       setup_fields(thd, 0, values, MARK_COLUMNS_READ, 0, 0);
1103
1162
 
1104
1163
  if (!res && fields->elements)
1105
1164
  {
1106
 
    bool saved_abort_on_warning= session->abort_on_warning;
1107
 
    session->abort_on_warning= !info.ignore;
1108
 
    res= check_that_all_fields_are_given_values(session, table_list->table,
 
1165
    bool saved_abort_on_warning= thd->abort_on_warning;
 
1166
    thd->abort_on_warning= !info.ignore;
 
1167
    res= check_that_all_fields_are_given_values(thd, table_list->table, 
1109
1168
                                                table_list);
1110
 
    session->abort_on_warning= saved_abort_on_warning;
 
1169
    thd->abort_on_warning= saved_abort_on_warning;
1111
1170
  }
1112
1171
 
1113
1172
  if (info.handle_duplicates == DUP_UPDATE && !res)
1122
1181
    table_list->next_local= 0;
1123
1182
    context->resolve_in_table_list_only(table_list);
1124
1183
 
1125
 
    res= res || check_update_fields(session, context->table_list,
 
1184
    res= res || check_update_fields(thd, context->table_list,
1126
1185
                                    *info.update_fields, &map);
1127
1186
    /*
1128
 
      When we are not using GROUP BY and there are no ungrouped aggregate functions
 
1187
      When we are not using GROUP BY and there are no ungrouped aggregate functions 
1129
1188
      we can refer to other tables in the ON DUPLICATE KEY part.
1130
1189
      We use next_name_resolution_table descructively, so check it first (views?)
1131
1190
    */
1136
1195
        We must make a single context out of the two separate name resolution contexts :
1137
1196
        the INSERT table and the tables in the SELECT part of INSERT ... SELECT.
1138
1197
        To do that we must concatenate the two lists
1139
 
      */
1140
 
      table_list->next_name_resolution_table=
 
1198
      */  
 
1199
      table_list->next_name_resolution_table= 
1141
1200
        ctx_state.get_first_name_resolution_table();
1142
1201
 
1143
 
    res= res || setup_fields(session, 0, *info.update_values,
 
1202
    res= res || setup_fields(thd, 0, *info.update_values,
1144
1203
                             MARK_COLUMNS_READ, 0, 0);
1145
1204
    if (!res)
1146
1205
    {
1177
1236
    Is table which we are changing used somewhere in other parts of
1178
1237
    query
1179
1238
  */
1180
 
  if (unique_table(table_list, table_list->next_global))
 
1239
  if (unique_table(thd, table_list, table_list->next_global, 0))
1181
1240
  {
1182
1241
    /* Using same table for INSERT and SELECT */
1183
1242
    lex->current_select->options|= OPTION_BUFFER_RESULT;
1186
1245
  else if (!(lex->current_select->options & OPTION_BUFFER_RESULT))
1187
1246
  {
1188
1247
    /*
1189
 
      We must not yet prepare the result table if it is the same as one of the
1190
 
      source tables (INSERT SELECT). The preparation may disable
 
1248
      We must not yet prepare the result table if it is the same as one of the 
 
1249
      source tables (INSERT SELECT). The preparation may disable 
1191
1250
      indexes on the result table, which may be used during the select, if it
1192
1251
      is the same table (Bug #6034). Do the preparation after the select phase
1193
1252
      in select_insert::prepare2().
1194
1253
      We won't start bulk inserts at all if this statement uses functions or
1195
1254
      should invoke triggers since they may access to the same table too.
1196
1255
    */
1197
 
    table->cursor->ha_start_bulk_insert((ha_rows) 0);
 
1256
    table->file->ha_start_bulk_insert((ha_rows) 0);
1198
1257
  }
1199
 
  table->restoreRecordAsDefault();              // Get empty record
 
1258
  restore_record(table,s->default_values);              // Get empty record
1200
1259
  table->next_number_field=table->found_next_number_field;
1201
1260
 
1202
 
  session->cuted_fields=0;
 
1261
  if (thd->slave_thread &&
 
1262
      (info.handle_duplicates == DUP_UPDATE) &&
 
1263
      (table->next_number_field != NULL) &&
 
1264
      rpl_master_has_bug(&active_mi->rli, 24432))
 
1265
    return(1);
 
1266
 
 
1267
  thd->cuted_fields=0;
1203
1268
  if (info.ignore || info.handle_duplicates != DUP_ERROR)
1204
 
    table->cursor->extra(HA_EXTRA_IGNORE_DUP_KEY);
 
1269
    table->file->extra(HA_EXTRA_IGNORE_DUP_KEY);
1205
1270
  if (info.handle_duplicates == DUP_REPLACE)
1206
 
    table->cursor->extra(HA_EXTRA_WRITE_CAN_REPLACE);
 
1271
    table->file->extra(HA_EXTRA_WRITE_CAN_REPLACE);
1207
1272
  if (info.handle_duplicates == DUP_UPDATE)
1208
 
    table->cursor->extra(HA_EXTRA_INSERT_WITH_UPDATE);
1209
 
  session->abort_on_warning= !info.ignore;
 
1273
    table->file->extra(HA_EXTRA_INSERT_WITH_UPDATE);
 
1274
  thd->abort_on_warning= !info.ignore;
1210
1275
  table->mark_columns_needed_for_insert();
1211
1276
 
1212
1277
 
1225
1290
    If the result table is the same as one of the source tables (INSERT SELECT),
1226
1291
    the result table is not finally prepared at the join prepair phase.
1227
1292
    Do the final preparation now.
1228
 
 
 
1293
                       
1229
1294
  RETURN
1230
1295
    0   OK
1231
1296
*/
1232
1297
 
1233
1298
int select_insert::prepare2(void)
1234
1299
{
1235
 
 
1236
 
  if (session->lex->current_select->options & OPTION_BUFFER_RESULT)
1237
 
    table->cursor->ha_start_bulk_insert((ha_rows) 0);
 
1300
  
 
1301
  if (thd->lex->current_select->options & OPTION_BUFFER_RESULT)
 
1302
    table->file->ha_start_bulk_insert((ha_rows) 0);
1238
1303
  return(0);
1239
1304
}
1240
1305
 
1247
1312
 
1248
1313
select_insert::~select_insert()
1249
1314
{
1250
 
 
 
1315
  
1251
1316
  if (table)
1252
1317
  {
1253
1318
    table->next_number_field=0;
1254
1319
    table->auto_increment_field_not_null= false;
1255
 
    table->cursor->ha_reset();
 
1320
    table->file->ha_reset();
1256
1321
  }
1257
 
  session->count_cuted_fields= CHECK_FIELD_IGNORE;
1258
 
  session->abort_on_warning= 0;
 
1322
  thd->count_cuted_fields= CHECK_FIELD_IGNORE;
 
1323
  thd->abort_on_warning= 0;
1259
1324
  return;
1260
1325
}
1261
1326
 
1262
1327
 
1263
1328
bool select_insert::send_data(List<Item> &values)
1264
1329
{
1265
 
 
 
1330
  
1266
1331
  bool error=0;
1267
1332
 
1268
1333
  if (unit->offset_limit_cnt)
1271
1336
    return(0);
1272
1337
  }
1273
1338
 
1274
 
  session->count_cuted_fields= CHECK_FIELD_WARN;        // Calculate cuted fields
 
1339
  thd->count_cuted_fields= CHECK_FIELD_WARN;    // Calculate cuted fields
1275
1340
  store_values(values);
1276
 
  session->count_cuted_fields= CHECK_FIELD_IGNORE;
1277
 
  if (session->is_error())
 
1341
  thd->count_cuted_fields= CHECK_FIELD_IGNORE;
 
1342
  if (thd->is_error())
1278
1343
    return(1);
1279
1344
 
1280
 
  // Release latches in case bulk insert takes a long time
1281
 
  plugin::TransactionalStorageEngine::releaseTemporaryLatches(session);
1282
 
 
1283
 
  error= write_record(session, table, &info);
1284
 
  table->auto_increment_field_not_null= false;
1285
 
 
 
1345
  error= write_record(thd, table, &info);
 
1346
    
1286
1347
  if (!error)
1287
1348
  {
1288
1349
    if (info.handle_duplicates == DUP_UPDATE)
1290
1351
      /*
1291
1352
        Restore fields of the record since it is possible that they were
1292
1353
        changed by ON DUPLICATE KEY UPDATE clause.
1293
 
 
 
1354
    
1294
1355
        If triggers exist then whey can modify some fields which were not
1295
1356
        originally touched by INSERT ... SELECT, so we have to restore
1296
1357
        their original values for the next row.
1297
1358
      */
1298
 
      table->restoreRecordAsDefault();
 
1359
      restore_record(table, s->default_values);
1299
1360
    }
1300
1361
    if (table->next_number_field)
1301
1362
    {
1303
1364
        If no value has been autogenerated so far, we need to remember the
1304
1365
        value we just saw, we may need to send it to client in the end.
1305
1366
      */
1306
 
      if (session->first_successful_insert_id_in_cur_stmt == 0) // optimization
1307
 
        autoinc_value_of_last_inserted_row=
 
1367
      if (thd->first_successful_insert_id_in_cur_stmt == 0) // optimization
 
1368
        autoinc_value_of_last_inserted_row= 
1308
1369
          table->next_number_field->val_int();
1309
1370
      /*
1310
1371
        Clear auto-increment field for the next record, if triggers are used
1320
1381
void select_insert::store_values(List<Item> &values)
1321
1382
{
1322
1383
  if (fields->elements)
1323
 
    fill_record(session, *fields, values, true);
 
1384
    fill_record(thd, *fields, values, 1);
1324
1385
  else
1325
 
    fill_record(session, table->getFields(), values, true);
 
1386
    fill_record(thd, table->field, values, 1);
1326
1387
}
1327
1388
 
1328
1389
void select_insert::send_error(uint32_t errcode,const char *err)
1329
1390
{
1330
 
 
 
1391
  
1331
1392
 
1332
1393
  my_message(errcode, err, MYF(0));
1333
1394
 
1338
1399
bool select_insert::send_eof()
1339
1400
{
1340
1401
  int error;
1341
 
  bool const trans_table= table->cursor->has_transactions();
 
1402
  bool const trans_table= table->file->has_transactions();
1342
1403
  uint64_t id;
1343
1404
  bool changed;
1344
 
 
1345
 
  error= table->cursor->ha_end_bulk_insert();
1346
 
  table->cursor->extra(HA_EXTRA_NO_IGNORE_DUP_KEY);
1347
 
  table->cursor->extra(HA_EXTRA_WRITE_CANNOT_REPLACE);
 
1405
  THD::killed_state killed_status= thd->killed;
 
1406
  
 
1407
  error= table->file->ha_end_bulk_insert();
 
1408
  table->file->extra(HA_EXTRA_NO_IGNORE_DUP_KEY);
 
1409
  table->file->extra(HA_EXTRA_WRITE_CANNOT_REPLACE);
1348
1410
 
1349
1411
  if ((changed= (info.copied || info.deleted || info.updated)))
1350
1412
  {
1351
1413
    /*
1352
1414
      We must invalidate the table in the query cache before binlog writing
1353
 
      and autocommitOrRollback.
 
1415
      and ha_autocommit_or_rollback.
1354
1416
    */
1355
 
    if (session->transaction.stmt.hasModifiedNonTransData())
1356
 
      session->transaction.all.markModifiedNonTransData();
 
1417
    if (thd->transaction.stmt.modified_non_trans_table)
 
1418
      thd->transaction.all.modified_non_trans_table= true;
1357
1419
  }
1358
 
  assert(trans_table || !changed ||
1359
 
              session->transaction.stmt.hasModifiedNonTransData());
 
1420
  assert(trans_table || !changed || 
 
1421
              thd->transaction.stmt.modified_non_trans_table);
1360
1422
 
1361
 
  table->cursor->ha_release_auto_increment();
 
1423
  /*
 
1424
    Write to binlog before commiting transaction.  No statement will
 
1425
    be written by the binlog_query() below in RBR mode.  All the
 
1426
    events are in the transaction cache and will be written when
 
1427
    ha_autocommit_or_rollback() is issued below.
 
1428
  */
 
1429
  if (mysql_bin_log.is_open())
 
1430
  {
 
1431
    if (!error)
 
1432
      thd->clear_error();
 
1433
    thd->binlog_query(THD::ROW_QUERY_TYPE,
 
1434
                      thd->query, thd->query_length,
 
1435
                      trans_table, false, killed_status);
 
1436
  }
 
1437
  table->file->ha_release_auto_increment();
1362
1438
 
1363
1439
  if (error)
1364
1440
  {
1365
 
    table->print_error(error,MYF(0));
1366
 
    DRIZZLE_INSERT_SELECT_DONE(error, 0);
1367
 
    return 1;
 
1441
    table->file->print_error(error,MYF(0));
 
1442
    return(1);
1368
1443
  }
1369
1444
  char buff[160];
1370
1445
  if (info.ignore)
1371
 
    snprintf(buff, sizeof(buff), ER(ER_INSERT_INFO), (ulong) info.records,
1372
 
            (ulong) (info.records - info.copied), (ulong) session->cuted_fields);
 
1446
    sprintf(buff, ER(ER_INSERT_INFO), (ulong) info.records,
 
1447
            (ulong) (info.records - info.copied), (ulong) thd->cuted_fields);
1373
1448
  else
1374
 
    snprintf(buff, sizeof(buff), ER(ER_INSERT_INFO), (ulong) info.records,
1375
 
            (ulong) (info.deleted+info.updated), (ulong) session->cuted_fields);
1376
 
  session->row_count_func= info.copied + info.deleted + info.updated;
 
1449
    sprintf(buff, ER(ER_INSERT_INFO), (ulong) info.records,
 
1450
            (ulong) (info.deleted+info.updated), (ulong) thd->cuted_fields);
 
1451
  thd->row_count_func= info.copied + info.deleted +
 
1452
                       ((thd->client_capabilities & CLIENT_FOUND_ROWS) ?
 
1453
                        info.touched : info.updated);
1377
1454
 
1378
 
  id= (session->first_successful_insert_id_in_cur_stmt > 0) ?
1379
 
    session->first_successful_insert_id_in_cur_stmt :
1380
 
    (session->arg_of_last_insert_id_function ?
1381
 
     session->first_successful_insert_id_in_prev_stmt :
 
1455
  id= (thd->first_successful_insert_id_in_cur_stmt > 0) ?
 
1456
    thd->first_successful_insert_id_in_cur_stmt :
 
1457
    (thd->arg_of_last_insert_id_function ?
 
1458
     thd->first_successful_insert_id_in_prev_stmt :
1382
1459
     (info.copied ? autoinc_value_of_last_inserted_row : 0));
1383
 
  session->my_ok((ulong) session->row_count_func,
1384
 
                 info.copied + info.deleted + info.touched, id, buff);
1385
 
  session->status_var.inserted_row_count+= session->row_count_func; 
1386
 
  DRIZZLE_INSERT_SELECT_DONE(0, session->row_count_func);
1387
 
  return 0;
 
1460
  ::my_ok(thd, (ulong) thd->row_count_func, id, buff);
 
1461
  return(0);
1388
1462
}
1389
1463
 
1390
1464
void select_insert::abort() {
1391
1465
 
1392
 
 
 
1466
  
1393
1467
  /*
1394
1468
    If the creation of the table failed (due to a syntax error, for
1395
1469
    example), no table will have been opened and therefore 'table'
1400
1474
  {
1401
1475
    bool changed, transactional_table;
1402
1476
 
1403
 
    table->cursor->ha_end_bulk_insert();
 
1477
    table->file->ha_end_bulk_insert();
1404
1478
 
1405
1479
    /*
1406
1480
      If at least one row has been inserted/modified and will stay in
1417
1491
      zero, so no check for that is made.
1418
1492
    */
1419
1493
    changed= (info.copied || info.deleted || info.updated);
1420
 
    transactional_table= table->cursor->has_transactions();
 
1494
    transactional_table= table->file->has_transactions();
 
1495
    if (thd->transaction.stmt.modified_non_trans_table)
 
1496
    {
 
1497
        if (mysql_bin_log.is_open())
 
1498
          thd->binlog_query(THD::ROW_QUERY_TYPE, thd->query, thd->query_length,
 
1499
                            transactional_table, false);
 
1500
        if (!thd->current_stmt_binlog_row_based && !can_rollback_data())
 
1501
          thd->transaction.all.modified_non_trans_table= true;
 
1502
    }
1421
1503
    assert(transactional_table || !changed ||
1422
 
                session->transaction.stmt.hasModifiedNonTransData());
1423
 
    table->cursor->ha_release_auto_increment();
1424
 
  }
1425
 
 
1426
 
  if (DRIZZLE_INSERT_SELECT_DONE_ENABLED())
1427
 
  {
1428
 
    DRIZZLE_INSERT_SELECT_DONE(0, info.copied + info.deleted + info.updated);
 
1504
                thd->transaction.stmt.modified_non_trans_table);
 
1505
    table->file->ha_release_auto_increment();
1429
1506
  }
1430
1507
 
1431
1508
  return;
1442
1519
 
1443
1520
  SYNOPSIS
1444
1521
    create_table_from_items()
1445
 
      session          in     Thread object
 
1522
      thd          in     Thread object
1446
1523
      create_info  in     Create information (like MAX_ROWS, ENGINE or
1447
1524
                          temporary table flag)
1448
1525
      create_table in     Pointer to TableList object providing database
1452
1529
      items        in     List of items which should be used to produce rest
1453
1530
                          of fields for the table (corresponding fields will
1454
1531
                          be added to the end of alter_info->create_list)
1455
 
      lock         out    Pointer to the DrizzleLock object for table created
 
1532
      lock         out    Pointer to the DRIZZLE_LOCK object for table created
1456
1533
                          (or open temporary table) will be returned in this
1457
1534
                          parameter. Since this table is not included in
1458
 
                          Session::lock caller is responsible for explicitly
 
1535
                          THD::lock caller is responsible for explicitly
1459
1536
                          unlocking this table.
1460
1537
      hooks
1461
1538
 
1462
1539
  NOTES
1463
1540
    This function behaves differently for base and temporary tables:
1464
1541
    - For base table we assume that either table exists and was pre-opened
1465
 
      and locked at openTablesLock() stage (and in this case we just
 
1542
      and locked at open_and_lock_tables() stage (and in this case we just
1466
1543
      emit error or warning and return pre-opened Table object) or special
1467
1544
      placeholder was put in table cache that guarantees that this table
1468
1545
      won't be created or opened until the placeholder will be removed
1478
1555
    0         Error
1479
1556
*/
1480
1557
 
1481
 
static Table *create_table_from_items(Session *session, HA_CREATE_INFO *create_info,
 
1558
static Table *create_table_from_items(THD *thd, HA_CREATE_INFO *create_info,
1482
1559
                                      TableList *create_table,
1483
 
                                      message::Table &table_proto,
1484
 
                                      AlterInfo *alter_info,
 
1560
                                      Alter_info *alter_info,
1485
1561
                                      List<Item> *items,
1486
 
                                      bool is_if_not_exists,
1487
 
                                      DrizzleLock **lock,
1488
 
                                      TableIdentifier &identifier)
 
1562
                                      DRIZZLE_LOCK **lock,
 
1563
                                      TABLEOP_HOOKS *hooks)
1489
1564
{
1490
 
  TableShare share(message::Table::INTERNAL);
 
1565
  Table tmp_table;              // Used during 'Create_field()'
 
1566
  TABLE_SHARE share;
 
1567
  Table *table= 0;
1491
1568
  uint32_t select_field_count= items->elements;
1492
1569
  /* Add selected items to field list */
1493
1570
  List_iterator_fast<Item> it(*items);
1495
1572
  Field *tmp_field;
1496
1573
  bool not_used;
1497
1574
 
1498
 
  if (not (identifier.isTmp()) && create_table->table->db_stat)
 
1575
  if (!(create_info->options & HA_LEX_CREATE_TMP_TABLE) &&
 
1576
      create_table->table->db_stat)
1499
1577
  {
1500
 
    /* Table already exists and was open at openTablesLock() stage. */
1501
 
    if (is_if_not_exists)
 
1578
    /* Table already exists and was open at open_and_lock_tables() stage. */
 
1579
    if (create_info->options & HA_LEX_CREATE_IF_NOT_EXISTS)
1502
1580
    {
1503
1581
      create_info->table_existed= 1;            // Mark that table existed
1504
 
      push_warning_printf(session, DRIZZLE_ERROR::WARN_LEVEL_NOTE,
 
1582
      push_warning_printf(thd, DRIZZLE_ERROR::WARN_LEVEL_NOTE,
1505
1583
                          ER_TABLE_EXISTS_ERROR, ER(ER_TABLE_EXISTS_ERROR),
1506
 
                          create_table->getTableName());
1507
 
      return create_table->table;
 
1584
                          create_table->table_name);
 
1585
      return(create_table->table);
1508
1586
    }
1509
1587
 
1510
 
    my_error(ER_TABLE_EXISTS_ERROR, MYF(0), create_table->getTableName());
1511
 
    return NULL;
 
1588
    my_error(ER_TABLE_EXISTS_ERROR, MYF(0), create_table->table_name);
 
1589
    return(0);
1512
1590
  }
1513
1591
 
 
1592
  tmp_table.alias= 0;
 
1593
  tmp_table.timestamp_field= 0;
 
1594
  tmp_table.s= &share;
 
1595
  init_tmp_table_share(thd, &share, "", 0, "", "");
 
1596
 
 
1597
  tmp_table.s->db_create_options=0;
 
1598
  tmp_table.s->blob_ptr_size= portable_sizeof_char_ptr;
 
1599
  tmp_table.s->db_low_byte_first= 
 
1600
        test(create_info->db_type == myisam_hton ||
 
1601
             create_info->db_type == heap_hton);
 
1602
  tmp_table.null_row= false;
 
1603
  tmp_table.maybe_null= false;
 
1604
 
 
1605
  while ((item=it++))
1514
1606
  {
1515
 
    table::Shell tmp_table(share);              // Used during 'CreateField()'
1516
 
    tmp_table.timestamp_field= 0;
1517
 
 
1518
 
    tmp_table.getMutableShare()->db_create_options= 0;
1519
 
    tmp_table.getMutableShare()->blob_ptr_size= portable_sizeof_char_ptr;
1520
 
 
1521
 
    if (not table_proto.engine().name().compare("MyISAM"))
1522
 
      tmp_table.getMutableShare()->db_low_byte_first= true;
1523
 
    else if (not table_proto.engine().name().compare("MEMORY"))
1524
 
      tmp_table.getMutableShare()->db_low_byte_first= true;
1525
 
 
1526
 
    tmp_table.null_row= false;
1527
 
    tmp_table.maybe_null= false;
1528
 
 
1529
 
    tmp_table.in_use= session;
1530
 
 
1531
 
    while ((item=it++))
1532
 
    {
1533
 
      CreateField *cr_field;
1534
 
      Field *field, *def_field;
1535
 
      if (item->type() == Item::FUNC_ITEM)
1536
 
      {
1537
 
        if (item->result_type() != STRING_RESULT)
1538
 
        {
1539
 
          field= item->tmp_table_field(&tmp_table);
1540
 
        }
1541
 
        else
1542
 
        {
1543
 
          field= item->tmp_table_field_from_field_type(&tmp_table, 0);
1544
 
        }
1545
 
      }
 
1607
    Create_field *cr_field;
 
1608
    Field *field, *def_field;
 
1609
    if (item->type() == Item::FUNC_ITEM)
 
1610
      if (item->result_type() != STRING_RESULT)
 
1611
        field= item->tmp_table_field(&tmp_table);
1546
1612
      else
1547
 
      {
1548
 
        field= create_tmp_field(session, &tmp_table, item, item->type(),
1549
 
                                (Item ***) 0, &tmp_field, &def_field, false,
1550
 
                                false, false, 0);
1551
 
      }
1552
 
 
1553
 
      if (!field ||
1554
 
          !(cr_field=new CreateField(field,(item->type() == Item::FIELD_ITEM ?
1555
 
                                            ((Item_field *)item)->field :
1556
 
                                            (Field*) 0))))
1557
 
      {
1558
 
        return NULL;
1559
 
      }
1560
 
 
1561
 
      if (item->maybe_null)
1562
 
      {
1563
 
        cr_field->flags &= ~NOT_NULL_FLAG;
1564
 
      }
1565
 
 
1566
 
      alter_info->create_list.push_back(cr_field);
1567
 
    }
 
1613
        field= item->tmp_table_field_from_field_type(&tmp_table, 0);
 
1614
    else
 
1615
      field= create_tmp_field(thd, &tmp_table, item, item->type(),
 
1616
                              (Item ***) 0, &tmp_field, &def_field, 0, 0, 0, 0,
 
1617
                              0);
 
1618
    if (!field ||
 
1619
        !(cr_field=new Create_field(field,(item->type() == Item::FIELD_ITEM ?
 
1620
                                           ((Item_field *)item)->field :
 
1621
                                           (Field*) 0))))
 
1622
      return(0);
 
1623
    if (item->maybe_null)
 
1624
      cr_field->flags &= ~NOT_NULL_FLAG;
 
1625
    alter_info->create_list.push_back(cr_field);
1568
1626
  }
1569
1627
 
1570
1628
  /*
1573
1631
    Note that we either creating (or opening existing) temporary table or
1574
1632
    creating base table on which name we have exclusive lock. So code below
1575
1633
    should not cause deadlocks or races.
 
1634
 
 
1635
    We don't log the statement, it will be logged later.
 
1636
 
 
1637
    If this is a HEAP table, the automatic DELETE FROM which is written to the
 
1638
    binlog when a HEAP table is opened for the first time since startup, must
 
1639
    not be written: 1) it would be wrong (imagine we're in CREATE SELECT: we
 
1640
    don't want to delete from it) 2) it would be written before the CREATE
 
1641
    Table, which is a wrong order. So we keep binary logging disabled when we
 
1642
    open_table().
1576
1643
  */
1577
 
  Table *table= 0;
1578
1644
  {
1579
 
    if (not mysql_create_table_no_lock(session,
1580
 
                                       identifier,
1581
 
                                       create_info,
1582
 
                                       table_proto,
1583
 
                                       alter_info,
1584
 
                                       false,
1585
 
                                       select_field_count,
1586
 
                                       is_if_not_exists))
 
1645
    tmp_disable_binlog(thd);
 
1646
    if (!mysql_create_table_no_lock(thd, create_table->db,
 
1647
                                    create_table->table_name,
 
1648
                                    create_info, alter_info, 0,
 
1649
                                    select_field_count, true))
1587
1650
    {
1588
 
      if (create_info->table_existed && not identifier.isTmp())
 
1651
      if (create_info->table_existed &&
 
1652
          !(create_info->options & HA_LEX_CREATE_TMP_TABLE))
1589
1653
      {
1590
1654
        /*
1591
1655
          This means that someone created table underneath server
1592
1656
          or it was created via different mysqld front-end to the
1593
1657
          cluster. We don't have much options but throw an error.
1594
1658
        */
1595
 
        my_error(ER_TABLE_EXISTS_ERROR, MYF(0), create_table->getTableName());
1596
 
        return NULL;
 
1659
        my_error(ER_TABLE_EXISTS_ERROR, MYF(0), create_table->table_name);
 
1660
        return(0);
1597
1661
      }
1598
1662
 
1599
 
      if (not identifier.isTmp())
 
1663
      if (!(create_info->options & HA_LEX_CREATE_TMP_TABLE))
1600
1664
      {
1601
 
        /* CREATE TABLE... has found that the table already exists for insert and is adapting to use it */
1602
 
        boost::mutex::scoped_lock scopedLock(table::Cache::singleton().mutex());
1603
 
 
1604
 
        if (create_table->table)
 
1665
        pthread_mutex_lock(&LOCK_open);
 
1666
        if (reopen_name_locked_table(thd, create_table, false))
1605
1667
        {
1606
 
          table::Concurrent *concurrent_table= static_cast<table::Concurrent *>(create_table->table);
1607
 
 
1608
 
          if (concurrent_table->reopen_name_locked_table(create_table, session))
1609
 
          {
1610
 
            plugin::StorageEngine::dropTable(*session, identifier);
1611
 
          }
1612
 
          else
1613
 
          {
1614
 
            table= create_table->table;
1615
 
          }
 
1668
          quick_rm_table(create_info->db_type, create_table->db,
 
1669
                         table_case_name(create_info, create_table->table_name),
 
1670
                         0);
1616
1671
        }
1617
1672
        else
1618
 
        {
1619
 
          plugin::StorageEngine::dropTable(*session, identifier);
1620
 
        }
 
1673
          table= create_table->table;
 
1674
        pthread_mutex_unlock(&LOCK_open);
1621
1675
      }
1622
1676
      else
1623
1677
      {
1624
 
        if (not (table= session->openTable(create_table, (bool*) 0,
1625
 
                                           DRIZZLE_OPEN_TEMPORARY_ONLY)) &&
1626
 
            not create_info->table_existed)
 
1678
        if (!(table= open_table(thd, create_table, (bool*) 0,
 
1679
                                DRIZZLE_OPEN_TEMPORARY_ONLY)) &&
 
1680
            !create_info->table_existed)
1627
1681
        {
1628
1682
          /*
1629
1683
            This shouldn't happen as creation of temporary table should make
1630
1684
            it preparable for open. But let us do close_temporary_table() here
1631
1685
            just in case.
1632
1686
          */
1633
 
          session->drop_temporary_table(identifier);
 
1687
          drop_temporary_table(thd, create_table);
1634
1688
        }
1635
1689
      }
1636
1690
    }
1637
 
    if (not table)                                   // open failed
1638
 
      return NULL;
 
1691
    reenable_binlog(thd);
 
1692
    if (!table)                                   // open failed
 
1693
      return(0);
1639
1694
  }
1640
1695
 
1641
1696
  table->reginfo.lock_type=TL_WRITE;
1642
 
  if (! ((*lock)= session->lockTables(&table, 1, DRIZZLE_LOCK_IGNORE_FLUSH, &not_used)))
 
1697
  hooks->prelock(&table, 1);                    // Call prelock hooks
 
1698
  if (! ((*lock)= mysql_lock_tables(thd, &table, 1,
 
1699
                                    DRIZZLE_LOCK_IGNORE_FLUSH, &not_used)) ||
 
1700
        hooks->postlock(&table, 1))
1643
1701
  {
1644
1702
    if (*lock)
1645
1703
    {
1646
 
      session->unlockTables(*lock);
 
1704
      mysql_unlock_tables(thd, *lock);
1647
1705
      *lock= 0;
1648
1706
    }
1649
1707
 
1650
 
    if (not create_info->table_existed)
1651
 
      session->drop_open_table(table, identifier);
1652
 
    return NULL;
 
1708
    if (!create_info->table_existed)
 
1709
      drop_open_table(thd, table, create_table->db, create_table->table_name);
 
1710
    return(0);
1653
1711
  }
1654
 
 
1655
 
  return table;
 
1712
  return(table);
1656
1713
}
1657
1714
 
1658
1715
 
1659
1716
int
1660
 
select_create::prepare(List<Item> &values, Select_Lex_Unit *u)
 
1717
select_create::prepare(List<Item> &values, SELECT_LEX_UNIT *u)
1661
1718
{
1662
 
  DrizzleLock *extra_lock= NULL;
 
1719
  DRIZZLE_LOCK *extra_lock= NULL;
 
1720
  
 
1721
 
 
1722
  TABLEOP_HOOKS *hook_ptr= NULL;
1663
1723
  /*
1664
 
    For replication, the CREATE-SELECT statement is written
1665
 
    in two pieces: the first transaction messsage contains 
1666
 
    the CREATE TABLE statement as a CreateTableStatement message
1667
 
    necessary to create the table.
1668
 
    
1669
 
    The second transaction message contains all the InsertStatement
1670
 
    and associated InsertRecords that should go into the table.
 
1724
    For row-based replication, the CREATE-SELECT statement is written
 
1725
    in two pieces: the first one contain the CREATE TABLE statement
 
1726
    necessary to create the table and the second part contain the rows
 
1727
    that should go into the table.
 
1728
 
 
1729
    For non-temporary tables, the start of the CREATE-SELECT
 
1730
    implicitly commits the previous transaction, and all events
 
1731
    forming the statement will be stored the transaction cache. At end
 
1732
    of the statement, the entire statement is committed as a
 
1733
    transaction, and all events are written to the binary log.
 
1734
 
 
1735
    On the master, the table is locked for the duration of the
 
1736
    statement, but since the CREATE part is replicated as a simple
 
1737
    statement, there is no way to lock the table for accesses on the
 
1738
    slave.  Hence, we have to hold on to the CREATE part of the
 
1739
    statement until the statement has finished.
1671
1740
   */
 
1741
  class MY_HOOKS : public TABLEOP_HOOKS {
 
1742
  public:
 
1743
    MY_HOOKS(select_create *x, TableList *create_table,
 
1744
             TableList *select_tables)
 
1745
      : ptr(x), all_tables(*create_table)
 
1746
      {
 
1747
        all_tables.next_global= select_tables;
 
1748
      }
 
1749
 
 
1750
  private:
 
1751
    virtual int do_postlock(Table **tables, uint32_t count)
 
1752
    {
 
1753
      THD *thd= const_cast<THD*>(ptr->get_thd());
 
1754
      if (int error= decide_logging_format(thd, &all_tables))
 
1755
        return error;
 
1756
 
 
1757
      Table const *const table = *tables;
 
1758
      if (thd->current_stmt_binlog_row_based  &&
 
1759
          !table->s->tmp_table &&
 
1760
          !ptr->get_create_info()->table_existed)
 
1761
      {
 
1762
        ptr->binlog_show_create_table(tables, count);
 
1763
      }
 
1764
      return 0;
 
1765
    }
 
1766
 
 
1767
    select_create *ptr;
 
1768
    TableList all_tables;
 
1769
  };
 
1770
 
 
1771
  MY_HOOKS hooks(this, create_table, select_tables);
 
1772
  hook_ptr= &hooks;
1672
1773
 
1673
1774
  unit= u;
1674
1775
 
1675
 
  if (not (table= create_table_from_items(session, create_info, create_table,
1676
 
                                          table_proto,
1677
 
                                          alter_info, &values,
1678
 
                                          is_if_not_exists,
1679
 
                                          &extra_lock, identifier)))
 
1776
  /*
 
1777
    Start a statement transaction before the create if we are using
 
1778
    row-based replication for the statement.  If we are creating a
 
1779
    temporary table, we need to start a statement transaction.
 
1780
  */
 
1781
  if ((thd->lex->create_info.options & HA_LEX_CREATE_TMP_TABLE) == 0 &&
 
1782
      thd->current_stmt_binlog_row_based)
1680
1783
  {
 
1784
    thd->binlog_start_trans_and_stmt();
 
1785
  }
 
1786
 
 
1787
  if (!(table= create_table_from_items(thd, create_info, create_table,
 
1788
                                       alter_info, &values,
 
1789
                                       &extra_lock, hook_ptr)))
1681
1790
    return(-1);                         // abort() deletes table
1682
 
  }
1683
1791
 
1684
1792
  if (extra_lock)
1685
1793
  {
1686
1794
    assert(m_plock == NULL);
1687
1795
 
1688
 
    if (identifier.isTmp())
 
1796
    if (create_info->options & HA_LEX_CREATE_TMP_TABLE)
1689
1797
      m_plock= &m_lock;
1690
1798
    else
1691
 
      m_plock= &session->extra_lock;
 
1799
      m_plock= &thd->extra_lock;
1692
1800
 
1693
1801
    *m_plock= extra_lock;
1694
1802
  }
1695
1803
 
1696
 
  if (table->getShare()->sizeFields() < values.elements)
 
1804
  if (table->s->fields < values.elements)
1697
1805
  {
1698
1806
    my_error(ER_WRONG_VALUE_COUNT_ON_ROW, MYF(0), 1);
1699
1807
    return(-1);
1700
1808
  }
1701
1809
 
1702
1810
 /* First field to copy */
1703
 
  field= table->getFields() + table->getShare()->sizeFields() - values.elements;
 
1811
  field= table->field+table->s->fields - values.elements;
1704
1812
 
1705
1813
  /* Mark all fields that are given values */
1706
1814
  for (Field **f= field ; *f ; f++)
1707
 
  {
1708
 
    table->setWriteSet((*f)->position());
1709
 
  }
 
1815
    bitmap_set_bit(table->write_set, (*f)->field_index);
1710
1816
 
1711
1817
  /* Don't set timestamp if used */
1712
1818
  table->timestamp_field_type= TIMESTAMP_NO_AUTO_SET;
1713
1819
  table->next_number_field=table->found_next_number_field;
1714
1820
 
1715
 
  table->restoreRecordAsDefault();      // Get empty record
1716
 
  session->cuted_fields=0;
 
1821
  restore_record(table,s->default_values);      // Get empty record
 
1822
  thd->cuted_fields=0;
1717
1823
  if (info.ignore || info.handle_duplicates != DUP_ERROR)
1718
 
    table->cursor->extra(HA_EXTRA_IGNORE_DUP_KEY);
 
1824
    table->file->extra(HA_EXTRA_IGNORE_DUP_KEY);
1719
1825
  if (info.handle_duplicates == DUP_REPLACE)
1720
 
    table->cursor->extra(HA_EXTRA_WRITE_CAN_REPLACE);
 
1826
    table->file->extra(HA_EXTRA_WRITE_CAN_REPLACE);
1721
1827
  if (info.handle_duplicates == DUP_UPDATE)
1722
 
    table->cursor->extra(HA_EXTRA_INSERT_WITH_UPDATE);
1723
 
  table->cursor->ha_start_bulk_insert((ha_rows) 0);
1724
 
  session->abort_on_warning= !info.ignore;
1725
 
  if (check_that_all_fields_are_given_values(session, table, table_list))
 
1828
    table->file->extra(HA_EXTRA_INSERT_WITH_UPDATE);
 
1829
  table->file->ha_start_bulk_insert((ha_rows) 0);
 
1830
  thd->abort_on_warning= !info.ignore;
 
1831
  if (check_that_all_fields_are_given_values(thd, table, table_list))
1726
1832
    return(1);
1727
1833
  table->mark_columns_needed_for_insert();
1728
 
  table->cursor->extra(HA_EXTRA_WRITE_CACHE);
 
1834
  table->file->extra(HA_EXTRA_WRITE_CACHE);
1729
1835
  return(0);
1730
1836
}
1731
1837
 
 
1838
void
 
1839
select_create::binlog_show_create_table(Table **tables, uint32_t count)
 
1840
{
 
1841
  /*
 
1842
    Note 1: In RBR mode, we generate a CREATE TABLE statement for the
 
1843
    created table by calling store_create_info() (behaves as SHOW
 
1844
    CREATE TABLE).  In the event of an error, nothing should be
 
1845
    written to the binary log, even if the table is non-transactional;
 
1846
    therefore we pretend that the generated CREATE TABLE statement is
 
1847
    for a transactional table.  The event will then be put in the
 
1848
    transaction cache, and any subsequent events (e.g., table-map
 
1849
    events and binrow events) will also be put there.  We can then use
 
1850
    ha_autocommit_or_rollback() to either throw away the entire
 
1851
    kaboodle of events, or write them to the binary log.
 
1852
 
 
1853
    We write the CREATE TABLE statement here and not in prepare()
 
1854
    since there potentially are sub-selects or accesses to information
 
1855
    schema that will do a close_thread_tables(), destroying the
 
1856
    statement transaction cache.
 
1857
  */
 
1858
  assert(thd->current_stmt_binlog_row_based);
 
1859
  assert(tables && *tables && count > 0);
 
1860
 
 
1861
  char buf[2048];
 
1862
  String query(buf, sizeof(buf), system_charset_info);
 
1863
  int result;
 
1864
  TableList tmp_table_list;
 
1865
 
 
1866
  memset(&tmp_table_list, 0, sizeof(tmp_table_list));
 
1867
  tmp_table_list.table = *tables;
 
1868
  query.length(0);      // Have to zero it since constructor doesn't
 
1869
 
 
1870
  result= store_create_info(thd, &tmp_table_list, &query, create_info);
 
1871
  assert(result == 0); /* store_create_info() always return 0 */
 
1872
 
 
1873
  thd->binlog_query(THD::STMT_QUERY_TYPE,
 
1874
                    query.ptr(), query.length(),
 
1875
                    /* is_trans */ true,
 
1876
                    /* suppress_use */ false);
 
1877
}
 
1878
 
1732
1879
void select_create::store_values(List<Item> &values)
1733
1880
{
1734
 
  fill_record(session, field, values, true);
 
1881
  fill_record(thd, field, values, 1);
1735
1882
}
1736
1883
 
1737
1884
 
1738
1885
void select_create::send_error(uint32_t errcode,const char *err)
1739
1886
{
 
1887
  
 
1888
 
1740
1889
  /*
1741
1890
    This will execute any rollbacks that are necessary before writing
1742
1891
    the transcation cache.
1748
1897
    written to the binary log.
1749
1898
 
1750
1899
  */
 
1900
  tmp_disable_binlog(thd);
1751
1901
  select_insert::send_error(errcode, err);
 
1902
  reenable_binlog(thd);
1752
1903
 
1753
1904
  return;
1754
1905
}
1766
1917
      tables.  This can fail, but we should unlock the table
1767
1918
      nevertheless.
1768
1919
    */
1769
 
    if (!table->getShare()->getType())
 
1920
    if (!table->s->tmp_table)
1770
1921
    {
1771
 
      TransactionServices &transaction_services= TransactionServices::singleton();
1772
 
      transaction_services.autocommitOrRollback(session, 0);
1773
 
      (void) session->endActiveTransaction();
 
1922
      ha_autocommit_or_rollback(thd, 0);
 
1923
      end_active_trans(thd);
1774
1924
    }
1775
1925
 
1776
 
    table->cursor->extra(HA_EXTRA_NO_IGNORE_DUP_KEY);
1777
 
    table->cursor->extra(HA_EXTRA_WRITE_CANNOT_REPLACE);
 
1926
    table->file->extra(HA_EXTRA_NO_IGNORE_DUP_KEY);
 
1927
    table->file->extra(HA_EXTRA_WRITE_CANNOT_REPLACE);
1778
1928
    if (m_plock)
1779
1929
    {
1780
 
      session->unlockTables(*m_plock);
 
1930
      mysql_unlock_tables(thd, *m_plock);
1781
1931
      *m_plock= NULL;
1782
1932
      m_plock= NULL;
1783
1933
    }
1788
1938
 
1789
1939
void select_create::abort()
1790
1940
{
 
1941
  
 
1942
 
1791
1943
  /*
1792
1944
    In select_insert::abort() we roll back the statement, including
1793
1945
    truncating the transaction cache of the binary log. To do this, we
1803
1955
    of the table succeeded or not, since we need to reset the binary
1804
1956
    log state.
1805
1957
  */
 
1958
  tmp_disable_binlog(thd);
1806
1959
  select_insert::abort();
 
1960
  thd->transaction.stmt.modified_non_trans_table= false;
 
1961
  reenable_binlog(thd);
 
1962
 
1807
1963
 
1808
1964
  if (m_plock)
1809
1965
  {
1810
 
    session->unlockTables(*m_plock);
 
1966
    mysql_unlock_tables(thd, *m_plock);
1811
1967
    *m_plock= NULL;
1812
1968
    m_plock= NULL;
1813
1969
  }
1814
1970
 
1815
1971
  if (table)
1816
1972
  {
1817
 
    table->cursor->extra(HA_EXTRA_NO_IGNORE_DUP_KEY);
1818
 
    table->cursor->extra(HA_EXTRA_WRITE_CANNOT_REPLACE);
1819
 
    if (not create_info->table_existed)
1820
 
      session->drop_open_table(table, identifier);
1821
 
    table= NULL;                                    // Safety
 
1973
    table->file->extra(HA_EXTRA_NO_IGNORE_DUP_KEY);
 
1974
    table->file->extra(HA_EXTRA_WRITE_CANNOT_REPLACE);
 
1975
    if (!create_info->table_existed)
 
1976
      drop_open_table(thd, table, create_table->db, create_table->table_name);
 
1977
    table=0;                                    // Safety
1822
1978
  }
 
1979
  return;
1823
1980
}
1824
1981
 
1825
 
} /* namespace drizzled */
 
1982
 
 
1983
/*****************************************************************************
 
1984
  Instansiate templates
 
1985
*****************************************************************************/
 
1986
 
 
1987
#ifdef HAVE_EXPLICIT_TEMPLATE_INSTANTIATION
 
1988
template class List_iterator_fast<List_item>;
 
1989
#endif /* HAVE_EXPLICIT_TEMPLATE_INSTANTIATION */