← 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: 2009-02-20 22:48:37 UTC
  • Revision ID: brian@tangent.org-20090220224837-fw5wrf46n4ru3e6a
First pass of stripping uint

Show diffs side-by-side

added added

removed removed

Lines of Context:
drizzled/sql_insert.cc
24
24
*/
25
25
#include <drizzled/server_includes.h>
26
26
#include <drizzled/sql_select.h>
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
 
 
 
27
#include <drizzled/show.h>
 
28
#include <drizzled/error.h>
 
29
#include <drizzled/name_resolution_context_state.h>
 
30
#include <drizzled/probes.h>
 
31
#include <drizzled/sql_base.h>
 
32
#include <drizzled/sql_load.h>
 
33
#include <drizzled/field/timestamp.h>
 
34
#include <drizzled/lock.h>
41
35
 
42
36
 
43
37
/*
45
39
 
46
40
  SYNOPSIS
47
41
    check_insert_fields()
48
 
    thd                         The current thread.
 
42
    session                         The current thread.
49
43
    table                       The table for insert.
50
44
    fields                      The insert fields.
51
45
    values                      The insert values.
61
55
    -1          Error
62
56
*/
63
57
 
64
 
static int check_insert_fields(THD *thd, TableList *table_list,
 
58
static int check_insert_fields(Session *session, TableList *table_list,
65
59
                               List<Item> &fields, List<Item> &values,
66
60
                               bool check_unique,
67
 
                               table_map *map __attribute__((unused)))
 
61
                               table_map *)
68
62
{
69
63
  Table *table= table_list->table;
70
64
 
85
79
  }
86
80
  else
87
81
  {                                             // Part field list
88
 
    SELECT_LEX *select_lex= &thd->lex->select_lex;
 
82
    Select_Lex *select_lex= &session->lex->select_lex;
89
83
    Name_resolution_context *context= &select_lex->context;
90
84
    Name_resolution_context_state ctx_state;
91
85
    int res;
96
90
      return -1;
97
91
    }
98
92
 
99
 
    thd->dup_field= 0;
 
93
    session->dup_field= 0;
100
94
 
101
95
    /* Save the state of the current name resolution context. */
102
96
    ctx_state.save_state(context, table_list);
107
101
    */
108
102
    table_list->next_local= 0;
109
103
    context->resolve_in_table_list_only(table_list);
110
 
    res= setup_fields(thd, 0, fields, MARK_COLUMNS_WRITE, 0, 0);
 
104
    res= setup_fields(session, 0, fields, MARK_COLUMNS_WRITE, 0, 0);
111
105
 
112
106
    /* Restore the current context. */
113
107
    ctx_state.restore_state(context, table_list);
115
109
    if (res)
116
110
      return -1;
117
111
 
118
 
    if (check_unique && thd->dup_field)
 
112
    if (check_unique && session->dup_field)
119
113
    {
120
 
      my_error(ER_FIELD_SPECIFIED_TWICE, MYF(0), thd->dup_field->field_name);
 
114
      my_error(ER_FIELD_SPECIFIED_TWICE, MYF(0), session->dup_field->field_name);
121
115
      return -1;
122
116
    }
123
117
    if (table->timestamp_field) // Don't automaticly set timestamp if used
132
126
                       table->timestamp_field->field_index);
133
127
      }
134
128
    }
 
129
    /* Mark all virtual columns for write*/
 
130
    if (table->vfield)
 
131
      table->mark_virtual_columns();
135
132
  }
136
133
 
137
134
  return 0;
143
140
 
144
141
  SYNOPSIS
145
142
    check_update_fields()
146
 
    thd                         The current thread.
 
143
    session                         The current thread.
147
144
    insert_table_list           The insert table list.
148
145
    table                       The table for update.
149
146
    update_fields               The update fields.
157
154
    -1          Error
158
155
*/
159
156
 
160
 
static int check_update_fields(THD *thd, TableList *insert_table_list,
 
157
static int check_update_fields(Session *session, TableList *insert_table_list,
161
158
                               List<Item> &update_fields,
162
 
                               table_map *map __attribute__((unused)))
 
159
                               table_map *)
163
160
{
164
161
  Table *table= insert_table_list->table;
165
162
  bool timestamp_mark= false;
175
172
  }
176
173
 
177
174
  /* Check the fields we are going to modify */
178
 
  if (setup_fields(thd, 0, update_fields, MARK_COLUMNS_WRITE, 0, 0))
 
175
  if (setup_fields(session, 0, update_fields, MARK_COLUMNS_WRITE, 0, 0))
179
176
    return -1;
180
177
 
181
178
  if (table->timestamp_field)
202
199
*/
203
200
 
204
201
static
205
 
void upgrade_lock_type(THD *thd __attribute__((unused)),
 
202
void upgrade_lock_type(Session *,
206
203
                       thr_lock_type *lock_type,
207
204
                       enum_duplicates duplic,
208
 
                       bool is_multi_insert __attribute__((unused)))
 
205
                       bool )
