← 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-05-15 17:06:35 UTC
  • mto: This revision was merged to the branch mainline in revision 1023.
  • Revision ID: brian@gaz-20090515170635-croy1u63a3gqdn9n
Dead convert functions for character sets.

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
 
81
75
      No fields are provided so all fields must be provided in the values.
82
76
      Thus we set all bits in the write set.
83
77
    */
84
 
    bitmap_set_all(table->write_set);
 
78
    table->setWriteSet();
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
124
118
    {
125
 
      if (bitmap_is_set(table->write_set,
126
 
                        table->timestamp_field->field_index))
 
119
      if (table->timestamp_field->isWriteSet())
127
120
        clear_timestamp_auto_bits(table->timestamp_field_type,
128
121
                                  TIMESTAMP_AUTO_SET_ON_INSERT);
129
122
      else
130
123
      {
131
 
        bitmap_set_bit(table->write_set,
132
 
                       table->timestamp_field->field_index);
 
124
        table->setWriteSet(table->timestamp_field->field_index);
133
125
      }
134
126
    }
135
127
  }
143
135
 
144
136
  SYNOPSIS
145
137
    check_update_fields()
146
 
    thd                         The current thread.
 
138
    session                         The current thread.
147
139
    insert_table_list           The insert table list.
148
140
    table                       The table for update.
149
141
    update_fields               The update fields.
157
149
    -1          Error
158
150
*/
159
151
 
160
 
static int check_update_fields(THD *thd, TableList *insert_table_list,
 
152
static int check_update_fields(Session *session, TableList *insert_table_list,
161
153
                               List<Item> &update_fields,
162
 
                               table_map *map __attribute__((unused)))
 
154
                               table_map *)
163
155
{
164
156
  Table *table= insert_table_list->table;
165
157
  bool timestamp_mark= false;
175
167
  }
176
168
 
177
169
  /* Check the fields we are going to modify */
178
 
  if (setup_fields(thd, 0, update_fields, MARK_COLUMNS_WRITE, 0, 0))
 
170
  if (setup_fields(session, 0, update_fields, MARK_COLUMNS_WRITE, 0, 0))
179
171
    return -1;
180
172
 
181
173
  if (table->timestamp_field)
182
174
  {
183
175
    /* Don't set timestamp column if this is modified. */
184
 
    if (bitmap_is_set(table->write_set,
185
 
                      table->timestamp_field->field_index))
 
176
    if (table->timestamp_field->isWriteSet())
186
177
      clear_timestamp_auto_bits(table->timestamp_field_type,
187
178
                                TIMESTAMP_AUTO_SET_ON_UPDATE);
188
179
    if (timestamp_mark)
189
 
      bitmap_set_bit(table->write_set,
190
 
                     table->timestamp_field->field_index);
 
180
      table->setWriteSet(table->timestamp_field->field_index);
191
181
  }
192
182
  return 0;
193
183
}
202
192
*/
203
193
 
204
194
static
205
 
void upgrade_lock_type(THD *thd __attribute__((unused)),
 
195
void upgrade_lock_type(Session *,
206
196
                       thr_lock_type *lock_type,
207
197
                       enum_duplicates duplic,
208
 
                       bool is_multi_insert __attribute__((unused)))
 
198
                       bool )
