← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to drizzled/sql_insert.cc

code clean move Item_func_num1 and Item_func_connection_id to functions directory

Show diffs side-by-side

added added

removed removed

Lines of Context:
drizzled/sql_insert.cc
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
 
namespace drizzled
36
 
{
37
 
 
38
 
extern plugin::StorageEngine *heap_engine;
39
 
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
 
40
42
 
41
43
/*
42
44
  Check if insert fields are correct.
43
45
 
44
46
  SYNOPSIS
45
47
    check_insert_fields()
46
 
    session                         The current thread.
 
48
    thd                         The current thread.
47
49
    table                       The table for insert.
48
50
    fields                      The insert fields.
49
51
    values                      The insert values.
59
61
    -1          Error
60
62
*/
61
63
 
62
 
static int check_insert_fields(Session *session, TableList *table_list,
 
64
static int check_insert_fields(THD *thd, TableList *table_list,
63
65
                               List<Item> &fields, List<Item> &values,
64
66
                               bool check_unique,
65
 
                               table_map *)
 
67
                               table_map *map __attribute__((unused)))
66
68
{
67
69
  Table *table= table_list->table;
68
70
 
69
71
  if (fields.elements == 0 && values.elements != 0)
70
72
  {
71
 
    if (values.elements != table->getShare()->sizeFields())
 
73
    if (values.elements != table->s->fields)
72
74
    {
73
75
      my_error(ER_WRONG_VALUE_COUNT_ON_ROW, MYF(0), 1L);
74
76
      return -1;
79
81
      No fields are provided so all fields must be provided in the values.
80
82
      Thus we set all bits in the write set.
81
83
    */
82
 
    table->setWriteSet();
 
84
    bitmap_set_all(table->write_set);
83
85
  }
84
86
  else
85
87
  {                                             // Part field list
86
 
    Select_Lex *select_lex= &session->lex->select_lex;
 
88
    SELECT_LEX *select_lex= &thd->lex->select_lex;
87
89
    Name_resolution_context *context= &select_lex->context;
88
90
    Name_resolution_context_state ctx_state;
89
91
    int res;
94
96
      return -1;
95
97
    }
96
98
 
97
 
    session->dup_field= 0;
 
99
    thd->dup_field= 0;
98
100
 
99
101
    /* Save the state of the current name resolution context. */
100
102
    ctx_state.save_state(context, table_list);
105
107
    */
106
108
    table_list->next_local= 0;
107
109
    context->resolve_in_table_list_only(table_list);
108
 
    res= setup_fields(session, 0, fields, MARK_COLUMNS_WRITE, 0, 0);
 
110
    res= setup_fields(thd, 0, fields, MARK_COLUMNS_WRITE, 0, 0);
109
111
 
110
112
    /* Restore the current context. */
111
113
    ctx_state.restore_state(context, table_list);
113
115
    if (res)
114
116
      return -1;
115
117
 
116
 
    if (check_unique && session->dup_field)
 
118
    if (check_unique && thd->dup_field)
117
119
    {
118
 
      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);
119
121
      return -1;
120
122
    }
121
123
    if (table->timestamp_field) // Don't automaticly set timestamp if used
122
124
    {
123
 
      if (table->timestamp_field->isWriteSet())
124
 
      {
 
125
      if (bitmap_is_set(table->write_set,
 
126
                        table->timestamp_field->field_index))
125
127
        clear_timestamp_auto_bits(table->timestamp_field_type,
126
128
                                  TIMESTAMP_AUTO_SET_ON_INSERT);
127
 
      }
128
129
      else
129
130
      {
130
 
        table->setWriteSet(table->timestamp_field->field_index);
 
131
        bitmap_set_bit(table->write_set,
 
132
                       table->timestamp_field->field_index);
131
133
      }
132
134
    }
133
135
  }
141
143
 
142
144
  SYNOPSIS
143
145
    check_update_fields()
144
 
    session                         The current thread.
 
146
    thd                         The current thread.
145
147
    insert_table_list           The insert table list.
146
148
    table                       The table for update.
147
149
    update_fields               The update fields.
155
157
    -1          Error
156
158
*/
157
159
 
158
 
static int check_update_fields(Session *session, TableList *insert_table_list,
 
160
static int check_update_fields(THD *thd, TableList *insert_table_list,
159
161
                               List<Item> &update_fields,
160
 
                               table_map *)
 
162
                               table_map *map __attribute__((unused)))
161
163
{
162
164
  Table *table= insert_table_list->table;
163
165
  bool timestamp_mark= false;
168
170
      Unmark the timestamp field so that we can check if this is modified
169
171
      by update_fields
170
172
    */
171
 
    timestamp_mark= table->write_set->testAndClear(table->timestamp_field->field_index);
 
173
    timestamp_mark= bitmap_test_and_clear(table->write_set,
 
174
                                          table->timestamp_field->field_index);
172
175
  }
173
176
 
174
177
  /* Check the fields we are going to modify */
175
 
  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))
176
179
    return -1;
177
180
 
178
181
  if (table->timestamp_field)
179
182
  {
180
183
    /* Don't set timestamp column if this is modified. */
181
 
    if (table->timestamp_field->isWriteSet())
182
 
    {
 
184
    if (bitmap_is_set(table->write_set,
 
185
                      table->timestamp_field->field_index))
183
186
      clear_timestamp_auto_bits(table->timestamp_field_type,
184
187
                                TIMESTAMP_AUTO_SET_ON_UPDATE);
185
 
    }
186
 
 
187
188
    if (timestamp_mark)
188
 
    {
189
 
      table->setWriteSet(table->timestamp_field->field_index);
190
 
    }
 
189
      bitmap_set_bit(table->write_set,
 
190
                     table->timestamp_field->field_index);
191
191
  }
192
192
  return 0;
193
193
}
202
202
*/
203
203
 
204
204
static
205
 
void upgrade_lock_type(Session *,
 
205
void upgrade_lock_type(THD *thd __attribute__((unused)),
206
206
                       thr_lock_type *lock_type,
207
207
                       enum_duplicates duplic,
208
 
                       bool )
 
208
                       bool is_multi_insert __attribute__((unused)))