209
206
{
210
207
  if (duplic == DUP_UPDATE ||
211
208
      (duplic == DUP_REPLACE && *lock_type == TL_WRITE_CONCURRENT_INSERT))
224
221
  end of dispatch_command().
225
222
*/
226
223
 
227
 
bool mysql_insert(THD *thd,TableList *table_list,
 
224
bool mysql_insert(Session *session,TableList *table_list,
228
225
                  List<Item> &fields,
229
226
                  List<List_item> &values_list,
230
227
                  List<Item> &update_fields,
235
232
  int error;
236
233
  bool transactional_table, joins_freed= false;
237
234
  bool changed;
238
 
  bool was_insert_delayed= (table_list->lock_type ==  TL_WRITE_DELAYED);
239
235
  uint32_t value_count;
240
236
  ulong counter = 1;
241
237
  uint64_t id;
247
243
  Name_resolution_context_state ctx_state;
248
244
  thr_lock_type lock_type;
249
245
  Item *unused_conds= 0;
250
 
  
 
246
 
251
247
 
252
248
  /*
253
249
    Upgrade lock type if the requested lock is incompatible with
254
250
    the current connection mode or table operation.
255
251
  */
256
 
  upgrade_lock_type(thd, &table_list->lock_type, duplic,
 
252
  upgrade_lock_type(session, &table_list->lock_type, duplic,
257
253
                    values_list.elements > 1);
258
254
 
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))
267
 
  {
268
 
    my_error(ER_DELAYED_INSERT_TABLE_LOCKED, MYF(0),
269
 
             table_list->table_name);
 
255
  if (open_and_lock_tables(session, table_list))
270
256
    return(true);
271
 
  }
272
257
 
273
 
  {
274
 
    if (open_and_lock_tables(thd, table_list))
275
 
      return(true);
276
 
  }
277
258
  lock_type= table_list->lock_type;
278
259
 
279
 
  thd_proc_info(thd, "init");
280
 
  thd->used_tables=0;
 
260
  session->set_proc_info("init");
 
261
  session->used_tables=0;
281
262
  values= its++;
282
263
  value_count= values->elements;
283
264
 
284
 
  if (mysql_prepare_insert(thd, table_list, table, fields, values,
 
265
  if (mysql_prepare_insert(session, table_list, table, fields, values,
285
266
                           update_fields, update_values, duplic, &unused_conds,
286
267
                           false,
287
268
                           (fields.elements || !value_count ||
291
272
  /* mysql_prepare_insert set table_list->table if it was not set */
292
273
  table= table_list->table;
293
274
 
294
 
  context= &thd->lex->select_lex.context;
 
275
  context= &session->lex->select_lex.context;
295
276
  /*
296
277
    These three asserts test the hypothesis that the resetting of the name
297
278
    resolution context below is not necessary at all since the list of local
319
300
      my_error(ER_WRONG_VALUE_COUNT_ON_ROW, MYF(0), counter);
320
301
      goto abort;
321
302
    }
322
 
    if (setup_fields(thd, 0, *values, MARK_COLUMNS_READ, 0, 0))
 
303
    if (setup_fields(session, 0, *values, MARK_COLUMNS_READ, 0, 0))
323
304
      goto abort;
324
305
  }
325
306
  its.rewind ();
326
 
 
 
307
 
327
308
  /* Restore the current context. */
328
309
  ctx_state.restore_state(context, table_list);
329
310
 
341
322
    For single line insert, generate an error if try to set a NOT NULL field
342
323
    to NULL.
343
324
  */
344
 
  thd->count_cuted_fields= ((values_list.elements == 1 &&
 
325
  session->count_cuted_fields= ((values_list.elements == 1 &&
345
326
                             !ignore) ?
346
327
                            CHECK_FIELD_ERROR_FOR_NULL :
347
328
                            CHECK_FIELD_WARN);
348
 
  thd->cuted_fields = 0L;
 
329
  session->cuted_fields = 0L;
349
330
  table->next_number_field=table->found_next_number_field;
350
331
 
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
 
 
357
332
  error=0;
358
 
  thd_proc_info(thd, "update");
 
333
  session->set_proc_info("update");
359
334
  if (duplic == DUP_REPLACE)
360
335
    table->file->extra(HA_EXTRA_WRITE_CAN_REPLACE);
361
336
  if (duplic == DUP_UPDATE)
367
342
  }
368
343
 
369
344
 
370
 
  thd->abort_on_warning= !ignore;
 
345
  session->abort_on_warning= !ignore;
371
346
 
372
347
  table->mark_columns_needed_for_insert();
373
348
 
376
351
    if (fields.elements || !value_count)
377
352
    {
378
353
      restore_record(table,s->default_values);  // Get empty record
379
 
      if (fill_record(thd, fields, *values, 0))
 
354
      if (fill_record(session, fields, *values, 0))
380
355
      {
381
 
        if (values_list.elements != 1 && ! thd->is_error())
 
356
        if (values_list.elements != 1 && ! session->is_error())
382
357
        {
383
358
          info.records++;
384
359
          continue;
385
360
        }
386
361
        /*
387
 
          TODO: set thd->abort_on_warning if values_list.elements == 1
 
362
          TODO: set session->abort_on_warning if values_list.elements == 1
388
363
          and check that all items return warning in case of problem with
389
364
          storing field.
390
365
        */
394
369
    }
395
370
    else
396
371
    {
397
 
      if (thd->used_tables)                     // Column used in values()
 
372
      if (session->used_tables)                 // Column used in values()
398
373
        restore_record(table,s->default_values);        // Get empty record
399
374
      else
400
375
      {
405
380
        */
406
381
        table->record[0][0]= table->s->default_values[0];
407
382
      }
408
 
      if (fill_record(thd, table->field, *values, 0))
 
383
      if (fill_record(session, table->field, *values, 0))
409
384
      {
410
 
        if (values_list.elements != 1 && ! thd->is_error())
 
385
        if (values_list.elements != 1 && ! session->is_error())
411
386
        {
412
387
          info.records++;
413
388
          continue;
417
392
      }
418
393
    }
419
394
 
420
 
    error=write_record(thd, table ,&info);
 
395
    // Release latches in case bulk insert takes a long time
 
396
    ha_release_temporary_latches(session);
 
397
 
 
398
    error=write_record(session, table ,&info);
421
399
    if (error)
422
400
      break;
423
 
    thd->row_count++;
 
401
    session->row_count++;
424
402
  }
425
403
 
426
 
  free_underlaid_joins(thd, &thd->lex->select_lex);
 
404
  free_underlaid_joins(session, &session->lex->select_lex);
427
405
  joins_freed= true;
428
406
 
429
407
  /*
446
424
 
447
425
    transactional_table= table->file->has_transactions();
448
426
 
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);
 
427
    changed= (info.copied || info.deleted || info.updated);
 
428
    if ((changed && error <= 0) || session->transaction.stmt.modified_non_trans_table)
 
429
    {
 
430
      if (session->transaction.stmt.modified_non_trans_table)
 
431
        session->transaction.all.modified_non_trans_table= true;
 
432
    }
 
433
    assert(transactional_table || !changed || session->transaction.stmt.modified_non_trans_table);
502
434
 
503
435
  }
504
 
  thd_proc_info(thd, "end");
 
436
  session->set_proc_info("end");
505
437
  /*
506
438
    We'll report to the client this id:
507
439
    - if the table contains an autoincrement column and we successfully
512
444
    inserted, the id of the last "inserted" row (if IGNORE, that value may not
513
445
    have been really inserted but ignored).
514
446
  */
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 :
 
447
  id= (session->first_successful_insert_id_in_cur_stmt > 0) ?
 
448
    session->first_successful_insert_id_in_cur_stmt :
 
449
    (session->arg_of_last_insert_id_function ?
 
450
     session->first_successful_insert_id_in_prev_stmt :
519
451
     ((table->next_number_field && info.copied) ?
520
452
     table->next_number_field->val_int() : 0));
521
453
  table->next_number_field=0;
522
 
  thd->count_cuted_fields= CHECK_FIELD_IGNORE;
 
454
  session->count_cuted_fields= CHECK_FIELD_IGNORE;
523
455
  table->auto_increment_field_not_null= false;
524
456
  if (duplic == DUP_REPLACE)
525
457
    table->file->extra(HA_EXTRA_WRITE_CANNOT_REPLACE);
526
458
 
527
459
  if (error)
528
460
    goto abort;
529
 
  if (values_list.elements == 1 && (!(thd->options & OPTION_WARNINGS) ||
530
 
                                    !thd->cuted_fields))
 
461
  if (values_list.elements == 1 && (!(session->options & OPTION_WARNINGS) ||
 
462
                                    !session->cuted_fields))
531
463
  {
532
 
    thd->row_count_func= info.copied + info.deleted +
533
 
                         ((thd->client_capabilities & CLIENT_FOUND_ROWS) ?
 
464
    session->row_count_func= info.copied + info.deleted +
 
465
                         ((session->client_capabilities & CLIENT_FOUND_ROWS) ?
534
466
                          info.touched : info.updated);
535
 
    my_ok(thd, (ulong) thd->row_count_func, id);
 
467
    session->my_ok((ulong) session->row_count_func, id);
536
468
  }
537
469
  else
538
470
  {
539
471
    char buff[160];
540
 
    ha_rows updated=((thd->client_capabilities & CLIENT_FOUND_ROWS) ?
 
472
    ha_rows updated=((session->client_capabilities & CLIENT_FOUND_ROWS) ?
541
473
                     info.touched : info.updated);
542
474
    if (ignore)
543
475
      sprintf(buff, ER(ER_INSERT_INFO), (ulong) info.records,
544
 
              (ulong) (info.records - info.copied), (ulong) thd->cuted_fields);
 
476
              (ulong) (info.records - info.copied), (ulong) session->cuted_fields);
545
477
    else
546
478
      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);
 
479
              (ulong) (info.deleted + updated), (ulong) session->cuted_fields);
 
480
    session->row_count_func= info.copied + info.deleted + updated;
 
481
    session->my_ok((ulong) session->row_count_func, id, buff);
550
482
  }
551
 
  thd->abort_on_warning= 0;
 
483
  session->abort_on_warning= 0;
552
484
  DRIZZLE_INSERT_END();
553
485
  return(false);
554
486
 
556
488
  if (table != NULL)
557
489
    table->file->ha_release_auto_increment();
558
490
  if (!joins_freed)
559
 
    free_underlaid_joins(thd, &thd->lex->select_lex);
560
 
  thd->abort_on_warning= 0;
 
491
    free_underlaid_joins(session, &session->lex->select_lex);
 
492
  session->abort_on_warning= 0;
561
493
  DRIZZLE_INSERT_END();
562
494
  return(true);
563
495
}
568
500
 
569
501
  SYNOPSIS
570
502
     mysql_prepare_insert_check_table()
571
 
     thd                Thread handle
 
503
     session            Thread handle
572
504
     table_list         Table list
573
505
     fields             List of fields to be updated
574
506
     where              Pointer to where clause
579
511
     true  ERROR
580
512
*/
581
513
 
582
 
static bool mysql_prepare_insert_check_table(THD *thd, TableList *table_list,
583
 
                                             List<Item> &fields __attribute__((unused)),
 
514
static bool mysql_prepare_insert_check_table(Session *session, TableList *table_list,
 
515
                                             List<Item> &,
584
516
                                             bool select_insert)
585
517
{
586
 
  
 
518
 
587
519
 
588
520
  /*
589
521
     first table in list is the one we'll INSERT into, requires INSERT_ACL.
592
524
     than INSERT.
593
525
  */
594
526
 
595
 
  if (setup_tables_and_check_access(thd, &thd->lex->select_lex.context,
596
 
                                    &thd->lex->select_lex.top_join_list,
 
527
  if (setup_tables_and_check_access(session, &session->lex->select_lex.context,
 
528
                                    &session->lex->select_lex.top_join_list,
597
529
                                    table_list,
598
 
                                    &thd->lex->select_lex.leaf_tables,
 
530
                                    &session->lex->select_lex.leaf_tables,
599
531
                                    select_insert))
600
532
    return(true);
601
533
 
608
540
 
609
541
  SYNOPSIS
610
542
    mysql_prepare_insert()
611
 
    thd                 Thread handler
 
543
    session                     Thread handler
612
544
    table_list          Global/local table list
613
545
    table               Table to insert into (can be NULL if table should
614
 
                        be taken from table_list->table)    
 
546
                        be taken from table_list->table)
615
547
    where               Where clause (for insert ... select)
616
548
    select_insert       true if INSERT ... SELECT statement
617
 
    check_fields        true if need to check that all INSERT fields are 
 
549
    check_fields        true if need to check that all INSERT fields are
618
550
                        given values.
619
 
    abort_on_warning    whether to report if some INSERT field is not 
 
551
    abort_on_warning    whether to report if some INSERT field is not
620
552
                        assigned as an error (true) or as a warning (false).
621
553
 
622
554
  TODO (in far future)
628
560
  WARNING
629
561
    You MUST set table->insert_values to 0 after calling this function
630
562
    before releasing the table object.
631
 
  
 
563
 
632
564
  RETURN VALUE
633
565
    false OK
634
566
    true  error
635
567
*/
636
568
 
637
 
bool mysql_prepare_insert(THD *thd, TableList *table_list,
 
569
bool mysql_prepare_insert(Session *session, TableList *table_list,
638
570
                          Table *table, List<Item> &fields, List_item *values,
639
571
                          List<Item> &update_fields, List<Item> &update_values,
640
572
                          enum_duplicates duplic,
641
 
                          COND **where __attribute__((unused)),
 
573
                          COND **,
642
574
                          bool select_insert,
643
575
                          bool check_fields, bool abort_on_warning)
644
576
{
645
 
  SELECT_LEX *select_lex= &thd->lex->select_lex;
 
577
  Select_Lex *select_lex= &session->lex->select_lex;
646
578
  Name_resolution_context *context= &select_lex->context;
647
579
  Name_resolution_context_state ctx_state;
648
580
  bool insert_into_view= (0 != 0);
649
581
  bool res= 0;
650
582
  table_map map= 0;
651
 
  
 
583
 
652
584
  /* INSERT should have a SELECT or VALUES clause */
653
585
  assert (!select_insert || !values);
654
586
 
655
587
  /*
656
588
    For subqueries in VALUES() we should not see the table in which we are
657
589
    inserting (for INSERT ... SELECT this is done by changing table_list,
658
 
    because INSERT ... SELECT share SELECT_LEX it with SELECT.
 
590
    because INSERT ... SELECT share Select_Lex it with SELECT.
659
591
  */
660
592
  if (!select_insert)
661
593
  {
662
 
    for (SELECT_LEX_UNIT *un= select_lex->first_inner_unit();
 
594
    for (Select_Lex_Unit *un= select_lex->first_inner_unit();
663
595
         un;
664
596
         un= un->next_unit())
665
597
    {
666
 
      for (SELECT_LEX *sl= un->first_select();
 
598
      for (Select_Lex *sl= un->first_select();
667
599
           sl;
668
600
           sl= sl->next_select())
669
601
      {
675
607
  if (duplic == DUP_UPDATE)
676
608
  {
677
609
    /* it should be allocated before Item::fix_fields() */
678
 
    if (table_list->set_insert_values(thd->mem_root))
 
610
    if (table_list->set_insert_values(session->mem_root))
679
611
      return(true);
680
612
  }
681
613
 
682
 
  if (mysql_prepare_insert_check_table(thd, table_list, fields, select_insert))
 
614
  if (mysql_prepare_insert_check_table(session, table_list, fields, select_insert))
683
615
    return(true);
684
616
 
685
617
 
699
631
    table_list->next_local= 0;
700
632
    context->resolve_in_table_list_only(table_list);
701
633
 
702
 
    res= check_insert_fields(thd, context->table_list, fields, *values,
 
634
    res= check_insert_fields(session, context->table_list, fields, *values,
703
635
                             !insert_into_view, &map) ||
704
 
      setup_fields(thd, 0, *values, MARK_COLUMNS_READ, 0, 0);
 
636
      setup_fields(session, 0, *values, MARK_COLUMNS_READ, 0, 0);
705
637
 
706
638
    if (!res && check_fields)
707
639
    {
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 : 
 
640
      bool saved_abort_on_warning= session->abort_on_warning;
 
641
      session->abort_on_warning= abort_on_warning;
 
642
      res= check_that_all_fields_are_given_values(session,
 
643
                                                  table ? table :
712
644
                                                  context->table_list->table,
713
645
                                                  context->table_list);
714
 
      thd->abort_on_warning= saved_abort_on_warning;
 
646
      session->abort_on_warning= saved_abort_on_warning;
715
647
    }
716
648
 
717
649
    if (!res && duplic == DUP_UPDATE)
718
650
    {
719
 
      res= check_update_fields(thd, context->table_list, update_fields, &map);
 
651
      res= check_update_fields(session, context->table_list, update_fields, &map);
720
652
    }
721
653
 
722
654
    /* Restore the current context. */
723
655
    ctx_state.restore_state(context, table_list);
724
656
 
725
657
    if (!res)
726
 
      res= setup_fields(thd, 0, update_values, MARK_COLUMNS_READ, 0, 0);
 
658
      res= setup_fields(session, 0, update_values, MARK_COLUMNS_READ, 0, 0);
727
659
  }
728
660
 
729
661
  if (res)
735
667
  if (!select_insert)
736
668
  {
737
669
    TableList *duplicate;
738
 
    if ((duplicate= unique_table(thd, table_list, table_list->next_global, 1)))
 
670
    if ((duplicate= unique_table(session, table_list, table_list->next_global, 1)))
739
671
    {
740
672
      update_non_unique_table_error(table_list, "INSERT", duplicate);
741
673
      return(true);
764
696
 
765
697
  SYNOPSIS
766
698
     write_record()
767
 
      thd   - thread context
 
699
      session   - thread context
768
700
      table - table to which record should be written
769
701
      info  - COPY_INFO structure describing handling of duplicates
770
702
              and which is used for counting number of records inserted
776
708
    then both on update triggers will work instead. Similarly both on
777
709
    delete triggers will be invoked if we will delete conflicting records.
778
710
 
779
 
    Sets thd->transaction.stmt.modified_non_trans_table to true if table which is updated didn't have
 
711
    Sets session->transaction.stmt.modified_non_trans_table to true if table which is updated didn't have
780
712
    transactions.
781
713
 
782
714
  RETURN VALUE
785
717
*/
786
718
 
787
719
 
788
 
int write_record(THD *thd, Table *table,COPY_INFO *info)
 
720
int write_record(Session *session, Table *table,COPY_INFO *info)
789
721
{
790
722
  int error;
791
723
  char *key=0;
792
724
  MY_BITMAP *save_read_set, *save_write_set;
793
725
  uint64_t prev_insert_id= table->file->next_insert_id;
794
726
  uint64_t insert_id_for_cur_row= 0;
795
 
  
 
727
 
796
728
 
797
729
  info->records++;
798
730
  save_read_set=  table->read_set;
799
731
  save_write_set= table->write_set;
800
732
 
801
 
  if (info->handle_duplicates == DUP_REPLACE ||
802
 
      info->handle_duplicates == DUP_UPDATE)
 
733
  if (info->handle_duplicates == DUP_REPLACE || info->handle_duplicates == DUP_UPDATE)
803
734
  {
804
735
    while ((error=table->file->ha_write_row(table->record[0])))
805
736
    {
808
739
        If we do more than one iteration of this loop, from the second one the
809
740
        row will have an explicit value in the autoinc field, which was set at
810
741
        the first call of handler::update_auto_increment(). So we must save
811
 
        the autogenerated value to avoid thd->insert_id_for_cur_row to become
 
742
        the autogenerated value to avoid session->insert_id_for_cur_row to become
812
743
        0.
813
744
      */
814
745
      if (table->file->insert_id_for_cur_row > 0)
862
793
 
863
794
        if (!key)
864
795
        {
865
 
          if (!(key=(char*) my_safe_alloca(table->s->max_unique_length,
866
 
                                           MAX_KEY_LENGTH)))
 
796
          if (!(key=(char*) malloc(table->s->max_unique_length)))
867
797
          {
868
798
            error=ENOMEM;
869
799
            goto err;
887
817
        restore_record(table,record[1]);
888
818
        assert(info->update_fields->elements ==
889
819
                    info->update_values->elements);
890
 
        if (fill_record(thd, *info->update_fields,
 
820
        if (fill_record(session, *info->update_fields,
891
821
                                                 *info->update_values,
892
822
                                                 info->ignore))
893
823
          goto before_err;
922
852
            like a regular UPDATE statement: it should not affect the value of a
923
853
            next SELECT LAST_INSERT_ID() or mysql_insert_id().
924
854
            Except if LAST_INSERT_ID(#) was in the INSERT query, which is
925
 
            handled separately by THD::arg_of_last_insert_id_function.
 
855
            handled separately by Session::arg_of_last_insert_id_function.
926
856
          */
927
857
          insert_id_for_cur_row= table->file->insert_id_for_cur_row= 0;
928
858
          info->copied++;
942
872
          an INSERT or DELETE(s) + INSERT; FOREIGN KEY checks in
943
873
          InnoDB do not function in the defined way if we allow MySQL
944
874
          to convert the latter operation internally to an UPDATE.
945
 
          We also should not perform this conversion if we have 
 
875
          We also should not perform this conversion if we have
946
876
          timestamp field with ON UPDATE which is different from DEFAULT.
947
877
          Another case when conversion should not be performed is when
948
878
          we have ON DELETE trigger on table so user may notice that
964
894
            info->deleted++;
965
895
          else
966
896
            error= 0;
967
 
          thd->record_first_successful_insert_id_in_cur_stmt(table->file->insert_id_for_cur_row);
 
897
          session->record_first_successful_insert_id_in_cur_stmt(table->file->insert_id_for_cur_row);
968
898
          /*
969
899
            Since we pretend that we have done insert we should call
970
900
            its after triggers.
977
907
            goto err;
978
908
          info->deleted++;
979
909
          if (!table->file->has_transactions())
980
 
            thd->transaction.stmt.modified_non_trans_table= true;
 
910
            session->transaction.stmt.modified_non_trans_table= true;
981
911
          /* Let us attempt do write_row() once more */
982
912
        }
983
913
      }
984
914
    }
985
 
    thd->record_first_successful_insert_id_in_cur_stmt(table->file->insert_id_for_cur_row);
 
915
    session->record_first_successful_insert_id_in_cur_stmt(table->file->insert_id_for_cur_row);
986
916
    /*
987
917
      Restore column maps if they where replaced during an duplicate key
988
918
      problem.
1002
932
 
1003
933
after_n_copied_inc:
1004
934
  info->copied++;
1005
 
  thd->record_first_successful_insert_id_in_cur_stmt(table->file->insert_id_for_cur_row);
 
935
  session->record_first_successful_insert_id_in_cur_stmt(table->file->insert_id_for_cur_row);
1006
936
 
1007
937
gok_or_after_err:
1008
938
  if (key)
1009
 
    my_safe_afree(key,table->s->max_unique_length,MAX_KEY_LENGTH);
 
939
    free(key);
1010
940
  if (!table->file->has_transactions())
1011
 
    thd->transaction.stmt.modified_non_trans_table= true;
 
941
    session->transaction.stmt.modified_non_trans_table= true;
1012
942
  return(0);
1013
943
 
1014
944
err:
1015
945
  info->last_errno= error;
1016
946
  /* current_select is NULL if this is a delayed insert */
1017
 
  if (thd->lex->current_select)
1018
 
    thd->lex->current_select->no_error= 0;        // Give error
 
947
  if (session->lex->current_select)
 
948
    session->lex->current_select->no_error= 0;        // Give error
1019
949
  table->file->print_error(error,MYF(0));
1020
 
  
 
950
 
1021
951
before_err:
1022
952
  table->file->restore_auto_increment(prev_insert_id);
1023
953
  if (key)
1024
 
    my_safe_afree(key, table->s->max_unique_length, MAX_KEY_LENGTH);
 
954
    free(key);
1025
955
  table->column_bitmaps_set(save_read_set, save_write_set);
1026
956
  return(1);
1027
957
}
1031
961
  Check that all fields with arn't null_fields are used
1032
962
******************************************************************************/
1033
963
 
1034
 
int check_that_all_fields_are_given_values(THD *thd, Table *entry,
1035
 
                                           TableList *table_list)
 
964
int check_that_all_fields_are_given_values(Session *session, Table *entry,
 
965
                                           TableList *)
1036
966
{
1037
967
  int err= 0;
1038
968
  MY_BITMAP *write_set= entry->write_set;
1039
969
 
1040
970
  for (Field **field=entry->field ; *field ; field++)
1041
971
  {
1042
 
    if (!bitmap_is_set(write_set, (*field)->field_index) &&
1043
 
        ((*field)->flags & NO_DEFAULT_VALUE_FLAG) &&
 
972
    if (!bitmap_is_set(write_set, (*field)->field_index))
 
973
    {
 
974
      /*
 
975
       * If the field doesn't have any default value
 
976
       * and there is no actual value specified in the
 
977
       * INSERT statement, throw error ER_NO_DEFAULT_FOR_FIELD.
 
978
       */
 
979
      if (((*field)->flags & NO_DEFAULT_VALUE_FLAG) &&
1044
980
        ((*field)->real_type() != DRIZZLE_TYPE_ENUM))
 
981
      {
 
982
        my_error(ER_NO_DEFAULT_FOR_FIELD, MYF(0), (*field)->field_name);
 
983
        err= 1;
 
984
      }
 
985
    }
 
986
    else
1045
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
      /*
 
989
       * However, if an actual NULL value was specified
 
990
       * for the field and the field is a NOT NULL field, 
 
991
       * throw ER_BAD_NULL_ERROR.
 
992
       *
 
993
       * Per the SQL standard, inserting NULL into a NOT NULL
 
994
       * field requires an error to be thrown.
 
995
       */
 
996
      if (((*field)->flags & NOT_NULL_FLAG) &&
 
997
          (*field)->is_null())
 
998
      {
 
999
        my_error(ER_BAD_NULL_ERROR, MYF(0), (*field)->field_name);
 
1000
        err= 1;
 
1001
      }
1059
1002
    }
1060
1003
  }
1061
 
  return thd->abort_on_warning ? err : 0;
 
1004
  return session->abort_on_warning ? err : 0;
1062
1005
}
1063
1006
 
1064
1007
/***************************************************************************
1071
1014
 
1072
1015
  SYNOPSIS
1073
1016
    mysql_insert_select_prepare()
1074
 
    thd         thread handler
 
1017
    session         thread handler
1075
1018
 
1076
1019
  RETURN
1077
1020
    false OK
1078
1021
    true  Error
1079
1022
*/
1080
1023
 
1081
 
bool mysql_insert_select_prepare(THD *thd)
 
1024
bool mysql_insert_select_prepare(Session *session)
1082
1025
{
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
 
1026
  LEX *lex= session->lex;
 
1027
  Select_Lex *select_lex= &lex->select_lex;
 
1028
 
 
1029
  /*
 
1030
    Select_Lex do not belong to INSERT statement, so we can't add WHERE
1102
1031
    clause if table is VIEW
1103
1032
  */
1104
 
  
1105
 
  if (mysql_prepare_insert(thd, lex->query_tables,
 
1033
 
 
1034
  if (mysql_prepare_insert(session, lex->query_tables,
1106
1035
                           lex->query_tables->table, lex->field_list, 0,
1107
1036
                           lex->update_list, lex->value_list,
1108
1037
                           lex->duplicates,
1140
1069
 
1141
1070
 
1142
1071
int
1143
 
select_insert::prepare(List<Item> &values, SELECT_LEX_UNIT *u)
 
1072
select_insert::prepare(List<Item> &values, Select_Lex_Unit *u)
1144
1073
{
1145
 
  LEX *lex= thd->lex;
 
1074
  LEX *lex= session->lex;
1146
1075
  int res;
1147
1076
  table_map map= 0;
1148
 
  SELECT_LEX *lex_current_select_save= lex->current_select;
1149
 
  
 
1077
  Select_Lex *lex_current_select_save= lex->current_select;
 
1078
 
1150
1079
 
1151
1080
  unit= u;
1152
1081
 
1156
1085
    we are fixing fields from insert list.
1157
1086
  */
1158
1087
  lex->current_select= &lex->select_lex;
1159
 
  res= check_insert_fields(thd, table_list, *fields, values,
 
1088
  res= check_insert_fields(session, table_list, *fields, values,
1160
1089
                           !insert_into_view, &map) ||
1161
 
       setup_fields(thd, 0, values, MARK_COLUMNS_READ, 0, 0);
 
1090
       setup_fields(session, 0, values, MARK_COLUMNS_READ, 0, 0);
1162
1091
 
1163
1092
  if (!res && fields->elements)
1164
1093
  {
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, 
 
1094
    bool saved_abort_on_warning= session->abort_on_warning;
 
1095
    session->abort_on_warning= !info.ignore;
 
1096
    res= check_that_all_fields_are_given_values(session, table_list->table,
1168
1097
                                                table_list);
1169
 
    thd->abort_on_warning= saved_abort_on_warning;
 
1098
    session->abort_on_warning= saved_abort_on_warning;
1170
1099
  }
1171
1100
 
1172
1101
  if (info.handle_duplicates == DUP_UPDATE && !res)
1181
1110
    table_list->next_local= 0;
1182
1111
    context->resolve_in_table_list_only(table_list);
1183
1112
 
1184
 
    res= res || check_update_fields(thd, context->table_list,
 
1113
    res= res || check_update_fields(session, context->table_list,
1185
1114
                                    *info.update_fields, &map);
1186
1115
    /*
1187
 
      When we are not using GROUP BY and there are no ungrouped aggregate functions 
 
1116
      When we are not using GROUP BY and there are no ungrouped aggregate functions
1188
1117
      we can refer to other tables in the ON DUPLICATE KEY part.
1189
1118
      We use next_name_resolution_table descructively, so check it first (views?)
1190
1119
    */
1195
1124
        We must make a single context out of the two separate name resolution contexts :
1196
1125
        the INSERT table and the tables in the SELECT part of INSERT ... SELECT.
1197
1126
        To do that we must concatenate the two lists
1198
 
      */  
1199
 
      table_list->next_name_resolution_table= 
 
1127
      */
 
1128
      table_list->next_name_resolution_table=
1200
1129
        ctx_state.get_first_name_resolution_table();
1201
1130
 
1202
 
    res= res || setup_fields(thd, 0, *info.update_values,
 
1131
    res= res || setup_fields(session, 0, *info.update_values,
1203
1132
                             MARK_COLUMNS_READ, 0, 0);
1204
1133
    if (!res)
1205
1134
    {
1236
1165
    Is table which we are changing used somewhere in other parts of
1237
1166
    query
1238
1167
  */
1239
 
  if (unique_table(thd, table_list, table_list->next_global, 0))
 
1168
  if (unique_table(session, table_list, table_list->next_global, 0))
1240
1169
  {
1241
1170
    /* Using same table for INSERT and SELECT */
1242
1171
    lex->current_select->options|= OPTION_BUFFER_RESULT;
1245
1174
  else if (!(lex->current_select->options & OPTION_BUFFER_RESULT))
1246
1175
  {
1247
1176
    /*
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 
 
1177
      We must not yet prepare the result table if it is the same as one of the
 
1178
      source tables (INSERT SELECT). The preparation may disable
1250
1179
      indexes on the result table, which may be used during the select, if it
1251
1180
      is the same table (Bug #6034). Do the preparation after the select phase
1252
1181
      in select_insert::prepare2().
1258
1187
  restore_record(table,s->default_values);              // Get empty record
1259
1188
  table->next_number_field=table->found_next_number_field;
1260
1189
 
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;
 
1190
  session->cuted_fields=0;
1268
1191
  if (info.ignore || info.handle_duplicates != DUP_ERROR)
1269
1192
    table->file->extra(HA_EXTRA_IGNORE_DUP_KEY);
1270
1193
  if (info.handle_duplicates == DUP_REPLACE)
1271
1194
    table->file->extra(HA_EXTRA_WRITE_CAN_REPLACE);
1272
1195
  if (info.handle_duplicates == DUP_UPDATE)
1273
1196
    table->file->extra(HA_EXTRA_INSERT_WITH_UPDATE);
1274
 
  thd->abort_on_warning= !info.ignore;
 
1197
  session->abort_on_warning= !info.ignore;
1275
1198
  table->mark_columns_needed_for_insert();
1276
1199
 
1277
1200
 
1290
1213
    If the result table is the same as one of the source tables (INSERT SELECT),
1291
1214
    the result table is not finally prepared at the join prepair phase.
1292
1215
    Do the final preparation now.
1293
 
                       
 
1216
 
1294
1217
  RETURN
1295
1218
    0   OK
1296
1219
*/
1297
1220
 
1298
1221
int select_insert::prepare2(void)
1299
1222
{
1300
 
  
1301
 
  if (thd->lex->current_select->options & OPTION_BUFFER_RESULT)
 
1223
 
 
1224
  if (session->lex->current_select->options & OPTION_BUFFER_RESULT)
1302
1225
    table->file->ha_start_bulk_insert((ha_rows) 0);
1303
1226
  return(0);
1304
1227
}
1312
1235
 
1313
1236
select_insert::~select_insert()
1314
1237
{
1315
 
  
 
1238
 
1316
1239
  if (table)
1317
1240
  {
1318
1241
    table->next_number_field=0;
1319
1242
    table->auto_increment_field_not_null= false;
1320
1243
    table->file->ha_reset();
1321
1244
  }
1322
 
  thd->count_cuted_fields= CHECK_FIELD_IGNORE;
1323
 
  thd->abort_on_warning= 0;
 
1245
  session->count_cuted_fields= CHECK_FIELD_IGNORE;
 
1246
  session->abort_on_warning= 0;
1324
1247
  return;
1325
1248
}
1326
1249
 
1327
1250
 
1328
1251
bool select_insert::send_data(List<Item> &values)
1329
1252
{
1330
 
  
 
1253
 
1331
1254
  bool error=0;
1332
1255
 
1333
1256
  if (unit->offset_limit_cnt)
1336
1259
    return(0);
1337
1260
  }
1338
1261
 
1339
 
  thd->count_cuted_fields= CHECK_FIELD_WARN;    // Calculate cuted fields
 
1262
  session->count_cuted_fields= CHECK_FIELD_WARN;        // Calculate cuted fields
1340
1263
  store_values(values);
1341
 
  thd->count_cuted_fields= CHECK_FIELD_IGNORE;
1342
 
  if (thd->is_error())
 
1264
  session->count_cuted_fields= CHECK_FIELD_IGNORE;
 
1265
  if (session->is_error())
1343
1266
    return(1);
1344
1267
 
1345
 
  error= write_record(thd, table, &info);
1346
 
    
 
1268
  error= write_record(session, table, &info);
 
1269
 
1347
1270
  if (!error)
1348
1271
  {
1349
1272
    if (info.handle_duplicates == DUP_UPDATE)
1351
1274
      /*
1352
1275
        Restore fields of the record since it is possible that they were
1353
1276
        changed by ON DUPLICATE KEY UPDATE clause.
1354
 
    
 
1277
 
1355
1278
        If triggers exist then whey can modify some fields which were not
1356
1279
        originally touched by INSERT ... SELECT, so we have to restore
1357
1280
        their original values for the next row.
1364
1287
        If no value has been autogenerated so far, we need to remember the
1365
1288
        value we just saw, we may need to send it to client in the end.
1366
1289
      */
1367
 
      if (thd->first_successful_insert_id_in_cur_stmt == 0) // optimization
1368
 
        autoinc_value_of_last_inserted_row= 
 
1290
      if (session->first_successful_insert_id_in_cur_stmt == 0) // optimization
 
1291
        autoinc_value_of_last_inserted_row=
1369
1292
          table->next_number_field->val_int();
1370
1293
      /*
1371
1294
        Clear auto-increment field for the next record, if triggers are used
1381
1304
void select_insert::store_values(List<Item> &values)
1382
1305
{
1383
1306
  if (fields->elements)
1384
 
    fill_record(thd, *fields, values, 1);
 
1307
    fill_record(session, *fields, values, 1);
1385
1308
  else
1386
 
    fill_record(thd, table->field, values, 1);
 
1309
    fill_record(session, table->field, values, 1);
1387
1310
}
1388
1311
 
1389
1312
void select_insert::send_error(uint32_t errcode,const char *err)
1390
1313
{
1391
 
  
 
1314
 
1392
1315
 
1393
1316
  my_message(errcode, err, MYF(0));
1394
1317
 
1402
1325
  bool const trans_table= table->file->has_transactions();
1403
1326
  uint64_t id;
1404
1327
  bool changed;
1405
 
  THD::killed_state killed_status= thd->killed;
1406
 
  
 
1328
 
1407
1329
  error= table->file->ha_end_bulk_insert();
1408
1330
  table->file->extra(HA_EXTRA_NO_IGNORE_DUP_KEY);
1409
1331
  table->file->extra(HA_EXTRA_WRITE_CANNOT_REPLACE);
1414
1336
      We must invalidate the table in the query cache before binlog writing
1415
1337
      and ha_autocommit_or_rollback.
1416
1338
    */
1417
 
    if (thd->transaction.stmt.modified_non_trans_table)
1418
 
      thd->transaction.all.modified_non_trans_table= true;
 
1339
    if (session->transaction.stmt.modified_non_trans_table)
 
1340
      session->transaction.all.modified_non_trans_table= true;
1419
1341
  }
1420
 
  assert(trans_table || !changed || 
1421
 
              thd->transaction.stmt.modified_non_trans_table);
 
1342
  assert(trans_table || !changed ||
 
1343
              session->transaction.stmt.modified_non_trans_table);
1422
1344
 
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
1345
  table->file->ha_release_auto_increment();
1438
1346
 
1439
1347
  if (error)
1444
1352
  char buff[160];
1445
1353
  if (info.ignore)
1446
1354
    sprintf(buff, ER(ER_INSERT_INFO), (ulong) info.records,
1447
 
            (ulong) (info.records - info.copied), (ulong) thd->cuted_fields);
 
1355
            (ulong) (info.records - info.copied), (ulong) session->cuted_fields);
1448
1356
  else
1449
1357
    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) ?
 
1358
            (ulong) (info.deleted+info.updated), (ulong) session->cuted_fields);
 
1359
  session->row_count_func= info.copied + info.deleted +
 
1360
                       ((session->client_capabilities & CLIENT_FOUND_ROWS) ?
1453
1361
                        info.touched : info.updated);
1454
1362
 
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 :
 
1363
  id= (session->first_successful_insert_id_in_cur_stmt > 0) ?
 
1364
    session->first_successful_insert_id_in_cur_stmt :
 
1365
    (session->arg_of_last_insert_id_function ?
 
1366
     session->first_successful_insert_id_in_prev_stmt :
1459
1367
     (info.copied ? autoinc_value_of_last_inserted_row : 0));
1460
 
  ::my_ok(thd, (ulong) thd->row_count_func, id, buff);
 
1368
  session->my_ok((ulong) session->row_count_func, id, buff);
1461
1369
  return(0);
1462
1370
}
1463
1371
 
1464
1372
void select_insert::abort() {
1465
1373
 
1466
 
  
 
1374
 
1467
1375
  /*
1468
1376
    If the creation of the table failed (due to a syntax error, for
1469
1377
    example), no table will have been opened and therefore 'table'
1492
1400
    */
1493
1401
    changed= (info.copied || info.deleted || info.updated);
1494
1402
    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
 
    }
1503
1403
    assert(transactional_table || !changed ||
1504
 
                thd->transaction.stmt.modified_non_trans_table);
 
1404
                session->transaction.stmt.modified_non_trans_table);
1505
1405
    table->file->ha_release_auto_increment();
1506
1406
  }
1507
1407
 
1519
1419
 
1520
1420
  SYNOPSIS
1521
1421
    create_table_from_items()
1522
 
      thd          in     Thread object
 
1422
      session          in     Thread object
1523
1423
      create_info  in     Create information (like MAX_ROWS, ENGINE or
1524
1424
                          temporary table flag)
1525
1425
      create_table in     Pointer to TableList object providing database
1532
1432
      lock         out    Pointer to the DRIZZLE_LOCK object for table created
1533
1433
                          (or open temporary table) will be returned in this
1534
1434
                          parameter. Since this table is not included in
1535
 
                          THD::lock caller is responsible for explicitly
 
1435
                          Session::lock caller is responsible for explicitly
1536
1436
                          unlocking this table.
1537
1437
      hooks
1538
1438
 
1555
1455
    0         Error
1556
1456
*/
1557
1457
 
1558
 
static Table *create_table_from_items(THD *thd, HA_CREATE_INFO *create_info,
 
1458
static Table *create_table_from_items(Session *session, HA_CREATE_INFO *create_info,
1559
1459
                                      TableList *create_table,
1560
1460
                                      Alter_info *alter_info,
1561
1461
                                      List<Item> *items,
1562
 
                                      DRIZZLE_LOCK **lock,
1563
 
                                      TABLEOP_HOOKS *hooks)
 
1462
                                      DRIZZLE_LOCK **lock)
1564
1463
{
1565
1464
  Table tmp_table;              // Used during 'Create_field()'
1566
1465
  TABLE_SHARE share;
1579
1478
    if (create_info->options & HA_LEX_CREATE_IF_NOT_EXISTS)
1580
1479
    {
1581
1480
      create_info->table_existed= 1;            // Mark that table existed
1582
 
      push_warning_printf(thd, DRIZZLE_ERROR::WARN_LEVEL_NOTE,
 
1481
      push_warning_printf(session, DRIZZLE_ERROR::WARN_LEVEL_NOTE,
1583
1482
                          ER_TABLE_EXISTS_ERROR, ER(ER_TABLE_EXISTS_ERROR),
1584
1483
                          create_table->table_name);
1585
1484
      return(create_table->table);
1592
1491
  tmp_table.alias= 0;
1593
1492
  tmp_table.timestamp_field= 0;
1594
1493
  tmp_table.s= &share;
1595
 
  init_tmp_table_share(thd, &share, "", 0, "", "");
 
1494
  init_tmp_table_share(session, &share, "", 0, "", "");
1596
1495
 
1597
1496
  tmp_table.s->db_create_options=0;
1598
1497
  tmp_table.s->blob_ptr_size= portable_sizeof_char_ptr;
1599
 
  tmp_table.s->db_low_byte_first= 
 
1498
  tmp_table.s->db_low_byte_first=
1600
1499
        test(create_info->db_type == myisam_hton ||
1601
1500
             create_info->db_type == heap_hton);
1602
1501
  tmp_table.null_row= false;
1612
1511
      else
1613
1512
        field= item->tmp_table_field_from_field_type(&tmp_table, 0);
1614
1513
    else
1615
 
      field= create_tmp_field(thd, &tmp_table, item, item->type(),
 
1514
      field= create_tmp_field(session, &tmp_table, item, item->type(),
1616
1515
                              (Item ***) 0, &tmp_field, &def_field, 0, 0, 0, 0,
1617
1516
                              0);
1618
1517
    if (!field ||
1642
1541
    open_table().
1643
1542
  */
1644
1543
  {
1645
 
    tmp_disable_binlog(thd);
1646
 
    if (!mysql_create_table_no_lock(thd, create_table->db,
 
1544
    if (!mysql_create_table_no_lock(session, create_table->db,
1647
1545
                                    create_table->table_name,
1648
1546
                                    create_info, alter_info, 0,
1649
 
                                    select_field_count))
 
1547
                                    select_field_count, true))
1650
1548
    {
1651
1549
      if (create_info->table_existed &&
1652
1550
          !(create_info->options & HA_LEX_CREATE_TMP_TABLE))
1663
1561
      if (!(create_info->options & HA_LEX_CREATE_TMP_TABLE))
1664
1562
      {
1665
1563
        pthread_mutex_lock(&LOCK_open);
1666
 
        if (reopen_name_locked_table(thd, create_table, false))
 
1564
        if (reopen_name_locked_table(session, create_table, false))
1667
1565
        {
1668
1566
          quick_rm_table(create_info->db_type, create_table->db,
1669
1567
                         table_case_name(create_info, create_table->table_name),
1675
1573
      }
1676
1574
      else
1677
1575
      {
1678
 
        if (!(table= open_table(thd, create_table, (bool*) 0,
 
1576
        if (!(table= open_table(session, create_table, (bool*) 0,
1679
1577
                                DRIZZLE_OPEN_TEMPORARY_ONLY)) &&
1680
1578
            !create_info->table_existed)
1681
1579
        {
1684
1582
            it preparable for open. But let us do close_temporary_table() here
1685
1583
            just in case.
1686
1584
          */
1687
 
          drop_temporary_table(thd, create_table);
 
1585
          drop_temporary_table(session, create_table);
1688
1586
        }
1689
1587
      }
1690
1588
    }
1691
 
    reenable_binlog(thd);
1692
1589
    if (!table)                                   // open failed
1693
1590
      return(0);
1694
1591
  }
1695
1592
 
1696
1593
  table->reginfo.lock_type=TL_WRITE;
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))
 
1594
  if (! ((*lock)= mysql_lock_tables(session, &table, 1,
 
1595
                                    DRIZZLE_LOCK_IGNORE_FLUSH, &not_used)))
1701
1596
  {
1702
1597
    if (*lock)
1703
1598
    {
1704
 
      mysql_unlock_tables(thd, *lock);
 
1599
      mysql_unlock_tables(session, *lock);
1705
1600
      *lock= 0;
1706
1601
    }
1707
1602
 
1708
1603
    if (!create_info->table_existed)
1709
 
      drop_open_table(thd, table, create_table->db, create_table->table_name);
 
1604
      drop_open_table(session, table, create_table->db, create_table->table_name);
1710
1605
    return(0);
1711
1606
  }
1712
1607
  return(table);
1714
1609
 
1715
1610
 
1716
1611
int
1717
 
select_create::prepare(List<Item> &values, SELECT_LEX_UNIT *u)
 
1612
select_create::prepare(List<Item> &values, Select_Lex_Unit *u)
1718
1613
{
1719
1614
  DRIZZLE_LOCK *extra_lock= NULL;
1720
 
  
1721
 
 
1722
 
  TABLEOP_HOOKS *hook_ptr= NULL;
1723
1615
  /*
1724
1616
    For row-based replication, the CREATE-SELECT statement is written
1725
1617
    in two pieces: the first one contain the CREATE TABLE statement
1738
1630
    slave.  Hence, we have to hold on to the CREATE part of the
1739
1631
    statement until the statement has finished.
1740
1632
   */
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;
1773
1633
 
1774
1634
  unit= u;
1775
1635
 
1778
1638
    row-based replication for the statement.  If we are creating a
1779
1639
    temporary table, we need to start a statement transaction.
1780
1640
  */
1781
 
  if ((thd->lex->create_info.options & HA_LEX_CREATE_TMP_TABLE) == 0 &&
1782
 
      thd->current_stmt_binlog_row_based)
1783
 
  {
1784
 
    thd->binlog_start_trans_and_stmt();
1785
 
  }
1786
1641
 
1787
 
  if (!(table= create_table_from_items(thd, create_info, create_table,
 
1642
  if (!(table= create_table_from_items(session, create_info, create_table,
1788
1643
                                       alter_info, &values,
1789
 
                                       &extra_lock, hook_ptr)))
 
1644
                                       &extra_lock)))
1790
1645
    return(-1);                         // abort() deletes table
1791
1646
 
1792
1647
  if (extra_lock)
1796
1651
    if (create_info->options & HA_LEX_CREATE_TMP_TABLE)
1797
1652
      m_plock= &m_lock;
1798
1653
    else
1799
 
      m_plock= &thd->extra_lock;
 
1654
      m_plock= &session->extra_lock;
1800
1655
 
1801
1656
    *m_plock= extra_lock;
1802
1657
  }
1819
1674
  table->next_number_field=table->found_next_number_field;
1820
1675
 
1821
1676
  restore_record(table,s->default_values);      // Get empty record
1822
 
  thd->cuted_fields=0;
 
1677
  session->cuted_fields=0;
1823
1678
  if (info.ignore || info.handle_duplicates != DUP_ERROR)
1824
1679
    table->file->extra(HA_EXTRA_IGNORE_DUP_KEY);
1825
1680
  if (info.handle_duplicates == DUP_REPLACE)
1827
1682
  if (info.handle_duplicates == DUP_UPDATE)
1828
1683
    table->file->extra(HA_EXTRA_INSERT_WITH_UPDATE);
1829
1684
  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))
 
1685
  session->abort_on_warning= !info.ignore;
 
1686
  if (check_that_all_fields_are_given_values(session, table, table_list))
1832
1687
    return(1);
1833
1688
  table->mark_columns_needed_for_insert();
1834
1689
  table->file->extra(HA_EXTRA_WRITE_CACHE);
1835
1690
  return(0);
1836
1691
}
1837
1692
 
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
 
 
1879
1693
void select_create::store_values(List<Item> &values)
1880
1694
{
1881
 
  fill_record(thd, field, values, 1);
 
1695
  fill_record(session, field, values, 1);
1882
1696
}
1883
1697
 
1884
1698
 
1885
1699
void select_create::send_error(uint32_t errcode,const char *err)
1886
1700
{
1887
 
  
 
1701
 
1888
1702
 
1889
1703
  /*
1890
1704
    This will execute any rollbacks that are necessary before writing
1897
1711
    written to the binary log.
1898
1712
 
1899
1713
  */
1900
 
  tmp_disable_binlog(thd);
1901
1714
  select_insert::send_error(errcode, err);
1902
 
  reenable_binlog(thd);
1903
1715
 
1904
1716
  return;
1905
1717
}
1919
1731
    */
1920
1732
    if (!table->s->tmp_table)
1921
1733
    {
1922
 
      ha_autocommit_or_rollback(thd, 0);
1923
 
      end_active_trans(thd);
 
1734
      ha_autocommit_or_rollback(session, 0);
 
1735
      end_active_trans(session);
1924
1736
    }
1925
1737
 
1926
1738
    table->file->extra(HA_EXTRA_NO_IGNORE_DUP_KEY);
1927
1739
    table->file->extra(HA_EXTRA_WRITE_CANNOT_REPLACE);
1928
1740
    if (m_plock)
1929
1741
    {
1930
 
      mysql_unlock_tables(thd, *m_plock);
 
1742
      mysql_unlock_tables(session, *m_plock);
1931
1743
      *m_plock= NULL;
1932
1744
      m_plock= NULL;
1933
1745
    }
1938
1750
 
1939
1751
void select_create::abort()
1940
1752
{
1941
 
  
 
1753
 
1942
1754
 
1943
1755
  /*
1944
1756
    In select_insert::abort() we roll back the statement, including
1955
1767
    of the table succeeded or not, since we need to reset the binary
1956
1768
    log state.
1957
1769
  */
1958
 
  tmp_disable_binlog(thd);
1959
1770
  select_insert::abort();
1960
 
  thd->transaction.stmt.modified_non_trans_table= false;
1961
 
  reenable_binlog(thd);
 
1771
  session->transaction.stmt.modified_non_trans_table= false;
1962
1772
 
1963
1773
 
1964
1774
  if (m_plock)
1965
1775
  {
1966
 
    mysql_unlock_tables(thd, *m_plock);
 
1776
    mysql_unlock_tables(session, *m_plock);
1967
1777
    *m_plock= NULL;
1968
1778
    m_plock= NULL;
1969
1779
  }
1973
1783
    table->file->extra(HA_EXTRA_NO_IGNORE_DUP_KEY);
1974
1784
    table->file->extra(HA_EXTRA_WRITE_CANNOT_REPLACE);
1975
1785
    if (!create_info->table_existed)
1976
 
      drop_open_table(thd, table, create_table->db, create_table->table_name);
 
1786
      drop_open_table(session, table, create_table->db, create_table->table_name);
1977
1787
    table=0;                                    // Safety
1978
1788
  }
1979
1789
  return;