← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to drizzled/sql_insert.cc

  • Committer: Monty Taylor
  • Date: 2008-08-22 04:35:12 UTC
  • mto: (365.1.2 drizzle)
  • mto: This revision was merged to the branch mainline in revision 368.
  • Revision ID: monty@inaugust.com-20080822043512-3vafw99x3vv97d39
INT32_MAX stuff.

Show diffs side-by-side

added added

removed removed

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