209
209
{
210
210
  if (duplic == DUP_UPDATE ||
211
211
      (duplic == DUP_REPLACE && *lock_type == TL_WRITE_CONCURRENT_INSERT))
224
224
  end of dispatch_command().
225
225
*/
226
226
 
227
 
bool mysql_insert(Session *session,TableList *table_list,
 
227
bool mysql_insert(THD *thd,TableList *table_list,
228
228
                  List<Item> &fields,
229
229
                  List<List_item> &values_list,
230
230
                  List<Item> &update_fields,
235
235
  int error;
236
236
  bool transactional_table, joins_freed= false;
237
237
  bool changed;
 
238
  bool was_insert_delayed= (table_list->lock_type ==  TL_WRITE_DELAYED);
238
239
  uint32_t value_count;
239
240
  ulong counter = 1;
240
241
  uint64_t id;
241
 
  CopyInfo info;
 
242
  COPY_INFO info;
242
243
  Table *table= 0;
243
244
  List_iterator_fast<List_item> its(values_list);
244
245
  List_item *values;
246
247
  Name_resolution_context_state ctx_state;
247
248
  thr_lock_type lock_type;
248
249
  Item *unused_conds= 0;
249
 
 
 
250
  
250
251
 
251
252
  /*
252
253
    Upgrade lock type if the requested lock is incompatible with
253
254
    the current connection mode or table operation.
254
255
  */
255
 
  upgrade_lock_type(session, &table_list->lock_type, duplic,
 
256
  upgrade_lock_type(thd, &table_list->lock_type, duplic,
256
257
                    values_list.elements > 1);
257
258
 
258
 
  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))
259
267
  {
260
 
    DRIZZLE_INSERT_DONE(1, 0);
261
 
    return true;
 
268
    my_error(ER_DELAYED_INSERT_TABLE_LOCKED, MYF(0),
 
269
             table_list->table_name);
 
270
    return(true);
262
271
  }
263
272
 
 
273
  {
 
274
    if (open_and_lock_tables(thd, table_list))
 
275
      return(true);
 
276
  }
264
277
  lock_type= table_list->lock_type;
265
278
 
266
 
  session->set_proc_info("init");
267
 
  session->used_tables=0;
 
279
  thd->set_proc_info("init");
 
280
  thd->used_tables=0;
268
281
  values= its++;
269
282
  value_count= values->elements;
270
283
 
271
 
  if (mysql_prepare_insert(session, table_list, table, fields, values,
 
284
  if (mysql_prepare_insert(thd, table_list, table, fields, values,
272
285
                           update_fields, update_values, duplic, &unused_conds,
273
286
                           false,
274
287
                           (fields.elements || !value_count ||
278
291
  /* mysql_prepare_insert set table_list->table if it was not set */
279
292
  table= table_list->table;
280
293
 
281
 
  context= &session->lex->select_lex.context;
 
294
  context= &thd->lex->select_lex.context;
282
295
  /*
283
296
    These three asserts test the hypothesis that the resetting of the name
284
297
    resolution context below is not necessary at all since the list of local
306
319
      my_error(ER_WRONG_VALUE_COUNT_ON_ROW, MYF(0), counter);
307
320
      goto abort;
308
321
    }
309
 
    if (setup_fields(session, 0, *values, MARK_COLUMNS_READ, 0, 0))
 
322
    if (setup_fields(thd, 0, *values, MARK_COLUMNS_READ, 0, 0))
310
323
      goto abort;
311
324
  }
312
325
  its.rewind ();
313
 
 
 
326
 
314
327
  /* Restore the current context. */
315
328
  ctx_state.restore_state(context, table_list);
316
329
 
317
330
  /*
318
 
    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
319
332
  */
 
333
  memset(&info, 0, sizeof(info));
320
334
  info.ignore= ignore;
321
335
  info.handle_duplicates=duplic;
322
336
  info.update_fields= &update_fields;
327
341
    For single line insert, generate an error if try to set a NOT NULL field
328
342
    to NULL.
329
343
  */
330
 
  session->count_cuted_fields= ignore ? CHECK_FIELD_WARN : CHECK_FIELD_ERROR_FOR_NULL;
331
 
 
332
 
  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;
333
349
  table->next_number_field=table->found_next_number_field;
334
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
 
335
357
  error=0;
336
 
  session->set_proc_info("update");
 
358
  thd->set_proc_info("update");
337
359
  if (duplic == DUP_REPLACE)
338
 
    table->cursor->extra(HA_EXTRA_WRITE_CAN_REPLACE);
 
360
    table->file->extra(HA_EXTRA_WRITE_CAN_REPLACE);
339
361
  if (duplic == DUP_UPDATE)
340
 
    table->cursor->extra(HA_EXTRA_INSERT_WITH_UPDATE);
 
362
    table->file->extra(HA_EXTRA_INSERT_WITH_UPDATE);
341
363
  {
342
364
    if (duplic != DUP_ERROR || ignore)
343
 
      table->cursor->extra(HA_EXTRA_IGNORE_DUP_KEY);
344
 
    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);
345
367
  }
346
368
 
347
369
 
348
 
  session->abort_on_warning= !ignore;
 
370
  thd->abort_on_warning= !ignore;
349
371
 
350
372
  table->mark_columns_needed_for_insert();
351
373
 
353
375
  {
354
376
    if (fields.elements || !value_count)
355
377
    {
356
 
      table->restoreRecordAsDefault();  // Get empty record
357
 
      if (fill_record(session, fields, *values))
 
378
      restore_record(table,s->default_values);  // Get empty record
 
379
      if (fill_record(thd, fields, *values, 0))
358
380
      {
359
 
        if (values_list.elements != 1 && ! session->is_error())
 
381
        if (values_list.elements != 1 && ! thd->is_error())
360
382
        {
361
383
          info.records++;
362
384
          continue;
363
385
        }
364
386
        /*
365
 
          TODO: set session->abort_on_warning if values_list.elements == 1
 
387
          TODO: set thd->abort_on_warning if values_list.elements == 1
366
388
          and check that all items return warning in case of problem with
367
389
          storing field.
368
390
        */
372
394
    }
373
395
    else
374
396
    {
375
 
      table->restoreRecordAsDefault();  // Get empty record
376
 
 
377
 
      if (fill_record(session, table->getFields(), *values))
378
 
      {
379
 
        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())
380
411
        {
381
412
          info.records++;
382
413
          continue;
386
417
      }
387
418
    }
388
419
 
389
 
    // Release latches in case bulk insert takes a long time
390
 
    plugin::TransactionalStorageEngine::releaseTemporaryLatches(session);
391
 
 
392
 
    error=write_record(session, table ,&info);
 
420
    error=write_record(thd, table ,&info);
393
421
    if (error)
394
422
      break;
395
 
    session->row_count++;
 
423
    thd->row_count++;
396
424
  }
397
425
 
398
 
  free_underlaid_joins(session, &session->lex->select_lex);
 
426
  free_underlaid_joins(thd, &thd->lex->select_lex);
399
427
  joins_freed= true;
400
428
 
401
429
  /*
407
435
      Do not do this release if this is a delayed insert, it would steal
408
436
      auto_inc values from the delayed_insert thread as they share Table.
409
437
    */
410
 
    table->cursor->ha_release_auto_increment();
411
 
    if (table->cursor->ha_end_bulk_insert() && !error)
 
438
    table->file->ha_release_auto_increment();
 
439
    if (table->file->ha_end_bulk_insert() && !error)
412
440
    {
413
 
      table->print_error(errno,MYF(0));
 
441
      table->file->print_error(my_errno,MYF(0));
414
442
      error=1;
415
443
    }
416
444
    if (duplic != DUP_ERROR || ignore)
417
 
      table->cursor->extra(HA_EXTRA_NO_IGNORE_DUP_KEY);
418
 
 
419
 
    transactional_table= table->cursor->has_transactions();
420
 
 
421
 
    changed= (info.copied || info.deleted || info.updated);
422
 
    if ((changed && error <= 0) || session->transaction.stmt.hasModifiedNonTransData())
423
 
    {
424
 
      if (session->transaction.stmt.hasModifiedNonTransData())
425
 
        session->transaction.all.markModifiedNonTransData();
426
 
    }
427
 
    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);
428
502
 
429
503
  }
430
 
  session->set_proc_info("end");
 
504
  thd->set_proc_info("end");
431
505
  /*
432
506
    We'll report to the client this id:
433
507
    - if the table contains an autoincrement column and we successfully
438
512
    inserted, the id of the last "inserted" row (if IGNORE, that value may not
439
513
    have been really inserted but ignored).
440
514
  */
441
 
  id= (session->first_successful_insert_id_in_cur_stmt > 0) ?
442
 
    session->first_successful_insert_id_in_cur_stmt :
443
 
    (session->arg_of_last_insert_id_function ?
444
 
     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 :
445
519
     ((table->next_number_field && info.copied) ?
446
520
     table->next_number_field->val_int() : 0));
447
521
  table->next_number_field=0;
448
 
  session->count_cuted_fields= CHECK_FIELD_IGNORE;
 
522
  thd->count_cuted_fields= CHECK_FIELD_IGNORE;
449
523
  table->auto_increment_field_not_null= false;
450
524
  if (duplic == DUP_REPLACE)
451
 
    table->cursor->extra(HA_EXTRA_WRITE_CANNOT_REPLACE);
 
525
    table->file->extra(HA_EXTRA_WRITE_CANNOT_REPLACE);
452
526
 
453
527
  if (error)
454
528
    goto abort;
455
 
  if (values_list.elements == 1 && (!(session->options & OPTION_WARNINGS) ||
456
 
                                    !session->cuted_fields))
 
529
  if (values_list.elements == 1 && (!(thd->options & OPTION_WARNINGS) ||
 
530
                                    !thd->cuted_fields))
457
531
  {
458
 
    session->row_count_func= info.copied + info.deleted + info.updated;
459
 
    session->my_ok((ulong) session->row_count_func,
460
 
                   info.copied + info.deleted + info.touched, id);
 
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);
461
536
  }
462
537
  else
463
538
  {
464
539
    char buff[160];
 
540
    ha_rows updated=((thd->client_capabilities & CLIENT_FOUND_ROWS) ?
 
541
                     info.touched : info.updated);
465
542
    if (ignore)
466
 
      snprintf(buff, sizeof(buff), ER(ER_INSERT_INFO), (ulong) info.records,
467
 
              (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);
468
545
    else
469
 
      snprintf(buff, sizeof(buff), ER(ER_INSERT_INFO), (ulong) info.records,
470
 
              (ulong) (info.deleted + info.updated), (ulong) session->cuted_fields);
471
 
    session->row_count_func= info.copied + info.deleted + info.updated;
472
 
    session->my_ok((ulong) session->row_count_func,
473
 
                   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);
474
550
  }
475
 
  session->status_var.inserted_row_count+= session->row_count_func;
476
 
  session->abort_on_warning= 0;
477
 
  DRIZZLE_INSERT_DONE(0, session->row_count_func);
478
 
  return false;
 
551
  thd->abort_on_warning= 0;
 
552
  DRIZZLE_INSERT_END();
 
553
  return(false);
479
554
 
480
555
abort:
481
556
  if (table != NULL)
482
 
    table->cursor->ha_release_auto_increment();
 
557
    table->file->ha_release_auto_increment();
483
558
  if (!joins_freed)
484
 
    free_underlaid_joins(session, &session->lex->select_lex);
485
 
  session->abort_on_warning= 0;
486
 
  DRIZZLE_INSERT_DONE(1, 0);
487
 
  return true;
 
559
    free_underlaid_joins(thd, &thd->lex->select_lex);
 
560
  thd->abort_on_warning= 0;
 
561
  DRIZZLE_INSERT_END();
 
562
  return(true);
488
563
}
489
564
 
490
565
 
493
568
 
494
569
  SYNOPSIS
495
570
     mysql_prepare_insert_check_table()
496
 
     session            Thread handle
 
571
     thd                Thread handle
497
572
     table_list         Table list
498
573
     fields             List of fields to be updated
499
574
     where              Pointer to where clause
504
579
     true  ERROR
505
580
*/
506
581
 
507
 
static bool mysql_prepare_insert_check_table(Session *session, TableList *table_list,
508
 
                                             List<Item> &,
 
582
static bool mysql_prepare_insert_check_table(THD *thd, TableList *table_list,
 
583
                                             List<Item> &fields __attribute__((unused)),
509
584
                                             bool select_insert)
510
585
{
511
 
 
 
586
  
512
587
 
513
588
  /*
514
589
     first table in list is the one we'll INSERT into, requires INSERT_ACL.
517
592
     than INSERT.
518
593
  */
519
594
 
520
 
  if (setup_tables_and_check_access(session, &session->lex->select_lex.context,
521
 
                                    &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,
522
597
                                    table_list,
523
 
                                    &session->lex->select_lex.leaf_tables,
 
598
                                    &thd->lex->select_lex.leaf_tables,
524
599
                                    select_insert))
525
600
    return(true);
526
601
 
533
608
 
534
609
  SYNOPSIS
535
610
    mysql_prepare_insert()
536
 
    session                     Thread handler
 
611
    thd                 Thread handler
537
612
    table_list          Global/local table list
538
613
    table               Table to insert into (can be NULL if table should
539
 
                        be taken from table_list->table)
 
614
                        be taken from table_list->table)    
540
615
    where               Where clause (for insert ... select)
541
616
    select_insert       true if INSERT ... SELECT statement
542
 
    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 
543
618
                        given values.
544
 
    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 
545
620
                        assigned as an error (true) or as a warning (false).
546
621
 
547
622
  TODO (in far future)
553
628
  WARNING
554
629
    You MUST set table->insert_values to 0 after calling this function
555
630
    before releasing the table object.
556
 
 
 
631
  
557
632
  RETURN VALUE
558
633
    false OK
559
634
    true  error
560
635
*/
561
636
 
562
 
bool mysql_prepare_insert(Session *session, TableList *table_list,
 
637
bool mysql_prepare_insert(THD *thd, TableList *table_list,
563
638
                          Table *table, List<Item> &fields, List_item *values,
564
639
                          List<Item> &update_fields, List<Item> &update_values,
565
640
                          enum_duplicates duplic,
566
 
                          COND **,
 
641
                          COND **where __attribute__((unused)),
567
642
                          bool select_insert,
568
643
                          bool check_fields, bool abort_on_warning)
569
644
{
570
 
  Select_Lex *select_lex= &session->lex->select_lex;
 
645
  SELECT_LEX *select_lex= &thd->lex->select_lex;
571
646
  Name_resolution_context *context= &select_lex->context;
572
647
  Name_resolution_context_state ctx_state;
573
648
  bool insert_into_view= (0 != 0);
574
649
  bool res= 0;
575
650
  table_map map= 0;
576
 
 
 
651
  
577
652
  /* INSERT should have a SELECT or VALUES clause */
578
653
  assert (!select_insert || !values);
579
654
 
580
655
  /*
581
656
    For subqueries in VALUES() we should not see the table in which we are
582
657
    inserting (for INSERT ... SELECT this is done by changing table_list,
583
 
    because INSERT ... SELECT share Select_Lex it with SELECT.
 
658
    because INSERT ... SELECT share SELECT_LEX it with SELECT.
584
659
  */
585
660
  if (!select_insert)
586
661
  {
587
 
    for (Select_Lex_Unit *un= select_lex->first_inner_unit();
 
662
    for (SELECT_LEX_UNIT *un= select_lex->first_inner_unit();
588
663
         un;
589
664
         un= un->next_unit())
590
665
    {
591
 
      for (Select_Lex *sl= un->first_select();
 
666
      for (SELECT_LEX *sl= un->first_select();
592
667
           sl;
593
668
           sl= sl->next_select())
594
669
      {
600
675
  if (duplic == DUP_UPDATE)
601
676
  {
602
677
    /* it should be allocated before Item::fix_fields() */
603
 
    if (table_list->set_insert_values(session->mem_root))
 
678
    if (table_list->set_insert_values(thd->mem_root))
604
679
      return(true);
605
680
  }
606
681
 
607
 
  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))
608
683
    return(true);
609
684
 
610
685
 
624
699
    table_list->next_local= 0;
625
700
    context->resolve_in_table_list_only(table_list);
626
701
 
627
 
    res= check_insert_fields(session, context->table_list, fields, *values,
 
702
    res= check_insert_fields(thd, context->table_list, fields, *values,
628
703
                             !insert_into_view, &map) ||
629
 
      setup_fields(session, 0, *values, MARK_COLUMNS_READ, 0, 0);
 
704
      setup_fields(thd, 0, *values, MARK_COLUMNS_READ, 0, 0);
630
705
 
631
706
    if (!res && check_fields)
632
707
    {
633
 
      bool saved_abort_on_warning= session->abort_on_warning;
634
 
      session->abort_on_warning= abort_on_warning;
635
 
      res= check_that_all_fields_are_given_values(session,
636
 
                                                  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 : 
637
712
                                                  context->table_list->table,
638
713
                                                  context->table_list);
639
 
      session->abort_on_warning= saved_abort_on_warning;
 
714
      thd->abort_on_warning= saved_abort_on_warning;
640
715
    }
641
716
 
642
717
    if (!res && duplic == DUP_UPDATE)
643
718
    {
644
 
      res= check_update_fields(session, context->table_list, update_fields, &map);
 
719
      res= check_update_fields(thd, context->table_list, update_fields, &map);
645
720
    }
646
721
 
647
722
    /* Restore the current context. */
648
723
    ctx_state.restore_state(context, table_list);
649
724
 
650
725
    if (!res)
651
 
      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);
652
727
  }
653
728
 
654
729
  if (res)
660
735
  if (!select_insert)
661
736
  {
662
737
    TableList *duplicate;
663
 
    if ((duplicate= unique_table(table_list, table_list->next_global, true)))
 
738
    if ((duplicate= unique_table(thd, table_list, table_list->next_global, 1)))
664
739
    {
665
 
      my_error(ER_UPDATE_TABLE_USED, MYF(0), table_list->alias);
666
 
 
667
 
      return true;
 
740
      update_non_unique_table_error(table_list, "INSERT", duplicate);
 
741
      return(true);
668
742
    }
669
743
  }
670
744
  if (duplic == DUP_UPDATE || duplic == DUP_REPLACE)
671
745
    table->prepare_for_position();
672
 
 
673
 
  return false;
 
746
  return(false);
674
747
}
675
748
 
676
749
 
678
751
 
679
752
static int last_uniq_key(Table *table,uint32_t keynr)
680
753
{
681
 
  while (++keynr < table->getShare()->sizeKeys())
 
754
  while (++keynr < table->s->keys)
682
755
    if (table->key_info[keynr].flags & HA_NOSAME)
683
756
      return 0;
684
757
  return 1;
691
764
 
692
765
  SYNOPSIS
693
766
     write_record()
694
 
      session   - thread context
 
767
      thd   - thread context
695
768
      table - table to which record should be written
696
 
      info  - CopyInfo structure describing handling of duplicates
 
769
      info  - COPY_INFO structure describing handling of duplicates
697
770
              and which is used for counting number of records inserted
698
771
              and deleted.
699
772
 
703
776
    then both on update triggers will work instead. Similarly both on
704
777
    delete triggers will be invoked if we will delete conflicting records.
705
778
 
706
 
    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
707
780
    transactions.
708
781
 
709
782
  RETURN VALUE
712
785
*/
713
786
 
714
787
 
715
 
int write_record(Session *session, Table *table,CopyInfo *info)
 
788
int write_record(THD *thd, Table *table,COPY_INFO *info)
716
789
{
717
790
  int error;
718
 
  std::vector<unsigned char> key;
719
 
  MyBitmap *save_read_set, *save_write_set;
720
 
  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;
721
794
  uint64_t insert_id_for_cur_row= 0;
722
 
 
 
795
  
723
796
 
724
797
  info->records++;
725
798
  save_read_set=  table->read_set;
726
799
  save_write_set= table->write_set;
727
800
 
728
 
  if (info->handle_duplicates == DUP_REPLACE || info->handle_duplicates == DUP_UPDATE)
 
801
  if (info->handle_duplicates == DUP_REPLACE ||
 
802
      info->handle_duplicates == DUP_UPDATE)
729
803
  {
730
 
    while ((error=table->cursor->insertRecord(table->getInsertRecord())))
 
804
    while ((error=table->file->ha_write_row(table->record[0])))
731
805
    {
732
806
      uint32_t key_nr;
733
807
      /*
734
808
        If we do more than one iteration of this loop, from the second one the
735
809
        row will have an explicit value in the autoinc field, which was set at
736
810
        the first call of handler::update_auto_increment(). So we must save
737
 
        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
738
812
        0.
739
813
      */
740
 
      if (table->cursor->insert_id_for_cur_row > 0)
741
 
        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;
742
816
      else
743
 
        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;
744
818
      bool is_duplicate_key_error;
745
 
      if (table->cursor->is_fatal_error(error, HA_CHECK_DUP))
 
819
      if (table->file->is_fatal_error(error, HA_CHECK_DUP))
746
820
        goto err;
747
 
      is_duplicate_key_error= table->cursor->is_fatal_error(error, 0);
 
821
      is_duplicate_key_error= table->file->is_fatal_error(error, 0);
748
822
      if (!is_duplicate_key_error)
749
823
      {
750
824
        /*
756
830
          goto gok_or_after_err; /* Ignoring a not fatal error, return 0 */
757
831
        goto err;
758
832
      }
759
 
      if ((int) (key_nr = table->get_dup_key(error)) < 0)
 
833
      if ((int) (key_nr = table->file->get_dup_key(error)) < 0)
760
834
      {
761
835
        error= HA_ERR_FOUND_DUPP_KEY;         /* Database can't find key */
762
836
        goto err;
770
844
      */
771
845
      if (info->handle_duplicates == DUP_REPLACE &&
772
846
          table->next_number_field &&
773
 
          key_nr == table->getShare()->next_number_index &&
 
847
          key_nr == table->s->next_number_index &&
774
848
          (insert_id_for_cur_row > 0))
775
849
        goto err;
776
 
      if (table->cursor->getEngine()->check_flag(HTON_BIT_DUPLICATE_POS))
 
850
      if (table->file->ha_table_flags() & HA_DUPLICATE_POS)
777
851
      {
778
 
        if (table->cursor->rnd_pos(table->getUpdateRecord(),table->cursor->dup_ref))
 
852
        if (table->file->rnd_pos(table->record[1],table->file->dup_ref))
779
853
          goto err;
780
854
      }
781
855
      else
782
856
      {
783
 
        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 */
784
858
        {
785
 
          error=errno;
 
859
          error=my_errno;
786
860
          goto err;
787
861
        }
788
862
 
789
 
        if (not key.size())
 
863
        if (!key)
790
864
        {
791
 
          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
          }
792
871
        }
793
 
        key_copy(&key[0], table->getInsertRecord(), table->key_info+key_nr, 0);
794
 
        if ((error=(table->cursor->index_read_idx_map(table->getUpdateRecord(),key_nr,
795
 
                                                    &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,
796
875
                                                    HA_READ_KEY_EXACT))))
797
876
          goto err;
798
877
      }
803
882
          that matches, is updated. If update causes a conflict again,
804
883
          an error is returned
805
884
        */
806
 
        assert(table->insert_values.size());
807
 
        table->storeRecordAsInsert();
808
 
        table->restoreRecord();
 
885
        assert(table->insert_values != NULL);
 
886
        store_record(table,insert_values);
 
887
        restore_record(table,record[1]);
809
888
        assert(info->update_fields->elements ==
810
889
                    info->update_values->elements);
811
 
        if (fill_record(session, *info->update_fields,
 
890
        if (fill_record(thd, *info->update_fields,
812
891
                                                 *info->update_values,
813
892
                                                 info->ignore))
814
893
          goto before_err;
815
894
 
816
 
        table->cursor->restore_auto_increment(prev_insert_id);
 
895
        table->file->restore_auto_increment(prev_insert_id);
817
896
        if (table->next_number_field)
818
 
          table->cursor->adjust_next_insert_id_after_explicit_value(
 
897
          table->file->adjust_next_insert_id_after_explicit_value(
819
898
            table->next_number_field->val_int());
820
899
        info->touched++;
821
 
        if ((table->cursor->getEngine()->check_flag(HTON_BIT_PARTIAL_COLUMN_READ) &&
 
900
        if ((table->file->ha_table_flags() & HA_PARTIAL_COLUMN_READ &&
822
901
             !bitmap_is_subset(table->write_set, table->read_set)) ||
823
902
            table->compare_record())
824
903
        {
825
 
          if ((error=table->cursor->updateRecord(table->getUpdateRecord(),
826
 
                                                table->getInsertRecord())) &&
 
904
          if ((error=table->file->ha_update_row(table->record[1],
 
905
                                                table->record[0])) &&
827
906
              error != HA_ERR_RECORD_IS_THE_SAME)
828
907
          {
829
908
            if (info->ignore &&
830
 
                !table->cursor->is_fatal_error(error, HA_CHECK_DUP_KEY))
 
909
                !table->file->is_fatal_error(error, HA_CHECK_DUP_KEY))
831
910
            {
832
911
              goto gok_or_after_err;
833
912
            }
843
922
            like a regular UPDATE statement: it should not affect the value of a
844
923
            next SELECT LAST_INSERT_ID() or mysql_insert_id().
845
924
            Except if LAST_INSERT_ID(#) was in the INSERT query, which is
846
 
            handled separately by Session::arg_of_last_insert_id_function.
 
925
            handled separately by THD::arg_of_last_insert_id_function.
847
926
          */
848
 
          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;
849
928
          info->copied++;
850
929
        }
851
930
 
852
931
        if (table->next_number_field)
853
 
          table->cursor->adjust_next_insert_id_after_explicit_value(
 
932
          table->file->adjust_next_insert_id_after_explicit_value(
854
933
            table->next_number_field->val_int());
855
934
        info->touched++;
856
935
 
863
942
          an INSERT or DELETE(s) + INSERT; FOREIGN KEY checks in
864
943
          InnoDB do not function in the defined way if we allow MySQL
865
944
          to convert the latter operation internally to an UPDATE.
866
 
          We also should not perform this conversion if we have
 
945
          We also should not perform this conversion if we have 
867
946
          timestamp field with ON UPDATE which is different from DEFAULT.
868
947
          Another case when conversion should not be performed is when
869
948
          we have ON DELETE trigger on table so user may notice that
873
952
          ON UPDATE triggers.
874
953
        */
875
954
        if (last_uniq_key(table,key_nr) &&
876
 
            !table->cursor->referenced_by_foreign_key() &&
 
955
            !table->file->referenced_by_foreign_key() &&
877
956
            (table->timestamp_field_type == TIMESTAMP_NO_AUTO_SET ||
878
957
             table->timestamp_field_type == TIMESTAMP_AUTO_SET_ON_BOTH))
879
958
        {
880
 
          if ((error=table->cursor->updateRecord(table->getUpdateRecord(),
881
 
                                                table->getInsertRecord())) &&
 
959
          if ((error=table->file->ha_update_row(table->record[1],
 
960
                                                table->record[0])) &&
882
961
              error != HA_ERR_RECORD_IS_THE_SAME)
883
962
            goto err;
884
963
          if (error != HA_ERR_RECORD_IS_THE_SAME)
885
964
            info->deleted++;
886
965
          else
887
966
            error= 0;
888
 
          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);
889
968
          /*
890
969
            Since we pretend that we have done insert we should call
891
970
            its after triggers.
894
973
        }
895
974
        else
896
975
        {
897
 
          if ((error=table->cursor->deleteRecord(table->getUpdateRecord())))
 
976
          if ((error=table->file->ha_delete_row(table->record[1])))
898
977
            goto err;
899
978
          info->deleted++;
900
 
          if (!table->cursor->has_transactions())
901
 
            session->transaction.stmt.markModifiedNonTransData();
 
979
          if (!table->file->has_transactions())
 
980
            thd->transaction.stmt.modified_non_trans_table= true;
902
981
          /* Let us attempt do write_row() once more */
903
982
        }
904
983
      }
905
984
    }
906
 
    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);
907
986
    /*
908
987
      Restore column maps if they where replaced during an duplicate key
909
988
      problem.
912
991
        table->write_set != save_write_set)
913
992
      table->column_bitmaps_set(save_read_set, save_write_set);
914
993
  }
915
 
  else if ((error=table->cursor->insertRecord(table->getInsertRecord())))
 
994
  else if ((error=table->file->ha_write_row(table->record[0])))
916
995
  {
917
996
    if (!info->ignore ||
918
 
        table->cursor->is_fatal_error(error, HA_CHECK_DUP))
 
997
        table->file->is_fatal_error(error, HA_CHECK_DUP))
919
998
      goto err;
920
 
    table->cursor->restore_auto_increment(prev_insert_id);
 
999
    table->file->restore_auto_increment(prev_insert_id);
921
1000
    goto gok_or_after_err;
922
1001
  }
923
1002
 
924
1003
after_n_copied_inc:
925
1004
  info->copied++;
926
 
  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);
927
1006
 
928
1007
gok_or_after_err:
929
 
  if (!table->cursor->has_transactions())
930
 
    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;
931
1012
  return(0);
932
1013
 
933
1014
err:
934
1015
  info->last_errno= error;
935
1016
  /* current_select is NULL if this is a delayed insert */
936
 
  if (session->lex->current_select)
937
 
    session->lex->current_select->no_error= 0;        // Give error
938
 
  table->print_error(error,MYF(0));
939
 
 
 
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
  
940
1021
before_err:
941
 
  table->cursor->restore_auto_increment(prev_insert_id);
 
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);
942
1025
  table->column_bitmaps_set(save_read_set, save_write_set);
943
1026
  return(1);
944
1027
}
948
1031
  Check that all fields with arn't null_fields are used
949
1032
******************************************************************************/
950
1033
 
951
 
int check_that_all_fields_are_given_values(Session *session, Table *entry,
952
 
                                           TableList *)
 
1034
int check_that_all_fields_are_given_values(THD *thd, Table *entry,
 
1035
                                           TableList *table_list)
953
1036
{
954
1037
  int err= 0;
 
1038
  MY_BITMAP *write_set= entry->write_set;
955
1039
 
956
 
  for (Field **field=entry->getFields() ; *field ; field++)
 
1040
  for (Field **field=entry->field ; *field ; field++)
957
1041
  {
958
 
    if (((*field)->isWriteSet()) == false)
959
 
    {
960
 
      /*
961
 
       * If the field doesn't have any default value
962
 
       * and there is no actual value specified in the
963
 
       * INSERT statement, throw error ER_NO_DEFAULT_FOR_FIELD.
964
 
       */
965
 
      if (((*field)->flags & NO_DEFAULT_VALUE_FLAG) &&
 
1042
    if (!bitmap_is_set(write_set, (*field)->field_index) &&
 
1043
        ((*field)->flags & NO_DEFAULT_VALUE_FLAG) &&
966
1044
        ((*field)->real_type() != DRIZZLE_TYPE_ENUM))
967
 
      {
968
 
        my_error(ER_NO_DEFAULT_FOR_FIELD, MYF(0), (*field)->field_name);
969
 
        err= 1;
970
 
      }
971
 
    }
972
 
    else
973
1045
    {
974
 
      /*
975
 
       * However, if an actual NULL value was specified
976
 
       * for the field and the field is a NOT NULL field, 
977
 
       * throw ER_BAD_NULL_ERROR.
978
 
       *
979
 
       * Per the SQL standard, inserting NULL into a NOT NULL
980
 
       * field requires an error to be thrown.
981
 
       */
982
 
      if (((*field)->flags & NOT_NULL_FLAG) &&
983
 
          (*field)->is_null())
984
 
      {
985
 
        my_error(ER_BAD_NULL_ERROR, MYF(0), (*field)->field_name);
986
 
        err= 1;
987
 
      }
 
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;
988
1059
    }
989
1060
  }
990
 
  return session->abort_on_warning ? err : 0;
 
1061
  return thd->abort_on_warning ? err : 0;
991
1062
}
992
1063
 
993
1064
/***************************************************************************
1000
1071
 
1001
1072
  SYNOPSIS
1002
1073
    mysql_insert_select_prepare()
1003
 
    session         thread handler
 
1074
    thd         thread handler
1004
1075
 
1005
1076
  RETURN
1006
1077
    false OK
1007
1078
    true  Error
1008
1079
*/
1009
1080
 
1010
 
bool mysql_insert_select_prepare(Session *session)
 
1081
bool mysql_insert_select_prepare(THD *thd)
1011
1082
{
1012
 
  LEX *lex= session->lex;
1013
 
  Select_Lex *select_lex= &lex->select_lex;
1014
 
 
1015
 
  /*
1016
 
    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
1017
1102
    clause if table is VIEW
1018
1103
  */
1019
 
 
1020
 
  if (mysql_prepare_insert(session, lex->query_tables,
 
1104
  
 
1105
  if (mysql_prepare_insert(thd, lex->query_tables,
1021
1106
                           lex->query_tables->table, lex->field_list, 0,
1022
1107
                           lex->update_list, lex->value_list,
1023
1108
                           lex->duplicates,
1041
1126
                             List<Item> *update_fields,
1042
1127
                             List<Item> *update_values,
1043
1128
                             enum_duplicates duplic,
1044
 
                             bool ignore_check_option_errors) :
1045
 
  table_list(table_list_par), table(table_par), fields(fields_par),
1046
 
  autoinc_value_of_last_inserted_row(0),
1047
 
  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)
1048
1133
{
 
1134
  memset(&info, 0, sizeof(info));
1049
1135
  info.handle_duplicates= duplic;
1050
1136
  info.ignore= ignore_check_option_errors;
1051
1137
  info.update_fields= update_fields;
1054
1140
 
1055
1141
 
1056
1142
int
1057
 
select_insert::prepare(List<Item> &values, Select_Lex_Unit *u)
 
1143
select_insert::prepare(List<Item> &values, SELECT_LEX_UNIT *u)
1058
1144
{
1059
 
  LEX *lex= session->lex;
 
1145
  LEX *lex= thd->lex;
1060
1146
  int res;
1061
1147
  table_map map= 0;
1062
 
  Select_Lex *lex_current_select_save= lex->current_select;
1063
 
 
 
1148
  SELECT_LEX *lex_current_select_save= lex->current_select;
 
1149
  
1064
1150
 
1065
1151
  unit= u;
1066
1152
 
1070
1156
    we are fixing fields from insert list.
1071
1157
  */
1072
1158
  lex->current_select= &lex->select_lex;
1073
 
  res= check_insert_fields(session, table_list, *fields, values,
 
1159
  res= check_insert_fields(thd, table_list, *fields, values,
1074
1160
                           !insert_into_view, &map) ||
1075
 
       setup_fields(session, 0, values, MARK_COLUMNS_READ, 0, 0);
 
1161
       setup_fields(thd, 0, values, MARK_COLUMNS_READ, 0, 0);
1076
1162
 
1077
1163
  if (!res && fields->elements)
1078
1164
  {
1079
 
    bool saved_abort_on_warning= session->abort_on_warning;
1080
 
    session->abort_on_warning= !info.ignore;
1081
 
    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, 
1082
1168
                                                table_list);
1083
 
    session->abort_on_warning= saved_abort_on_warning;
 
1169
    thd->abort_on_warning= saved_abort_on_warning;
1084
1170
  }
1085
1171
 
1086
1172
  if (info.handle_duplicates == DUP_UPDATE && !res)
1095
1181
    table_list->next_local= 0;
1096
1182
    context->resolve_in_table_list_only(table_list);
1097
1183
 
1098
 
    res= res || check_update_fields(session, context->table_list,
 
1184
    res= res || check_update_fields(thd, context->table_list,
1099
1185
                                    *info.update_fields, &map);
1100
1186
    /*
1101
 
      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 
1102
1188
      we can refer to other tables in the ON DUPLICATE KEY part.
1103
1189
      We use next_name_resolution_table descructively, so check it first (views?)
1104
1190
    */
1109
1195
        We must make a single context out of the two separate name resolution contexts :
1110
1196
        the INSERT table and the tables in the SELECT part of INSERT ... SELECT.
1111
1197
        To do that we must concatenate the two lists
1112
 
      */
1113
 
      table_list->next_name_resolution_table=
 
1198
      */  
 
1199
      table_list->next_name_resolution_table= 
1114
1200
        ctx_state.get_first_name_resolution_table();
1115
1201
 
1116
 
    res= res || setup_fields(session, 0, *info.update_values,
 
1202
    res= res || setup_fields(thd, 0, *info.update_values,
1117
1203
                             MARK_COLUMNS_READ, 0, 0);
1118
1204
    if (!res)
1119
1205
    {
1150
1236
    Is table which we are changing used somewhere in other parts of
1151
1237
    query
1152
1238
  */
1153
 
  if (unique_table(table_list, table_list->next_global))
 
1239
  if (unique_table(thd, table_list, table_list->next_global, 0))
1154
1240
  {
1155
1241
    /* Using same table for INSERT and SELECT */
1156
1242
    lex->current_select->options|= OPTION_BUFFER_RESULT;
1159
1245
  else if (!(lex->current_select->options & OPTION_BUFFER_RESULT))
1160
1246
  {
1161
1247
    /*
1162
 
      We must not yet prepare the result table if it is the same as one of the
1163
 
      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 
1164
1250
      indexes on the result table, which may be used during the select, if it
1165
1251
      is the same table (Bug #6034). Do the preparation after the select phase
1166
1252
      in select_insert::prepare2().
1167
1253
      We won't start bulk inserts at all if this statement uses functions or
1168
1254
      should invoke triggers since they may access to the same table too.
1169
1255
    */
1170
 
    table->cursor->ha_start_bulk_insert((ha_rows) 0);
 
1256
    table->file->ha_start_bulk_insert((ha_rows) 0);
1171
1257
  }
1172
 
  table->restoreRecordAsDefault();              // Get empty record
 
1258
  restore_record(table,s->default_values);              // Get empty record
1173
1259
  table->next_number_field=table->found_next_number_field;
1174
1260
 
1175
 
  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;
1176
1268
  if (info.ignore || info.handle_duplicates != DUP_ERROR)
1177
 
    table->cursor->extra(HA_EXTRA_IGNORE_DUP_KEY);
 
1269
    table->file->extra(HA_EXTRA_IGNORE_DUP_KEY);
1178
1270
  if (info.handle_duplicates == DUP_REPLACE)
1179
 
    table->cursor->extra(HA_EXTRA_WRITE_CAN_REPLACE);
 
1271
    table->file->extra(HA_EXTRA_WRITE_CAN_REPLACE);
1180
1272
  if (info.handle_duplicates == DUP_UPDATE)
1181
 
    table->cursor->extra(HA_EXTRA_INSERT_WITH_UPDATE);
1182
 
  session->abort_on_warning= !info.ignore;
 
1273
    table->file->extra(HA_EXTRA_INSERT_WITH_UPDATE);
 
1274
  thd->abort_on_warning= !info.ignore;
1183
1275
  table->mark_columns_needed_for_insert();
1184
1276
 
1185
1277
 
1198
1290
    If the result table is the same as one of the source tables (INSERT SELECT),
1199
1291
    the result table is not finally prepared at the join prepair phase.
1200
1292
    Do the final preparation now.
1201
 
 
 
1293
                       
1202
1294
  RETURN
1203
1295
    0   OK
1204
1296
*/
1205
1297
 
1206
1298
int select_insert::prepare2(void)
1207
1299
{
1208
 
 
1209
 
  if (session->lex->current_select->options & OPTION_BUFFER_RESULT)
1210
 
    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);
1211
1303
  return(0);
1212
1304
}
1213
1305
 
1220
1312
 
1221
1313
select_insert::~select_insert()
1222
1314
{
1223
 
 
 
1315
  
1224
1316
  if (table)
1225
1317
  {
1226
1318
    table->next_number_field=0;
1227
1319
    table->auto_increment_field_not_null= false;
1228
 
    table->cursor->ha_reset();
 
1320
    table->file->ha_reset();
1229
1321
  }
1230
 
  session->count_cuted_fields= CHECK_FIELD_IGNORE;
1231
 
  session->abort_on_warning= 0;
 
1322
  thd->count_cuted_fields= CHECK_FIELD_IGNORE;
 
1323
  thd->abort_on_warning= 0;
1232
1324
  return;
1233
1325
}
1234
1326
 
1235
1327
 
1236
1328
bool select_insert::send_data(List<Item> &values)
1237
1329
{
1238
 
 
 
1330
  
1239
1331
  bool error=0;
1240
1332
 
1241
1333
  if (unit->offset_limit_cnt)
1244
1336
    return(0);
1245
1337
  }
1246
1338
 
1247
 
  session->count_cuted_fields= CHECK_FIELD_WARN;        // Calculate cuted fields
 
1339
  thd->count_cuted_fields= CHECK_FIELD_WARN;    // Calculate cuted fields
1248
1340
  store_values(values);
1249
 
  session->count_cuted_fields= CHECK_FIELD_IGNORE;
1250
 
  if (session->is_error())
 
1341
  thd->count_cuted_fields= CHECK_FIELD_IGNORE;
 
1342
  if (thd->is_error())
1251
1343
    return(1);
1252
1344
 
1253
 
  // Release latches in case bulk insert takes a long time
1254
 
  plugin::TransactionalStorageEngine::releaseTemporaryLatches(session);
1255
 
 
1256
 
  error= write_record(session, table, &info);
1257
 
  table->auto_increment_field_not_null= false;
1258
 
 
 
1345
  error= write_record(thd, table, &info);
 
1346
    
1259
1347
  if (!error)
1260
1348
  {
1261
1349
    if (info.handle_duplicates == DUP_UPDATE)
1263
1351
      /*
1264
1352
        Restore fields of the record since it is possible that they were
1265
1353
        changed by ON DUPLICATE KEY UPDATE clause.
1266
 
 
 
1354
    
1267
1355
        If triggers exist then whey can modify some fields which were not
1268
1356
        originally touched by INSERT ... SELECT, so we have to restore
1269
1357
        their original values for the next row.
1270
1358
      */
1271
 
      table->restoreRecordAsDefault();
 
1359
      restore_record(table, s->default_values);
1272
1360
    }
1273
1361
    if (table->next_number_field)
1274
1362
    {
1276
1364
        If no value has been autogenerated so far, we need to remember the
1277
1365
        value we just saw, we may need to send it to client in the end.
1278
1366
      */
1279
 
      if (session->first_successful_insert_id_in_cur_stmt == 0) // optimization
1280
 
        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= 
1281
1369
          table->next_number_field->val_int();
1282
1370
      /*
1283
1371
        Clear auto-increment field for the next record, if triggers are used
1293
1381
void select_insert::store_values(List<Item> &values)
1294
1382
{
1295
1383
  if (fields->elements)
1296
 
    fill_record(session, *fields, values, true);
 
1384
    fill_record(thd, *fields, values, 1);
1297
1385
  else
1298
 
    fill_record(session, table->getFields(), values, true);
 
1386
    fill_record(thd, table->field, values, 1);
1299
1387
}
1300
1388
 
1301
1389
void select_insert::send_error(uint32_t errcode,const char *err)
1302
1390
{
1303
 
 
 
1391
  
1304
1392
 
1305
1393
  my_message(errcode, err, MYF(0));
1306
1394
 
1311
1399
bool select_insert::send_eof()
1312
1400
{
1313
1401
  int error;
1314
 
  bool const trans_table= table->cursor->has_transactions();
 
1402
  bool const trans_table= table->file->has_transactions();
1315
1403
  uint64_t id;
1316
1404
  bool changed;
1317
 
 
1318
 
  error= table->cursor->ha_end_bulk_insert();
1319
 
  table->cursor->extra(HA_EXTRA_NO_IGNORE_DUP_KEY);
1320
 
  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);
1321
1410
 
1322
1411
  if ((changed= (info.copied || info.deleted || info.updated)))
1323
1412
  {
1324
1413
    /*
1325
1414
      We must invalidate the table in the query cache before binlog writing
1326
 
      and autocommitOrRollback.
 
1415
      and ha_autocommit_or_rollback.
1327
1416
    */
1328
 
    if (session->transaction.stmt.hasModifiedNonTransData())
1329
 
      session->transaction.all.markModifiedNonTransData();
 
1417
    if (thd->transaction.stmt.modified_non_trans_table)
 
1418
      thd->transaction.all.modified_non_trans_table= true;
1330
1419
  }
1331
 
  assert(trans_table || !changed ||
1332
 
              session->transaction.stmt.hasModifiedNonTransData());
 
1420
  assert(trans_table || !changed || 
 
1421
              thd->transaction.stmt.modified_non_trans_table);
1333
1422
 
1334
 
  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();
1335
1438
 
1336
1439
  if (error)
1337
1440
  {
1338
 
    table->print_error(error,MYF(0));
1339
 
    DRIZZLE_INSERT_SELECT_DONE(error, 0);
1340
 
    return 1;
 
1441
    table->file->print_error(error,MYF(0));
 
1442
    return(1);
1341
1443
  }
1342
1444
  char buff[160];
1343
1445
  if (info.ignore)
1344
 
    snprintf(buff, sizeof(buff), ER(ER_INSERT_INFO), (ulong) info.records,
1345
 
            (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);
1346
1448
  else
1347
 
    snprintf(buff, sizeof(buff), ER(ER_INSERT_INFO), (ulong) info.records,
1348
 
            (ulong) (info.deleted+info.updated), (ulong) session->cuted_fields);
1349
 
  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);
1350
1454
 
1351
 
  id= (session->first_successful_insert_id_in_cur_stmt > 0) ?
1352
 
    session->first_successful_insert_id_in_cur_stmt :
1353
 
    (session->arg_of_last_insert_id_function ?
1354
 
     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 :
1355
1459
     (info.copied ? autoinc_value_of_last_inserted_row : 0));
1356
 
  session->my_ok((ulong) session->row_count_func,
1357
 
                 info.copied + info.deleted + info.touched, id, buff);
1358
 
  session->status_var.inserted_row_count+= session->row_count_func; 
1359
 
  DRIZZLE_INSERT_SELECT_DONE(0, session->row_count_func);
1360
 
  return 0;
 
1460
  ::my_ok(thd, (ulong) thd->row_count_func, id, buff);
 
1461
  return(0);
1361
1462
}
1362
1463
 
1363
1464
void select_insert::abort() {
1364
1465
 
1365
 
 
 
1466
  
1366
1467
  /*
1367
1468
    If the creation of the table failed (due to a syntax error, for
1368
1469
    example), no table will have been opened and therefore 'table'
1373
1474
  {
1374
1475
    bool changed, transactional_table;
1375
1476
 
1376
 
    table->cursor->ha_end_bulk_insert();
 
1477
    table->file->ha_end_bulk_insert();
1377
1478
 
1378
1479
    /*
1379
1480
      If at least one row has been inserted/modified and will stay in
1390
1491
      zero, so no check for that is made.
1391
1492
    */
1392
1493
    changed= (info.copied || info.deleted || info.updated);
1393
 
    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
    }
1394
1503
    assert(transactional_table || !changed ||
1395
 
                session->transaction.stmt.hasModifiedNonTransData());
1396
 
    table->cursor->ha_release_auto_increment();
1397
 
  }
1398
 
 
1399
 
  if (DRIZZLE_INSERT_SELECT_DONE_ENABLED())
1400
 
  {
1401
 
    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();
1402
1506
  }
1403
1507
 
1404
1508
  return;
1415
1519
 
1416
1520
  SYNOPSIS
1417
1521
    create_table_from_items()
1418
 
      session          in     Thread object
 
1522
      thd          in     Thread object
1419
1523
      create_info  in     Create information (like MAX_ROWS, ENGINE or
1420
1524
                          temporary table flag)
1421
1525
      create_table in     Pointer to TableList object providing database
1425
1529
      items        in     List of items which should be used to produce rest
1426
1530
                          of fields for the table (corresponding fields will
1427
1531
                          be added to the end of alter_info->create_list)
1428
 
      lock         out    Pointer to the DrizzleLock object for table created
 
1532
      lock         out    Pointer to the DRIZZLE_LOCK object for table created
1429
1533
                          (or open temporary table) will be returned in this
1430
1534
                          parameter. Since this table is not included in
1431
 
                          Session::lock caller is responsible for explicitly
 
1535
                          THD::lock caller is responsible for explicitly
1432
1536
                          unlocking this table.
1433
1537
      hooks
1434
1538
 
1435
1539
  NOTES
1436
1540
    This function behaves differently for base and temporary tables:
1437
1541
    - For base table we assume that either table exists and was pre-opened
1438
 
      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
1439
1543
      emit error or warning and return pre-opened Table object) or special
1440
1544
      placeholder was put in table cache that guarantees that this table
1441
1545
      won't be created or opened until the placeholder will be removed
1451
1555
    0         Error
1452
1556
*/
1453
1557
 
1454
 
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,
1455
1559
                                      TableList *create_table,
1456
 
                                      message::Table &table_proto,
1457
 
                                      AlterInfo *alter_info,
 
1560
                                      Alter_info *alter_info,
1458
1561
                                      List<Item> *items,
1459
 
                                      bool is_if_not_exists,
1460
 
                                      DrizzleLock **lock,
1461
 
                                      TableIdentifier &identifier)
 
1562
                                      DRIZZLE_LOCK **lock,
 
1563
                                      TABLEOP_HOOKS *hooks)
1462
1564
{
1463
 
  Table tmp_table;              // Used during 'CreateField()'
1464
 
  TableShare share(message::Table::INTERNAL);
 
1565
  Table tmp_table;              // Used during 'Create_field()'
 
1566
  TABLE_SHARE share;
1465
1567
  Table *table= 0;
1466
1568
  uint32_t select_field_count= items->elements;
1467
1569
  /* Add selected items to field list */
1470
1572
  Field *tmp_field;
1471
1573
  bool not_used;
1472
1574
 
1473
 
  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)
1474
1577
  {
1475
 
    /* Table already exists and was open at openTablesLock() stage. */
1476
 
    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)
1477
1580
    {
1478
1581
      create_info->table_existed= 1;            // Mark that table existed
1479
 
      push_warning_printf(session, DRIZZLE_ERROR::WARN_LEVEL_NOTE,
 
1582
      push_warning_printf(thd, DRIZZLE_ERROR::WARN_LEVEL_NOTE,
1480
1583
                          ER_TABLE_EXISTS_ERROR, ER(ER_TABLE_EXISTS_ERROR),
1481
1584
                          create_table->table_name);
1482
 
      return create_table->table;
 
1585
      return(create_table->table);
1483
1586
    }
1484
1587
 
1485
1588
    my_error(ER_TABLE_EXISTS_ERROR, MYF(0), create_table->table_name);
1486
 
    return NULL;
 
1589
    return(0);
1487
1590
  }
1488
1591
 
 
1592
  tmp_table.alias= 0;
1489
1593
  tmp_table.timestamp_field= 0;
1490
 
  tmp_table.setShare(&share);
1491
 
 
1492
 
  tmp_table.getMutableShare()->db_create_options= 0;
1493
 
  tmp_table.getMutableShare()->blob_ptr_size= portable_sizeof_char_ptr;
1494
 
 
1495
 
  if (not table_proto.engine().name().compare("MyISAM"))
1496
 
    tmp_table.getMutableShare()->db_low_byte_first= true;
1497
 
  else if (not table_proto.engine().name().compare("MEMORY"))
1498
 
    tmp_table.getMutableShare()->db_low_byte_first= true;
1499
 
 
 
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);
1500
1602
  tmp_table.null_row= false;
1501
1603
  tmp_table.maybe_null= false;
1502
1604
 
1503
1605
  while ((item=it++))
1504
1606
  {
1505
 
    CreateField *cr_field;
 
1607
    Create_field *cr_field;
1506
1608
    Field *field, *def_field;
1507
1609
    if (item->type() == Item::FUNC_ITEM)
1508
1610
      if (item->result_type() != STRING_RESULT)
1510
1612
      else
1511
1613
        field= item->tmp_table_field_from_field_type(&tmp_table, 0);
1512
1614
    else
1513
 
      field= create_tmp_field(session, &tmp_table, item, item->type(),
1514
 
                              (Item ***) 0, &tmp_field, &def_field, false,
1515
 
                              false, false, 0);
 
1615
      field= create_tmp_field(thd, &tmp_table, item, item->type(),
 
1616
                              (Item ***) 0, &tmp_field, &def_field, 0, 0, 0, 0,
 
1617
                              0);
1516
1618
    if (!field ||
1517
 
        !(cr_field=new CreateField(field,(item->type() == Item::FIELD_ITEM ?
 
1619
        !(cr_field=new Create_field(field,(item->type() == Item::FIELD_ITEM ?
1518
1620
                                           ((Item_field *)item)->field :
1519
1621
                                           (Field*) 0))))
1520
 
      return NULL;
 
1622
      return(0);
1521
1623
    if (item->maybe_null)
1522
1624
      cr_field->flags &= ~NOT_NULL_FLAG;
1523
1625
    alter_info->create_list.push_back(cr_field);
1529
1631
    Note that we either creating (or opening existing) temporary table or
1530
1632
    creating base table on which name we have exclusive lock. So code below
1531
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().
1532
1643
  */
1533
1644
  {
1534
 
    if (not mysql_create_table_no_lock(session,
1535
 
                                       identifier,
1536
 
                                       create_info,
1537
 
                                       table_proto,
1538
 
                                       alter_info,
1539
 
                                       false,
1540
 
                                       select_field_count,
1541
 
                                       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))
1542
1650
    {
1543
 
      if (create_info->table_existed && not identifier.isTmp())
 
1651
      if (create_info->table_existed &&
 
1652
          !(create_info->options & HA_LEX_CREATE_TMP_TABLE))
1544
1653
      {
1545
1654
        /*
1546
1655
          This means that someone created table underneath server
1548
1657
          cluster. We don't have much options but throw an error.
1549
1658
        */
1550
1659
        my_error(ER_TABLE_EXISTS_ERROR, MYF(0), create_table->table_name);
1551
 
        return NULL;
 
1660
        return(0);
1552
1661
      }
1553
1662
 
1554
 
      if (not identifier.isTmp())
 
1663
      if (!(create_info->options & HA_LEX_CREATE_TMP_TABLE))
1555
1664
      {
1556
 
        LOCK_open.lock(); /* CREATE TABLE... has found that the table already exists for insert and is adapting to use it */
1557
 
        if (session->reopen_name_locked_table(create_table, false))
 
1665
        pthread_mutex_lock(&LOCK_open);
 
1666
        if (reopen_name_locked_table(thd, create_table, false))
1558
1667
        {
1559
 
          quick_rm_table(*session, identifier);
 
1668
          quick_rm_table(create_info->db_type, create_table->db,
 
1669
                         table_case_name(create_info, create_table->table_name),
 
1670
                         0);
1560
1671
        }
1561
1672
        else
1562
1673
          table= create_table->table;
1563
 
        LOCK_open.unlock();
 
1674
        pthread_mutex_unlock(&LOCK_open);
1564
1675
      }
1565
1676
      else
1566
1677
      {
1567
 
        if (not (table= session->openTable(create_table, (bool*) 0,
1568
 
                                           DRIZZLE_OPEN_TEMPORARY_ONLY)) &&
1569
 
            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)
1570
1681
        {
1571
1682
          /*
1572
1683
            This shouldn't happen as creation of temporary table should make
1573
1684
            it preparable for open. But let us do close_temporary_table() here
1574
1685
            just in case.
1575
1686
          */
1576
 
          session->drop_temporary_table(create_table);
 
1687
          drop_temporary_table(thd, create_table);
1577
1688
        }
1578
1689
      }
1579
1690
    }
 
1691
    reenable_binlog(thd);
1580
1692
    if (!table)                                   // open failed
1581
 
      return NULL;
 
1693
      return(0);
1582
1694
  }
1583
1695
 
1584
1696
  table->reginfo.lock_type=TL_WRITE;
1585
 
  if (! ((*lock)= mysql_lock_tables(session, &table, 1,
1586
 
                                    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))
1587
1701
  {
1588
1702
    if (*lock)
1589
1703
    {
1590
 
      mysql_unlock_tables(session, *lock);
 
1704
      mysql_unlock_tables(thd, *lock);
1591
1705
      *lock= 0;
1592
1706
    }
1593
1707
 
1594
 
    if (not create_info->table_existed)
1595
 
      session->drop_open_table(table, identifier);
1596
 
    return NULL;
 
1708
    if (!create_info->table_existed)
 
1709
      drop_open_table(thd, table, create_table->db, create_table->table_name);
 
1710
    return(0);
1597
1711
  }
1598
 
 
1599
 
  return table;
 
1712
  return(table);
1600
1713
}
1601
1714
 
1602
1715
 
1603
1716
int
1604
 
select_create::prepare(List<Item> &values, Select_Lex_Unit *u)
 
1717
select_create::prepare(List<Item> &values, SELECT_LEX_UNIT *u)
1605
1718
{
1606
 
  DrizzleLock *extra_lock= NULL;
 
1719
  DRIZZLE_LOCK *extra_lock= NULL;
 
1720
  
 
1721
 
 
1722
  TABLEOP_HOOKS *hook_ptr= NULL;
1607
1723
  /*
1608
 
    For replication, the CREATE-SELECT statement is written
1609
 
    in two pieces: the first transaction messsage contains 
1610
 
    the CREATE TABLE statement as a CreateTableStatement message
1611
 
    necessary to create the table.
1612
 
    
1613
 
    The second transaction message contains all the InsertStatement
1614
 
    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.
1615
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;
1616
1773
 
1617
1774
  unit= u;
1618
1775
 
1619
 
  if (not (table= create_table_from_items(session, create_info, create_table,
1620
 
                                          table_proto,
1621
 
                                          alter_info, &values,
1622
 
                                          is_if_not_exists,
1623
 
                                          &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)
1624
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)))
1625
1790
    return(-1);                         // abort() deletes table
1626
 
  }
1627
1791
 
1628
1792
  if (extra_lock)
1629
1793
  {
1630
1794
    assert(m_plock == NULL);
1631
1795
 
1632
 
    if (identifier.isTmp())
 
1796
    if (create_info->options & HA_LEX_CREATE_TMP_TABLE)
1633
1797
      m_plock= &m_lock;
1634
1798
    else
1635
 
      m_plock= &session->extra_lock;
 
1799
      m_plock= &thd->extra_lock;
1636
1800
 
1637
1801
    *m_plock= extra_lock;
1638
1802
  }
1639
1803
 
1640
 
  if (table->getShare()->sizeFields() < values.elements)
 
1804
  if (table->s->fields < values.elements)
1641
1805
  {
1642
1806
    my_error(ER_WRONG_VALUE_COUNT_ON_ROW, MYF(0), 1);
1643
1807
    return(-1);
1644
1808
  }
1645
1809
 
1646
1810
 /* First field to copy */
1647
 
  field= table->getFields() + table->getShare()->sizeFields() - values.elements;
 
1811
  field= table->field+table->s->fields - values.elements;
1648
1812
 
1649
1813
  /* Mark all fields that are given values */
1650
1814
  for (Field **f= field ; *f ; f++)
1651
 
    table->setWriteSet((*f)->field_index);
 
1815
    bitmap_set_bit(table->write_set, (*f)->field_index);
1652
1816
 
1653
1817
  /* Don't set timestamp if used */
1654
1818
  table->timestamp_field_type= TIMESTAMP_NO_AUTO_SET;
1655
1819
  table->next_number_field=table->found_next_number_field;
1656
1820
 
1657
 
  table->restoreRecordAsDefault();      // Get empty record
1658
 
  session->cuted_fields=0;
 
1821
  restore_record(table,s->default_values);      // Get empty record
 
1822
  thd->cuted_fields=0;
1659
1823
  if (info.ignore || info.handle_duplicates != DUP_ERROR)
1660
 
    table->cursor->extra(HA_EXTRA_IGNORE_DUP_KEY);
 
1824
    table->file->extra(HA_EXTRA_IGNORE_DUP_KEY);
1661
1825
  if (info.handle_duplicates == DUP_REPLACE)
1662
 
    table->cursor->extra(HA_EXTRA_WRITE_CAN_REPLACE);
 
1826
    table->file->extra(HA_EXTRA_WRITE_CAN_REPLACE);
1663
1827
  if (info.handle_duplicates == DUP_UPDATE)
1664
 
    table->cursor->extra(HA_EXTRA_INSERT_WITH_UPDATE);
1665
 
  table->cursor->ha_start_bulk_insert((ha_rows) 0);
1666
 
  session->abort_on_warning= !info.ignore;
1667
 
  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))
1668
1832
    return(1);
1669
1833
  table->mark_columns_needed_for_insert();
1670
 
  table->cursor->extra(HA_EXTRA_WRITE_CACHE);
 
1834
  table->file->extra(HA_EXTRA_WRITE_CACHE);
1671
1835
  return(0);
1672
1836
}
1673
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
 
1674
1879
void select_create::store_values(List<Item> &values)
1675
1880
{
1676
 
  fill_record(session, field, values, true);
 
1881
  fill_record(thd, field, values, 1);
1677
1882
}
1678
1883
 
1679
1884
 
1680
1885
void select_create::send_error(uint32_t errcode,const char *err)
1681
1886
{
 
1887
  
 
1888
 
1682
1889
  /*
1683
1890
    This will execute any rollbacks that are necessary before writing
1684
1891
    the transcation cache.
1690
1897
    written to the binary log.
1691
1898
 
1692
1899
  */
 
1900
  tmp_disable_binlog(thd);
1693
1901
  select_insert::send_error(errcode, err);
 
1902
  reenable_binlog(thd);
1694
1903
 
1695
1904
  return;
1696
1905
}
1708
1917
      tables.  This can fail, but we should unlock the table
1709
1918
      nevertheless.
1710
1919
    */
1711
 
    if (!table->getShare()->getType())
 
1920
    if (!table->s->tmp_table)
1712
1921
    {
1713
 
      TransactionServices &transaction_services= TransactionServices::singleton();
1714
 
      transaction_services.autocommitOrRollback(session, 0);
1715
 
      (void) session->endActiveTransaction();
 
1922
      ha_autocommit_or_rollback(thd, 0);
 
1923
      end_active_trans(thd);
1716
1924
    }
1717
1925
 
1718
 
    table->cursor->extra(HA_EXTRA_NO_IGNORE_DUP_KEY);
1719
 
    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);
1720
1928
    if (m_plock)
1721
1929
    {
1722
 
      mysql_unlock_tables(session, *m_plock);
 
1930
      mysql_unlock_tables(thd, *m_plock);
1723
1931
      *m_plock= NULL;
1724
1932
      m_plock= NULL;
1725
1933
    }
1730
1938
 
1731
1939
void select_create::abort()
1732
1940
{
 
1941
  
 
1942
 
1733
1943
  /*
1734
1944
    In select_insert::abort() we roll back the statement, including
1735
1945
    truncating the transaction cache of the binary log. To do this, we
1745
1955
    of the table succeeded or not, since we need to reset the binary
1746
1956
    log state.
1747
1957
  */
 
1958
  tmp_disable_binlog(thd);
1748
1959
  select_insert::abort();
 
1960
  thd->transaction.stmt.modified_non_trans_table= false;
 
1961
  reenable_binlog(thd);
 
1962
 
1749
1963
 
1750
1964
  if (m_plock)
1751
1965
  {
1752
 
    mysql_unlock_tables(session, *m_plock);
 
1966
    mysql_unlock_tables(thd, *m_plock);
1753
1967
    *m_plock= NULL;
1754
1968
    m_plock= NULL;
1755
1969
  }
1756
1970
 
1757
1971
  if (table)
1758
1972
  {
1759
 
    table->cursor->extra(HA_EXTRA_NO_IGNORE_DUP_KEY);
1760
 
    table->cursor->extra(HA_EXTRA_WRITE_CANNOT_REPLACE);
1761
 
    if (not create_info->table_existed)
1762
 
      session->drop_open_table(table, identifier);
1763
 
    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
1764
1978
  }
 
1979
  return;
1765
1980
}
1766
1981
 
1767
 
} /* 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 */