209
199
{
210
200
  if (duplic == DUP_UPDATE ||
211
201
      (duplic == DUP_REPLACE && *lock_type == TL_WRITE_CONCURRENT_INSERT))
224
214
  end of dispatch_command().
225
215
*/
226
216
 
227
 
bool mysql_insert(THD *thd,TableList *table_list,
 
217
bool mysql_insert(Session *session,TableList *table_list,
228
218
                  List<Item> &fields,
229
219
                  List<List_item> &values_list,
230
220
                  List<Item> &update_fields,
235
225
  int error;
236
226
  bool transactional_table, joins_freed= false;
237
227
  bool changed;
238
 
  bool was_insert_delayed= (table_list->lock_type ==  TL_WRITE_DELAYED);
239
228
  uint32_t value_count;
240
229
  ulong counter = 1;
241
230
  uint64_t id;
247
236
  Name_resolution_context_state ctx_state;
248
237
  thr_lock_type lock_type;
249
238
  Item *unused_conds= 0;
250
 
  
 
239
 
251
240
 
252
241
  /*
253
242
    Upgrade lock type if the requested lock is incompatible with
254
243
    the current connection mode or table operation.
255
244
  */
256
 
  upgrade_lock_type(thd, &table_list->lock_type, duplic,
 
245
  upgrade_lock_type(session, &table_list->lock_type, duplic,
257
246
                    values_list.elements > 1);
258
247
 
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);
 
248
  if (open_and_lock_tables(session, table_list))
270
249
    return(true);
271
 
  }
272
250
 
273
 
  {
274
 
    if (open_and_lock_tables(thd, table_list))
275
 
      return(true);
276
 
  }
277
251
  lock_type= table_list->lock_type;
278
252
 
279
 
  thd_proc_info(thd, "init");
280
 
  thd->used_tables=0;
 
253
  session->set_proc_info("init");
 
254
  session->used_tables=0;
281
255
  values= its++;
282
256
  value_count= values->elements;
283
257
 
284
 
  if (mysql_prepare_insert(thd, table_list, table, fields, values,
 
258
  if (mysql_prepare_insert(session, table_list, table, fields, values,
285
259
                           update_fields, update_values, duplic, &unused_conds,
286
260
                           false,
287
261
                           (fields.elements || !value_count ||
291
265
  /* mysql_prepare_insert set table_list->table if it was not set */
292
266
  table= table_list->table;
293
267
 
294
 
  context= &thd->lex->select_lex.context;
 
268
  context= &session->lex->select_lex.context;
295
269
  /*
296
270
    These three asserts test the hypothesis that the resetting of the name
297
271
    resolution context below is not necessary at all since the list of local
319
293
      my_error(ER_WRONG_VALUE_COUNT_ON_ROW, MYF(0), counter);
320
294
      goto abort;
321
295
    }
322
 
    if (setup_fields(thd, 0, *values, MARK_COLUMNS_READ, 0, 0))
 
296
    if (setup_fields(session, 0, *values, MARK_COLUMNS_READ, 0, 0))
323
297
      goto abort;
324
298
  }
325
299
  its.rewind ();
326
 
 
 
300
 
327
301
  /* Restore the current context. */
328
302
  ctx_state.restore_state(context, table_list);
329
303
 
341
315
    For single line insert, generate an error if try to set a NOT NULL field
342
316
    to NULL.
343
317
  */
344
 
  thd->count_cuted_fields= ((values_list.elements == 1 &&
 
318
  session->count_cuted_fields= ((values_list.elements == 1 &&
345
319
                             !ignore) ?
346
320
                            CHECK_FIELD_ERROR_FOR_NULL :
347
321
                            CHECK_FIELD_WARN);
348
 
  thd->cuted_fields = 0L;
 
322
  session->cuted_fields = 0L;
349
323
  table->next_number_field=table->found_next_number_field;
350
324
 
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
325
  error=0;
358
 
  thd_proc_info(thd, "update");
 
326
  session->set_proc_info("update");
359
327
  if (duplic == DUP_REPLACE)
360
328
    table->file->extra(HA_EXTRA_WRITE_CAN_REPLACE);
361
329
  if (duplic == DUP_UPDATE)
367
335
  }
368
336
 
369
337
 
370
 
  thd->abort_on_warning= !ignore;
 
338
  session->abort_on_warning= !ignore;
371
339
 
372
340
  table->mark_columns_needed_for_insert();
373
341
 
375
343
  {
376
344
    if (fields.elements || !value_count)
377
345
    {
378
 
      restore_record(table,s->default_values);  // Get empty record
379
 
      if (fill_record(thd, fields, *values, 0))
 
346
      table->restoreRecordAsDefault();  // Get empty record
 
347
      if (fill_record(session, fields, *values, 0))
380
348
      {
381
 
        if (values_list.elements != 1 && ! thd->is_error())
 
349
        if (values_list.elements != 1 && ! session->is_error())
382
350
        {
383
351
          info.records++;
384
352
          continue;
385
353
        }
386
354
        /*
387
 
          TODO: set thd->abort_on_warning if values_list.elements == 1
 
355
          TODO: set session->abort_on_warning if values_list.elements == 1
388
356
          and check that all items return warning in case of problem with
389
357
          storing field.
390
358
        */
394
362
    }
395
363
    else
396
364
    {
397
 
      if (thd->used_tables)                     // Column used in values()
398
 
        restore_record(table,s->default_values);        // Get empty record
 
365
      if (session->used_tables)                 // Column used in values()
 
366
        table->restoreRecordAsDefault();        // Get empty record
399
367
      else
400
368
      {
401
369
        /*
405
373
        */
406
374
        table->record[0][0]= table->s->default_values[0];
407
375
      }
408
 
      if (fill_record(thd, table->field, *values, 0))
 
376
      if (fill_record(session, table->field, *values, 0))
409
377
      {
410
 
        if (values_list.elements != 1 && ! thd->is_error())
 
378
        if (values_list.elements != 1 && ! session->is_error())
411
379
        {
412
380
          info.records++;
413
381
          continue;
417
385
      }
418
386
    }
419
387
 
420
 
    error=write_record(thd, table ,&info);
 
388
    // Release latches in case bulk insert takes a long time
 
389
    ha_release_temporary_latches(session);
 
390
 
 
391
    error=write_record(session, table ,&info);
421
392
    if (error)
422
393
      break;
423
 
    thd->row_count++;
 
394
    session->row_count++;
424
395
  }
425
396
 
426
 
  free_underlaid_joins(thd, &thd->lex->select_lex);
 
397
  free_underlaid_joins(session, &session->lex->select_lex);
427
398
  joins_freed= true;
428
399
 
429
400
  /*
446
417
 
447
418
    transactional_table= table->file->has_transactions();
448
419
 
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);
 
420
    changed= (info.copied || info.deleted || info.updated);
 
421
    if ((changed && error <= 0) || session->transaction.stmt.modified_non_trans_table)
 
422
    {
 
423
      if (session->transaction.stmt.modified_non_trans_table)
 
424
        session->transaction.all.modified_non_trans_table= true;
 
425
    }
 
426
    assert(transactional_table || !changed || session->transaction.stmt.modified_non_trans_table);
502
427
 
503
428
  }
504
 
  thd_proc_info(thd, "end");
 
429
  session->set_proc_info("end");
505
430
  /*
506
431
    We'll report to the client this id:
507
432
    - if the table contains an autoincrement column and we successfully
512
437
    inserted, the id of the last "inserted" row (if IGNORE, that value may not
513
438
    have been really inserted but ignored).
514
439
  */
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 :
 
440
  id= (session->first_successful_insert_id_in_cur_stmt > 0) ?
 
441
    session->first_successful_insert_id_in_cur_stmt :
 
442
    (session->arg_of_last_insert_id_function ?
 
443
     session->first_successful_insert_id_in_prev_stmt :
519
444
     ((table->next_number_field && info.copied) ?
520
445
     table->next_number_field->val_int() : 0));
521
446
  table->next_number_field=0;
522
 
  thd->count_cuted_fields= CHECK_FIELD_IGNORE;
 
447
  session->count_cuted_fields= CHECK_FIELD_IGNORE;
523
448
  table->auto_increment_field_not_null= false;
524
449
  if (duplic == DUP_REPLACE)
525
450
    table->file->extra(HA_EXTRA_WRITE_CANNOT_REPLACE);
526
451
 
527
452
  if (error)
528
453
    goto abort;
529
 
  if (values_list.elements == 1 && (!(thd->options & OPTION_WARNINGS) ||
530
 
                                    !thd->cuted_fields))
 
454
  if (values_list.elements == 1 && (!(session->options & OPTION_WARNINGS) ||
 
455
                                    !session->cuted_fields))
531
456
  {
532
 
    thd->row_count_func= info.copied + info.deleted +
533
 
                         ((thd->client_capabilities & CLIENT_FOUND_ROWS) ?
 
457
    session->row_count_func= info.copied + info.deleted +
 
458
                         ((session->client_capabilities & CLIENT_FOUND_ROWS) ?
534
459
                          info.touched : info.updated);
535
 
    my_ok(thd, (ulong) thd->row_count_func, id);
 
460
    session->my_ok((ulong) session->row_count_func, id);
536
461
  }
537
462
  else
538
463
  {
539
464
    char buff[160];
540
 
    ha_rows updated=((thd->client_capabilities & CLIENT_FOUND_ROWS) ?
 
465
    ha_rows updated=((session->client_capabilities & CLIENT_FOUND_ROWS) ?
541
466
                     info.touched : info.updated);
542
467
    if (ignore)
543
468
      sprintf(buff, ER(ER_INSERT_INFO), (ulong) info.records,
544
 
              (ulong) (info.records - info.copied), (ulong) thd->cuted_fields);
 
469
              (ulong) (info.records - info.copied), (ulong) session->cuted_fields);
545
470
    else
546
471
      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);
 
472
              (ulong) (info.deleted + updated), (ulong) session->cuted_fields);
 
473
    session->row_count_func= info.copied + info.deleted + updated;
 
474
    session->my_ok((ulong) session->row_count_func, id, buff);
550
475
  }
551
 
  thd->abort_on_warning= 0;
 
476
  session->abort_on_warning= 0;
552
477
  DRIZZLE_INSERT_END();
553
478
  return(false);
554
479
 
556
481
  if (table != NULL)
557
482
    table->file->ha_release_auto_increment();
558
483
  if (!joins_freed)
559
 
    free_underlaid_joins(thd, &thd->lex->select_lex);
560
 
  thd->abort_on_warning= 0;
 
484
    free_underlaid_joins(session, &session->lex->select_lex);
 
485
  session->abort_on_warning= 0;
561
486
  DRIZZLE_INSERT_END();
562
487
  return(true);
563
488
}
568
493
 
569
494
  SYNOPSIS
570
495
     mysql_prepare_insert_check_table()
571
 
     thd                Thread handle
 
496
     session            Thread handle
572
497
     table_list         Table list
573
498
     fields             List of fields to be updated
574
499
     where              Pointer to where clause
579
504
     true  ERROR
580
505
*/
581
506
 
582
 
static bool mysql_prepare_insert_check_table(THD *thd, TableList *table_list,
583
 
                                             List<Item> &fields __attribute__((unused)),
 
507
static bool mysql_prepare_insert_check_table(Session *session, TableList *table_list,
 
508
                                             List<Item> &,
584
509
                                             bool select_insert)
585
510
{
586
 
  
 
511
 
587
512
 
588
513
  /*
589
514
     first table in list is the one we'll INSERT into, requires INSERT_ACL.
592
517
     than INSERT.
593
518
  */
594
519
 
595
 
  if (setup_tables_and_check_access(thd, &thd->lex->select_lex.context,
596
 
                                    &thd->lex->select_lex.top_join_list,
 
520
  if (setup_tables_and_check_access(session, &session->lex->select_lex.context,
 
521
                                    &session->lex->select_lex.top_join_list,
597
522
                                    table_list,
598
 
                                    &thd->lex->select_lex.leaf_tables,
 
523
                                    &session->lex->select_lex.leaf_tables,
599
524
                                    select_insert))
600
525
    return(true);
601
526
 
608
533
 
609
534
  SYNOPSIS
610
535
    mysql_prepare_insert()
611
 
    thd                 Thread handler
 
536
    session                     Thread handler
612
537
    table_list          Global/local table list
613
538
    table               Table to insert into (can be NULL if table should
614
 
                        be taken from table_list->table)    
 
539
                        be taken from table_list->table)
615
540
    where               Where clause (for insert ... select)
616
541
    select_insert       true if INSERT ... SELECT statement
617
 
    check_fields        true if need to check that all INSERT fields are 
 
542
    check_fields        true if need to check that all INSERT fields are
618
543
                        given values.
619
 
    abort_on_warning    whether to report if some INSERT field is not 
 
544
    abort_on_warning    whether to report if some INSERT field is not
620
545
                        assigned as an error (true) or as a warning (false).
621
546
 
622
547
  TODO (in far future)
628
553
  WARNING
629
554
    You MUST set table->insert_values to 0 after calling this function
630
555
    before releasing the table object.
631
 
  
 
556
 
632
557
  RETURN VALUE
633
558
    false OK
634
559
    true  error
635
560
*/
636
561
 
637
 
bool mysql_prepare_insert(THD *thd, TableList *table_list,
 
562
bool mysql_prepare_insert(Session *session, TableList *table_list,
638
563
                          Table *table, List<Item> &fields, List_item *values,
639
564
                          List<Item> &update_fields, List<Item> &update_values,
640
565
                          enum_duplicates duplic,
641
 
                          COND **where __attribute__((unused)),
 
566
                          COND **,
642
567
                          bool select_insert,
643
568
                          bool check_fields, bool abort_on_warning)
644
569
{
645
 
  SELECT_LEX *select_lex= &thd->lex->select_lex;
 
570
  Select_Lex *select_lex= &session->lex->select_lex;
646
571
  Name_resolution_context *context= &select_lex->context;
647
572
  Name_resolution_context_state ctx_state;
648
573
  bool insert_into_view= (0 != 0);
649
574
  bool res= 0;
650
575
  table_map map= 0;
651
 
  
 
576
 
652
577
  /* INSERT should have a SELECT or VALUES clause */
653
578
  assert (!select_insert || !values);
654
579
 
655
580
  /*
656
581
    For subqueries in VALUES() we should not see the table in which we are
657
582
    inserting (for INSERT ... SELECT this is done by changing table_list,
658
 
    because INSERT ... SELECT share SELECT_LEX it with SELECT.
 
583
    because INSERT ... SELECT share Select_Lex it with SELECT.
659
584
  */
660
585
  if (!select_insert)
661
586
  {
662
 
    for (SELECT_LEX_UNIT *un= select_lex->first_inner_unit();
 
587
    for (Select_Lex_Unit *un= select_lex->first_inner_unit();
663
588
         un;
664
589
         un= un->next_unit())
665
590
    {
666
 
      for (SELECT_LEX *sl= un->first_select();
 
591
      for (Select_Lex *sl= un->first_select();
667
592
           sl;
668
593
           sl= sl->next_select())
669
594
      {
675
600
  if (duplic == DUP_UPDATE)
676
601
  {
677
602
    /* it should be allocated before Item::fix_fields() */
678
 
    if (table_list->set_insert_values(thd->mem_root))
 
603
    if (table_list->set_insert_values(session->mem_root))
679
604
      return(true);
680
605
  }
681
606
 
682
 
  if (mysql_prepare_insert_check_table(thd, table_list, fields, select_insert))
 
607
  if (mysql_prepare_insert_check_table(session, table_list, fields, select_insert))
683
608
    return(true);
684
609
 
685
610
 
699
624
    table_list->next_local= 0;
700
625
    context->resolve_in_table_list_only(table_list);
701
626
 
702
 
    res= check_insert_fields(thd, context->table_list, fields, *values,
 
627
    res= check_insert_fields(session, context->table_list, fields, *values,
703
628
                             !insert_into_view, &map) ||
704
 
      setup_fields(thd, 0, *values, MARK_COLUMNS_READ, 0, 0);
 
629
      setup_fields(session, 0, *values, MARK_COLUMNS_READ, 0, 0);
705
630
 
706
631
    if (!res && check_fields)
707
632
    {
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 : 
 
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 :
712
637
                                                  context->table_list->table,
713
638
                                                  context->table_list);
714
 
      thd->abort_on_warning= saved_abort_on_warning;
 
639
      session->abort_on_warning= saved_abort_on_warning;
715
640
    }
716
641
 
717
642
    if (!res && duplic == DUP_UPDATE)
718
643
    {
719
 
      res= check_update_fields(thd, context->table_list, update_fields, &map);
 
644
      res= check_update_fields(session, context->table_list, update_fields, &map);
720
645
    }
721
646
 
722
647
    /* Restore the current context. */
723
648
    ctx_state.restore_state(context, table_list);
724
649
 
725
650
    if (!res)
726
 
      res= setup_fields(thd, 0, update_values, MARK_COLUMNS_READ, 0, 0);
 
651
      res= setup_fields(session, 0, update_values, MARK_COLUMNS_READ, 0, 0);
727
652
  }
728
653
 
729
654
  if (res)
735
660
  if (!select_insert)
736
661
  {
737
662
    TableList *duplicate;
738
 
    if ((duplicate= unique_table(thd, table_list, table_list->next_global, 1)))
 
663
    if ((duplicate= unique_table(session, table_list, table_list->next_global, 1)))
739
664
    {
740
665
      update_non_unique_table_error(table_list, "INSERT", duplicate);
741
666
      return(true);
764
689
 
765
690
  SYNOPSIS
766
691
     write_record()
767
 
      thd   - thread context
 
692
      session   - thread context
768
693
      table - table to which record should be written
769
694
      info  - COPY_INFO structure describing handling of duplicates
770
695
              and which is used for counting number of records inserted
776
701
    then both on update triggers will work instead. Similarly both on
777
702
    delete triggers will be invoked if we will delete conflicting records.
778
703
 
779
 
    Sets thd->transaction.stmt.modified_non_trans_table to true if table which is updated didn't have
 
704
    Sets session->transaction.stmt.modified_non_trans_table to true if table which is updated didn't have
780
705
    transactions.
781
706
 
782
707
  RETURN VALUE
785
710
*/
786
711
 
787
712
 
788
 
int write_record(THD *thd, Table *table,COPY_INFO *info)
 
713
int write_record(Session *session, Table *table,COPY_INFO *info)
789
714
{
790
715
  int error;
791
716
  char *key=0;
792
717
  MY_BITMAP *save_read_set, *save_write_set;
793
718
  uint64_t prev_insert_id= table->file->next_insert_id;
794
719
  uint64_t insert_id_for_cur_row= 0;
795
 
  
 
720
 
796
721
 
797
722
  info->records++;
798
723
  save_read_set=  table->read_set;
799
724
  save_write_set= table->write_set;
800
725
 
801
 
  if (info->handle_duplicates == DUP_REPLACE ||
802
 
      info->handle_duplicates == DUP_UPDATE)
 
726
  if (info->handle_duplicates == DUP_REPLACE || info->handle_duplicates == DUP_UPDATE)
803
727
  {
804
728
    while ((error=table->file->ha_write_row(table->record[0])))
805
729
    {
808
732
        If we do more than one iteration of this loop, from the second one the
809
733
        row will have an explicit value in the autoinc field, which was set at
810
734
        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
 
735
        the autogenerated value to avoid session->insert_id_for_cur_row to become
812
736
        0.
813
737
      */
814
738
      if (table->file->insert_id_for_cur_row > 0)
862
786
 
863
787
        if (!key)
864
788
        {
865
 
          if (!(key=(char*) my_safe_alloca(table->s->max_unique_length,
866
 
                                           MAX_KEY_LENGTH)))
 
789
          if (!(key=(char*) malloc(table->s->max_unique_length)))
867
790
          {
868
791
            error=ENOMEM;
869
792
            goto err;
883
806
          an error is returned
884
807
        */
885
808
        assert(table->insert_values != NULL);
886
 
        store_record(table,insert_values);
887
 
        restore_record(table,record[1]);
 
809
        table->storeRecordAsInsert();
 
810
        table->restoreRecord();
888
811
        assert(info->update_fields->elements ==
889
812
                    info->update_values->elements);
890
 
        if (fill_record(thd, *info->update_fields,
 
813
        if (fill_record(session, *info->update_fields,
891
814
                                                 *info->update_values,
892
815
                                                 info->ignore))
893
816
          goto before_err;
922
845
            like a regular UPDATE statement: it should not affect the value of a
923
846
            next SELECT LAST_INSERT_ID() or mysql_insert_id().
924
847
            Except if LAST_INSERT_ID(#) was in the INSERT query, which is
925
 
            handled separately by THD::arg_of_last_insert_id_function.
 
848
            handled separately by Session::arg_of_last_insert_id_function.
926
849
          */
927
850
          insert_id_for_cur_row= table->file->insert_id_for_cur_row= 0;
928
851
          info->copied++;
942
865
          an INSERT or DELETE(s) + INSERT; FOREIGN KEY checks in
943
866
          InnoDB do not function in the defined way if we allow MySQL
944
867
          to convert the latter operation internally to an UPDATE.
945
 
          We also should not perform this conversion if we have 
 
868
          We also should not perform this conversion if we have
946
869
          timestamp field with ON UPDATE which is different from DEFAULT.
947
870
          Another case when conversion should not be performed is when
948
871
          we have ON DELETE trigger on table so user may notice that
964
887
            info->deleted++;
965
888
          else
966
889
            error= 0;
967
 
          thd->record_first_successful_insert_id_in_cur_stmt(table->file->insert_id_for_cur_row);
 
890
          session->record_first_successful_insert_id_in_cur_stmt(table->file->insert_id_for_cur_row);
968
891
          /*
969
892
            Since we pretend that we have done insert we should call
970
893
            its after triggers.
977
900
            goto err;
978
901
          info->deleted++;
979
902
          if (!table->file->has_transactions())
980
 
            thd->transaction.stmt.modified_non_trans_table= true;
 
903
            session->transaction.stmt.modified_non_trans_table= true;
981
904
          /* Let us attempt do write_row() once more */
982
905
        }
983
906
      }
984
907
    }
985
 
    thd->record_first_successful_insert_id_in_cur_stmt(table->file->insert_id_for_cur_row);
 
908
    session->record_first_successful_insert_id_in_cur_stmt(table->file->insert_id_for_cur_row);
986
909
    /*
987
910
      Restore column maps if they where replaced during an duplicate key
988
911
      problem.
1002
925
 
1003
926
after_n_copied_inc:
1004
927
  info->copied++;
1005
 
  thd->record_first_successful_insert_id_in_cur_stmt(table->file->insert_id_for_cur_row);
 
928
  session->record_first_successful_insert_id_in_cur_stmt(table->file->insert_id_for_cur_row);
1006
929
 
1007
930
gok_or_after_err:
1008
931
  if (key)
1009
 
    my_safe_afree(key,table->s->max_unique_length,MAX_KEY_LENGTH);
 
932
    free(key);
1010
933
  if (!table->file->has_transactions())
1011
 
    thd->transaction.stmt.modified_non_trans_table= true;
 
934
    session->transaction.stmt.modified_non_trans_table= true;
1012
935
  return(0);
1013
936
 
1014
937
err:
1015
938
  info->last_errno= error;
1016
939
  /* 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
 
940
  if (session->lex->current_select)
 
941
    session->lex->current_select->no_error= 0;        // Give error
1019
942
  table->file->print_error(error,MYF(0));
1020
 
  
 
943
 
1021
944
before_err:
1022
945
  table->file->restore_auto_increment(prev_insert_id);
1023
946
  if (key)
1024
 
    my_safe_afree(key, table->s->max_unique_length, MAX_KEY_LENGTH);
 
947
    free(key);
1025
948
  table->column_bitmaps_set(save_read_set, save_write_set);
1026
949
  return(1);
1027
950
}
1031
954
  Check that all fields with arn't null_fields are used
1032
955
******************************************************************************/
1033
956
 
1034
 
int check_that_all_fields_are_given_values(THD *thd, Table *entry,
1035
 
                                           TableList *table_list)
 
957
int check_that_all_fields_are_given_values(Session *session, Table *entry,
 
958
                                           TableList *)
1036
959
{
1037
960
  int err= 0;
1038
 
  MY_BITMAP *write_set= entry->write_set;
1039
961
 
1040
962
  for (Field **field=entry->field ; *field ; field++)
1041
963
  {
1042
 
    if (!bitmap_is_set(write_set, (*field)->field_index) &&
1043
 
        ((*field)->flags & NO_DEFAULT_VALUE_FLAG) &&
 
964
    if (((*field)->isWriteSet()) == false)
 
965
    {
 
966
      /*
 
967
       * If the field doesn't have any default value
 
968
       * and there is no actual value specified in the
 
969
       * INSERT statement, throw error ER_NO_DEFAULT_FOR_FIELD.
 
970
       */
 
971
      if (((*field)->flags & NO_DEFAULT_VALUE_FLAG) &&
1044
972
        ((*field)->real_type() != DRIZZLE_TYPE_ENUM))
 
973
      {
 
974
        my_error(ER_NO_DEFAULT_FOR_FIELD, MYF(0), (*field)->field_name);
 
975
        err= 1;
 
976
      }
 
977
    }
 
978
    else
1045
979
    {
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;
 
980
      /*
 
981
       * However, if an actual NULL value was specified
 
982
       * for the field and the field is a NOT NULL field, 
 
983
       * throw ER_BAD_NULL_ERROR.
 
984
       *
 
985
       * Per the SQL standard, inserting NULL into a NOT NULL
 
986
       * field requires an error to be thrown.
 
987
       */
 
988
      if (((*field)->flags & NOT_NULL_FLAG) &&
 
989
          (*field)->is_null())
 
990
      {
 
991
        my_error(ER_BAD_NULL_ERROR, MYF(0), (*field)->field_name);
 
992
        err= 1;
 
993
      }
1059
994
    }
1060
995
  }
1061
 
  return thd->abort_on_warning ? err : 0;
 
996
  return session->abort_on_warning ? err : 0;
1062
997
}
1063
998
 
1064
999
/***************************************************************************
1071
1006
 
1072
1007
  SYNOPSIS
1073
1008
    mysql_insert_select_prepare()
1074
 
    thd         thread handler
 
1009
    session         thread handler
1075
1010
 
1076
1011
  RETURN
1077
1012
    false OK
1078
1013
    true  Error
1079
1014
*/
1080
1015
 
1081
 
bool mysql_insert_select_prepare(THD *thd)
 
1016
bool mysql_insert_select_prepare(Session *session)
1082
1017
{
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
 
1018
  LEX *lex= session->lex;
 
1019
  Select_Lex *select_lex= &lex->select_lex;
 
1020
 
 
1021
  /*
 
1022
    Select_Lex do not belong to INSERT statement, so we can't add WHERE
1102
1023
    clause if table is VIEW
1103
1024
  */
1104
 
  
1105
 
  if (mysql_prepare_insert(thd, lex->query_tables,
 
1025
 
 
1026
  if (mysql_prepare_insert(session, lex->query_tables,
1106
1027
                           lex->query_tables->table, lex->field_list, 0,
1107
1028
                           lex->update_list, lex->value_list,
1108
1029
                           lex->duplicates,
1140
1061
 
1141
1062
 
1142
1063
int
1143
 
select_insert::prepare(List<Item> &values, SELECT_LEX_UNIT *u)
 
1064
select_insert::prepare(List<Item> &values, Select_Lex_Unit *u)
1144
1065
{
1145
 
  LEX *lex= thd->lex;
 
1066
  LEX *lex= session->lex;
1146
1067
  int res;
1147
1068
  table_map map= 0;
1148
 
  SELECT_LEX *lex_current_select_save= lex->current_select;
1149
 
  
 
1069
  Select_Lex *lex_current_select_save= lex->current_select;
 
1070
 
1150
1071
 
1151
1072
  unit= u;
1152
1073
 
1156
1077
    we are fixing fields from insert list.
1157
1078
  */
1158
1079
  lex->current_select= &lex->select_lex;
1159
 
  res= check_insert_fields(thd, table_list, *fields, values,
 
1080
  res= check_insert_fields(session, table_list, *fields, values,
1160
1081
                           !insert_into_view, &map) ||
1161
 
       setup_fields(thd, 0, values, MARK_COLUMNS_READ, 0, 0);
 
1082
       setup_fields(session, 0, values, MARK_COLUMNS_READ, 0, 0);
1162
1083
 
1163
1084
  if (!res && fields->elements)
1164
1085
  {
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, 
 
1086
    bool saved_abort_on_warning= session->abort_on_warning;
 
1087
    session->abort_on_warning= !info.ignore;
 
1088
    res= check_that_all_fields_are_given_values(session, table_list->table,
1168
1089
                                                table_list);
1169
 
    thd->abort_on_warning= saved_abort_on_warning;
 
1090
    session->abort_on_warning= saved_abort_on_warning;
1170
1091
  }
1171
1092
 
1172
1093
  if (info.handle_duplicates == DUP_UPDATE && !res)
1181
1102
    table_list->next_local= 0;
1182
1103
    context->resolve_in_table_list_only(table_list);
1183
1104
 
1184
 
    res= res || check_update_fields(thd, context->table_list,
 
1105
    res= res || check_update_fields(session, context->table_list,
1185
1106
                                    *info.update_fields, &map);
1186
1107
    /*
1187
 
      When we are not using GROUP BY and there are no ungrouped aggregate functions 
 
1108
      When we are not using GROUP BY and there are no ungrouped aggregate functions
1188
1109
      we can refer to other tables in the ON DUPLICATE KEY part.
1189
1110
      We use next_name_resolution_table descructively, so check it first (views?)
1190
1111
    */
1195
1116
        We must make a single context out of the two separate name resolution contexts :
1196
1117
        the INSERT table and the tables in the SELECT part of INSERT ... SELECT.
1197
1118
        To do that we must concatenate the two lists
1198
 
      */  
1199
 
      table_list->next_name_resolution_table= 
 
1119
      */
 
1120
      table_list->next_name_resolution_table=
1200
1121
        ctx_state.get_first_name_resolution_table();
1201
1122
 
1202
 
    res= res || setup_fields(thd, 0, *info.update_values,
 
1123
    res= res || setup_fields(session, 0, *info.update_values,
1203
1124
                             MARK_COLUMNS_READ, 0, 0);
1204
1125
    if (!res)
1205
1126
    {
1236
1157
    Is table which we are changing used somewhere in other parts of
1237
1158
    query
1238
1159
  */
1239
 
  if (unique_table(thd, table_list, table_list->next_global, 0))
 
1160
  if (unique_table(session, table_list, table_list->next_global, 0))
1240
1161
  {
1241
1162
    /* Using same table for INSERT and SELECT */
1242
1163
    lex->current_select->options|= OPTION_BUFFER_RESULT;
1245
1166
  else if (!(lex->current_select->options & OPTION_BUFFER_RESULT))
1246
1167
  {
1247
1168
    /*
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 
 
1169
      We must not yet prepare the result table if it is the same as one of the
 
1170
      source tables (INSERT SELECT). The preparation may disable
1250
1171
      indexes on the result table, which may be used during the select, if it
1251
1172
      is the same table (Bug #6034). Do the preparation after the select phase
1252
1173
      in select_insert::prepare2().
1255
1176
    */
1256
1177
    table->file->ha_start_bulk_insert((ha_rows) 0);
1257
1178
  }
1258
 
  restore_record(table,s->default_values);              // Get empty record
 
1179
  table->restoreRecordAsDefault();              // Get empty record
1259
1180
  table->next_number_field=table->found_next_number_field;
1260
1181
 
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;
 
1182
  session->cuted_fields=0;
1268
1183
  if (info.ignore || info.handle_duplicates != DUP_ERROR)
1269
1184
    table->file->extra(HA_EXTRA_IGNORE_DUP_KEY);
1270
1185
  if (info.handle_duplicates == DUP_REPLACE)
1271
1186
    table->file->extra(HA_EXTRA_WRITE_CAN_REPLACE);
1272
1187
  if (info.handle_duplicates == DUP_UPDATE)
1273
1188
    table->file->extra(HA_EXTRA_INSERT_WITH_UPDATE);
1274
 
  thd->abort_on_warning= !info.ignore;
 
1189
  session->abort_on_warning= !info.ignore;
1275
1190
  table->mark_columns_needed_for_insert();
1276
1191
 
1277
1192
 
1290
1205
    If the result table is the same as one of the source tables (INSERT SELECT),
1291
1206
    the result table is not finally prepared at the join prepair phase.
1292
1207
    Do the final preparation now.
1293
 
                       
 
1208
 
1294
1209
  RETURN
1295
1210
    0   OK
1296
1211
*/
1297
1212
 
1298
1213
int select_insert::prepare2(void)
1299
1214
{
1300
 
  
1301
 
  if (thd->lex->current_select->options & OPTION_BUFFER_RESULT)
 
1215
 
 
1216
  if (session->lex->current_select->options & OPTION_BUFFER_RESULT)
1302
1217
    table->file->ha_start_bulk_insert((ha_rows) 0);
1303
1218
  return(0);
1304
1219
}
1312
1227
 
1313
1228
select_insert::~select_insert()
1314
1229
{
1315
 
  
 
1230
 
1316
1231
  if (table)
1317
1232
  {
1318
1233
    table->next_number_field=0;
1319
1234
    table->auto_increment_field_not_null= false;
1320
1235
    table->file->ha_reset();
1321
1236
  }
1322
 
  thd->count_cuted_fields= CHECK_FIELD_IGNORE;
1323
 
  thd->abort_on_warning= 0;
 
1237
  session->count_cuted_fields= CHECK_FIELD_IGNORE;
 
1238
  session->abort_on_warning= 0;
1324
1239
  return;
1325
1240
}
1326
1241
 
1327
1242
 
1328
1243
bool select_insert::send_data(List<Item> &values)
1329
1244
{
1330
 
  
 
1245
 
1331
1246
  bool error=0;
1332
1247
 
1333
1248
  if (unit->offset_limit_cnt)
1336
1251
    return(0);
1337
1252
  }
1338
1253
 
1339
 
  thd->count_cuted_fields= CHECK_FIELD_WARN;    // Calculate cuted fields
 
1254
  session->count_cuted_fields= CHECK_FIELD_WARN;        // Calculate cuted fields
1340
1255
  store_values(values);
1341
 
  thd->count_cuted_fields= CHECK_FIELD_IGNORE;
1342
 
  if (thd->is_error())
 
1256
  session->count_cuted_fields= CHECK_FIELD_IGNORE;
 
1257
  if (session->is_error())
1343
1258
    return(1);
1344
1259
 
1345
 
  error= write_record(thd, table, &info);
1346
 
    
 
1260
  // Release latches in case bulk insert takes a long time
 
1261
  ha_release_temporary_latches(session);
 
1262
 
 
1263
  error= write_record(session, table, &info);
 
1264
 
1347
1265
  if (!error)
1348
1266
  {
1349
1267
    if (info.handle_duplicates == DUP_UPDATE)
1351
1269
      /*
1352
1270
        Restore fields of the record since it is possible that they were
1353
1271
        changed by ON DUPLICATE KEY UPDATE clause.
1354
 
    
 
1272
 
1355
1273
        If triggers exist then whey can modify some fields which were not
1356
1274
        originally touched by INSERT ... SELECT, so we have to restore
1357
1275
        their original values for the next row.
1358
1276
      */
1359
 
      restore_record(table, s->default_values);
 
1277
      table->restoreRecordAsDefault();
1360
1278
    }
1361
1279
    if (table->next_number_field)
1362
1280
    {
1364
1282
        If no value has been autogenerated so far, we need to remember the
1365
1283
        value we just saw, we may need to send it to client in the end.
1366
1284
      */
1367
 
      if (thd->first_successful_insert_id_in_cur_stmt == 0) // optimization
1368
 
        autoinc_value_of_last_inserted_row= 
 
1285
      if (session->first_successful_insert_id_in_cur_stmt == 0) // optimization
 
1286
        autoinc_value_of_last_inserted_row=
1369
1287
          table->next_number_field->val_int();
1370
1288
      /*
1371
1289
        Clear auto-increment field for the next record, if triggers are used
1381
1299
void select_insert::store_values(List<Item> &values)
1382
1300
{
1383
1301
  if (fields->elements)
1384
 
    fill_record(thd, *fields, values, 1);
 
1302
    fill_record(session, *fields, values, 1);
1385
1303
  else
1386
 
    fill_record(thd, table->field, values, 1);
 
1304
    fill_record(session, table->field, values, 1);
1387
1305
}
1388
1306
 
1389
1307
void select_insert::send_error(uint32_t errcode,const char *err)
1390
1308
{
1391
 
  
 
1309
 
1392
1310
 
1393
1311
  my_message(errcode, err, MYF(0));
1394
1312
 
1402
1320
  bool const trans_table= table->file->has_transactions();
1403
1321
  uint64_t id;
1404
1322
  bool changed;
1405
 
  THD::killed_state killed_status= thd->killed;
1406
 
  
 
1323
 
1407
1324
  error= table->file->ha_end_bulk_insert();
1408
1325
  table->file->extra(HA_EXTRA_NO_IGNORE_DUP_KEY);
1409
1326
  table->file->extra(HA_EXTRA_WRITE_CANNOT_REPLACE);
1414
1331
      We must invalidate the table in the query cache before binlog writing
1415
1332
      and ha_autocommit_or_rollback.
1416
1333
    */
1417
 
    if (thd->transaction.stmt.modified_non_trans_table)
1418
 
      thd->transaction.all.modified_non_trans_table= true;
 
1334
    if (session->transaction.stmt.modified_non_trans_table)
 
1335
      session->transaction.all.modified_non_trans_table= true;
1419
1336
  }
1420
 
  assert(trans_table || !changed || 
1421
 
              thd->transaction.stmt.modified_non_trans_table);
 
1337
  assert(trans_table || !changed ||
 
1338
              session->transaction.stmt.modified_non_trans_table);
1422
1339
 
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
1340
  table->file->ha_release_auto_increment();
1438
1341
 
1439
1342
  if (error)
1444
1347
  char buff[160];
1445
1348
  if (info.ignore)
1446
1349
    sprintf(buff, ER(ER_INSERT_INFO), (ulong) info.records,
1447
 
            (ulong) (info.records - info.copied), (ulong) thd->cuted_fields);
 
1350
            (ulong) (info.records - info.copied), (ulong) session->cuted_fields);
1448
1351
  else
1449
1352
    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) ?
 
1353
            (ulong) (info.deleted+info.updated), (ulong) session->cuted_fields);
 
1354
  session->row_count_func= info.copied + info.deleted +
 
1355
                       ((session->client_capabilities & CLIENT_FOUND_ROWS) ?
1453
1356
                        info.touched : info.updated);
1454
1357
 
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 :
 
1358
  id= (session->first_successful_insert_id_in_cur_stmt > 0) ?
 
1359
    session->first_successful_insert_id_in_cur_stmt :
 
1360
    (session->arg_of_last_insert_id_function ?
 
1361
     session->first_successful_insert_id_in_prev_stmt :
1459
1362
     (info.copied ? autoinc_value_of_last_inserted_row : 0));
1460
 
  ::my_ok(thd, (ulong) thd->row_count_func, id, buff);
 
1363
  session->my_ok((ulong) session->row_count_func, id, buff);
1461
1364
  return(0);
1462
1365
}
1463
1366
 
1464
1367
void select_insert::abort() {
1465
1368
 
1466
 
  
 
1369
 
1467
1370
  /*
1468
1371
    If the creation of the table failed (due to a syntax error, for
1469
1372
    example), no table will have been opened and therefore 'table'
1492
1395
    */
1493
1396
    changed= (info.copied || info.deleted || info.updated);
1494
1397
    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
1398
    assert(transactional_table || !changed ||
1504
 
                thd->transaction.stmt.modified_non_trans_table);
 
1399
                session->transaction.stmt.modified_non_trans_table);
1505
1400
    table->file->ha_release_auto_increment();
1506
1401
  }
1507
1402
 
1519
1414
 
1520
1415
  SYNOPSIS
1521
1416
    create_table_from_items()
1522
 
      thd          in     Thread object
 
1417
      session          in     Thread object
1523
1418
      create_info  in     Create information (like MAX_ROWS, ENGINE or
1524
1419
                          temporary table flag)
1525
1420
      create_table in     Pointer to TableList object providing database
1532
1427
      lock         out    Pointer to the DRIZZLE_LOCK object for table created
1533
1428
                          (or open temporary table) will be returned in this
1534
1429
                          parameter. Since this table is not included in
1535
 
                          THD::lock caller is responsible for explicitly
 
1430
                          Session::lock caller is responsible for explicitly
1536
1431
                          unlocking this table.
1537
1432
      hooks
1538
1433
 
1555
1450
    0         Error
1556
1451
*/
1557
1452
 
1558
 
static Table *create_table_from_items(THD *thd, HA_CREATE_INFO *create_info,
 
1453
static Table *create_table_from_items(Session *session, HA_CREATE_INFO *create_info,
1559
1454
                                      TableList *create_table,
1560
1455
                                      Alter_info *alter_info,
1561
1456
                                      List<Item> *items,
1562
 
                                      DRIZZLE_LOCK **lock,
1563
 
                                      TABLEOP_HOOKS *hooks)
 
1457
                                      DRIZZLE_LOCK **lock)
1564
1458
{
1565
1459
  Table tmp_table;              // Used during 'Create_field()'
1566
 
  TABLE_SHARE share;
 
1460
  TableShare share;
1567
1461
  Table *table= 0;
1568
1462
  uint32_t select_field_count= items->elements;
1569
1463
  /* Add selected items to field list */
1579
1473
    if (create_info->options & HA_LEX_CREATE_IF_NOT_EXISTS)
1580
1474
    {
1581
1475
      create_info->table_existed= 1;            // Mark that table existed
1582
 
      push_warning_printf(thd, DRIZZLE_ERROR::WARN_LEVEL_NOTE,
 
1476
      push_warning_printf(session, DRIZZLE_ERROR::WARN_LEVEL_NOTE,
1583
1477
                          ER_TABLE_EXISTS_ERROR, ER(ER_TABLE_EXISTS_ERROR),
1584
1478
                          create_table->table_name);
1585
1479
      return(create_table->table);
1592
1486
  tmp_table.alias= 0;
1593
1487
  tmp_table.timestamp_field= 0;
1594
1488
  tmp_table.s= &share;
1595
 
  init_tmp_table_share(thd, &share, "", 0, "", "");
1596
1489
 
1597
1490
  tmp_table.s->db_create_options=0;
1598
1491
  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);
 
1492
  tmp_table.s->db_low_byte_first=
 
1493
        test(create_info->db_type == myisam_engine ||
 
1494
             create_info->db_type == heap_engine);
1602
1495
  tmp_table.null_row= false;
1603
1496
  tmp_table.maybe_null= false;
1604
1497
 
1612
1505
      else
1613
1506
        field= item->tmp_table_field_from_field_type(&tmp_table, 0);
1614
1507
    else
1615
 
      field= create_tmp_field(thd, &tmp_table, item, item->type(),
 
1508
      field= create_tmp_field(session, &tmp_table, item, item->type(),
1616
1509
                              (Item ***) 0, &tmp_field, &def_field, 0, 0, 0, 0,
1617
1510
                              0);
1618
1511
    if (!field ||
1642
1535
    open_table().
1643
1536
  */
1644
1537
  {
1645
 
    tmp_disable_binlog(thd);
1646
 
    if (!mysql_create_table_no_lock(thd, create_table->db,
 
1538
    if (!mysql_create_table_no_lock(session, create_table->db,
1647
1539
                                    create_table->table_name,
1648
1540
                                    create_info, alter_info, 0,
1649
 
                                    select_field_count))
 
1541
                                    select_field_count, true))
1650
1542
    {
1651
1543
      if (create_info->table_existed &&
1652
1544
          !(create_info->options & HA_LEX_CREATE_TMP_TABLE))
1663
1555
      if (!(create_info->options & HA_LEX_CREATE_TMP_TABLE))
1664
1556
      {
1665
1557
        pthread_mutex_lock(&LOCK_open);
1666
 
        if (reopen_name_locked_table(thd, create_table, false))
 
1558
        if (reopen_name_locked_table(session, create_table, false))
1667
1559
        {
1668
1560
          quick_rm_table(create_info->db_type, create_table->db,
1669
1561
                         table_case_name(create_info, create_table->table_name),
1675
1567
      }
1676
1568
      else
1677
1569
      {
1678
 
        if (!(table= open_table(thd, create_table, (bool*) 0,
 
1570
        if (!(table= open_table(session, create_table, (bool*) 0,
1679
1571
                                DRIZZLE_OPEN_TEMPORARY_ONLY)) &&
1680
1572
            !create_info->table_existed)
1681
1573
        {
1684
1576
            it preparable for open. But let us do close_temporary_table() here
1685
1577
            just in case.
1686
1578
          */
1687
 
          drop_temporary_table(thd, create_table);
 
1579
          drop_temporary_table(session, create_table);
1688
1580
        }
1689
1581
      }
1690
1582
    }
1691
 
    reenable_binlog(thd);
1692
1583
    if (!table)                                   // open failed
1693
1584
      return(0);
1694
1585
  }
1695
1586
 
1696
1587
  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))
 
1588
  if (! ((*lock)= mysql_lock_tables(session, &table, 1,
 
1589
                                    DRIZZLE_LOCK_IGNORE_FLUSH, &not_used)))
1701
1590
  {
1702
1591
    if (*lock)
1703
1592
    {
1704
 
      mysql_unlock_tables(thd, *lock);
 
1593
      mysql_unlock_tables(session, *lock);
1705
1594
      *lock= 0;
1706
1595
    }
1707
1596
 
1708
1597
    if (!create_info->table_existed)
1709
 
      drop_open_table(thd, table, create_table->db, create_table->table_name);
 
1598
      drop_open_table(session, table, create_table->db, create_table->table_name);
1710
1599
    return(0);
1711
1600
  }
1712
1601
  return(table);
1714
1603
 
1715
1604
 
1716
1605
int
1717
 
select_create::prepare(List<Item> &values, SELECT_LEX_UNIT *u)
 
1606
select_create::prepare(List<Item> &values, Select_Lex_Unit *u)
1718
1607
{
1719
1608
  DRIZZLE_LOCK *extra_lock= NULL;
1720
 
  
1721
 
 
1722
 
  TABLEOP_HOOKS *hook_ptr= NULL;
1723
1609
  /*
1724
1610
    For row-based replication, the CREATE-SELECT statement is written
1725
1611
    in two pieces: the first one contain the CREATE TABLE statement
1738
1624
    slave.  Hence, we have to hold on to the CREATE part of the
1739
1625
    statement until the statement has finished.
1740
1626
   */
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
1627
 
1774
1628
  unit= u;
1775
1629
 
1778
1632
    row-based replication for the statement.  If we are creating a
1779
1633
    temporary table, we need to start a statement transaction.
1780
1634
  */
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
1635
 
1787
 
  if (!(table= create_table_from_items(thd, create_info, create_table,
 
1636
  if (!(table= create_table_from_items(session, create_info, create_table,
1788
1637
                                       alter_info, &values,
1789
 
                                       &extra_lock, hook_ptr)))
 
1638
                                       &extra_lock)))
1790
1639
    return(-1);                         // abort() deletes table
1791
1640
 
1792
1641
  if (extra_lock)
1796
1645
    if (create_info->options & HA_LEX_CREATE_TMP_TABLE)
1797
1646
      m_plock= &m_lock;
1798
1647
    else
1799
 
      m_plock= &thd->extra_lock;
 
1648
      m_plock= &session->extra_lock;
1800
1649
 
1801
1650
    *m_plock= extra_lock;
1802
1651
  }
1812
1661
 
1813
1662
  /* Mark all fields that are given values */
1814
1663
  for (Field **f= field ; *f ; f++)
1815
 
    bitmap_set_bit(table->write_set, (*f)->field_index);
 
1664
    table->setWriteSet((*f)->field_index);
1816
1665
 
1817
1666
  /* Don't set timestamp if used */
1818
1667
  table->timestamp_field_type= TIMESTAMP_NO_AUTO_SET;
1819
1668
  table->next_number_field=table->found_next_number_field;
1820
1669
 
1821
 
  restore_record(table,s->default_values);      // Get empty record
1822
 
  thd->cuted_fields=0;
 
1670
  table->restoreRecordAsDefault();      // Get empty record
 
1671
  session->cuted_fields=0;
1823
1672
  if (info.ignore || info.handle_duplicates != DUP_ERROR)
1824
1673
    table->file->extra(HA_EXTRA_IGNORE_DUP_KEY);
1825
1674
  if (info.handle_duplicates == DUP_REPLACE)
1827
1676
  if (info.handle_duplicates == DUP_UPDATE)
1828
1677
    table->file->extra(HA_EXTRA_INSERT_WITH_UPDATE);
1829
1678
  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))
 
1679
  session->abort_on_warning= !info.ignore;
 
1680
  if (check_that_all_fields_are_given_values(session, table, table_list))
1832
1681
    return(1);
1833
1682
  table->mark_columns_needed_for_insert();
1834
1683
  table->file->extra(HA_EXTRA_WRITE_CACHE);
1835
1684
  return(0);
1836
1685
}
1837
1686
 
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
1687
void select_create::store_values(List<Item> &values)
1880
1688
{
1881
 
  fill_record(thd, field, values, 1);
 
1689
  fill_record(session, field, values, 1);
1882
1690
}
1883
1691
 
1884
1692
 
1885
1693
void select_create::send_error(uint32_t errcode,const char *err)
1886
1694
{
1887
 
  
 
1695
 
1888
1696
 
1889
1697
  /*
1890
1698
    This will execute any rollbacks that are necessary before writing
1897
1705
    written to the binary log.
1898
1706
 
1899
1707
  */
1900
 
  tmp_disable_binlog(thd);
1901
1708
  select_insert::send_error(errcode, err);
1902
 
  reenable_binlog(thd);
1903
1709
 
1904
1710
  return;
1905
1711
}
1919
1725
    */
1920
1726
    if (!table->s->tmp_table)
1921
1727
    {
1922
 
      ha_autocommit_or_rollback(thd, 0);
1923
 
      end_active_trans(thd);
 
1728
      ha_autocommit_or_rollback(session, 0);
 
1729
      (void) session->endActiveTransaction();
1924
1730
    }
1925
1731
 
1926
1732
    table->file->extra(HA_EXTRA_NO_IGNORE_DUP_KEY);
1927
1733
    table->file->extra(HA_EXTRA_WRITE_CANNOT_REPLACE);
1928
1734
    if (m_plock)
1929
1735
    {
1930
 
      mysql_unlock_tables(thd, *m_plock);
 
1736
      mysql_unlock_tables(session, *m_plock);
1931
1737
      *m_plock= NULL;
1932
1738
      m_plock= NULL;
1933
1739
    }
1938
1744
 
1939
1745
void select_create::abort()
1940
1746
{
1941
 
  
 
1747
 
1942
1748
 
1943
1749
  /*
1944
1750
    In select_insert::abort() we roll back the statement, including
1955
1761
    of the table succeeded or not, since we need to reset the binary
1956
1762
    log state.
1957
1763
  */
1958
 
  tmp_disable_binlog(thd);
1959
1764
  select_insert::abort();
1960
 
  thd->transaction.stmt.modified_non_trans_table= false;
1961
 
  reenable_binlog(thd);
 
1765
  session->transaction.stmt.modified_non_trans_table= false;
1962
1766
 
1963
1767
 
1964
1768
  if (m_plock)
1965
1769
  {
1966
 
    mysql_unlock_tables(thd, *m_plock);
 
1770
    mysql_unlock_tables(session, *m_plock);
1967
1771
    *m_plock= NULL;
1968
1772
    m_plock= NULL;
1969
1773
  }
1973
1777
    table->file->extra(HA_EXTRA_NO_IGNORE_DUP_KEY);
1974
1778
    table->file->extra(HA_EXTRA_WRITE_CANNOT_REPLACE);
1975
1779
    if (!create_info->table_existed)
1976
 
      drop_open_table(thd, table, create_table->db, create_table->table_name);
 
1780
      drop_open_table(session, table, create_table->db, create_table->table_name);
1977
1781
    table=0;                                    // Safety
1978
1782
  }
1979
1783
  return;