← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to drizzled/sql_insert.cc

  • Committer: Brian Aker
  • Date: 2010-08-17 01:34:55 UTC
  • mto: (1711.1.23 build)
  • mto: This revision was merged to the branch mainline in revision 1714.
  • Revision ID: brian@tangent.org-20100817013455-zx3nm7qilxvpwrgb
Style on structure cleanup

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 */
25
25
#include <drizzled/probes.h>
26
26
#include <drizzled/sql_base.h>
27
27
#include <drizzled/sql_load.h>
28
 
#include <drizzled/field/epoch.h>
 
28
#include <drizzled/field/timestamp.h>
29
29
#include <drizzled/lock.h>
30
30
#include "drizzled/sql_table.h"
31
31
#include "drizzled/pthread_globals.h"
32
32
#include "drizzled/transaction_services.h"
33
33
#include "drizzled/plugin/transactional_storage_engine.h"
34
34
 
35
 
#include "drizzled/table/shell.h"
36
 
 
37
35
namespace drizzled
38
36
{
39
37
 
129
127
      }
130
128
      else
131
129
      {
132
 
        table->setWriteSet(table->timestamp_field->position());
 
130
        table->setWriteSet(table->timestamp_field->field_index);
133
131
      }
134
132
    }
135
133
  }
170
168
      Unmark the timestamp field so that we can check if this is modified
171
169
      by update_fields
172
170
    */
173
 
    timestamp_mark= table->write_set->test(table->timestamp_field->position());
174
 
    table->write_set->reset(table->timestamp_field->position());
 
171
    timestamp_mark= table->write_set->testAndClear(table->timestamp_field->field_index);
175
172
  }
176
173
 
177
174
  /* Check the fields we are going to modify */
189
186
 
190
187
    if (timestamp_mark)
191
188
    {
192
 
      table->setWriteSet(table->timestamp_field->position());
 
189
      table->setWriteSet(table->timestamp_field->field_index);
193
190
    }
194
191
  }
195
192
  return 0;
227
224
  end of dispatch_command().
228
225
*/
229
226
 
230
 
bool insert_query(Session *session,TableList *table_list,
 
227
bool mysql_insert(Session *session,TableList *table_list,
231
228
                  List<Item> &fields,
232
229
                  List<List_item> &values_list,
233
230
                  List<Item> &update_fields,
271
268
  values= its++;
272
269
  value_count= values->elements;
273
270
 
274
 
  if (prepare_insert(session, table_list, table, fields, values,
 
271
  if (mysql_prepare_insert(session, table_list, table, fields, values,
275
272
                           update_fields, update_values, duplic, &unused_conds,
276
273
                           false,
277
274
                           (fields.elements || !value_count ||
278
275
                            (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
 
  }
 
276
    goto abort;
288
277
 
289
278
  /* mysql_prepare_insert set table_list->table if it was not set */
290
279
  table= table_list->table;
315
304
    if (values->elements != value_count)
316
305
    {
317
306
      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;
 
307
      goto abort;
327
308
    }
328
309
    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
 
    }
 
310
      goto abort;
338
311
  }
339
312
  its.rewind ();
340
313
 
344
317
  /*
345
318
    Fill in the given fields and dump it to the table cursor
346
319
  */
 
320
  memset(&info, 0, sizeof(info));
347
321
  info.ignore= ignore;
348
322
  info.handle_duplicates=duplic;
349
323
  info.update_fields= &update_fields;
372
346
  }
373
347
 
374
348
 
375
 
  session->setAbortOnWarning(not ignore);
 
349
  session->abort_on_warning= !ignore;
376
350
 
377
351
  table->mark_columns_needed_for_insert();
378
352
 
478
452
    table->cursor->extra(HA_EXTRA_WRITE_CANNOT_REPLACE);
479
453
 
480
454
  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
 
 
 
455
    goto abort;
491
456
  if (values_list.elements == 1 && (!(session->options & OPTION_WARNINGS) ||
492
457
                                    !session->cuted_fields))
493
458
  {
494
459
    session->row_count_func= info.copied + info.deleted + info.updated;
495
 
    session->my_ok((ulong) session->rowCount(),
 
460
    session->my_ok((ulong) session->row_count_func,
496
461
                   info.copied + info.deleted + info.touched, id);
497
462
  }
498
463
  else
505
470
      snprintf(buff, sizeof(buff), ER(ER_INSERT_INFO), (ulong) info.records,
506
471
              (ulong) (info.deleted + info.updated), (ulong) session->cuted_fields);
507
472
    session->row_count_func= info.copied + info.deleted + info.updated;
508
 
    session->my_ok((ulong) session->rowCount(),
 
473
    session->my_ok((ulong) session->row_count_func,
509
474
                   info.copied + info.deleted + info.touched, id, buff);
510
475
  }
511
 
  session->status_var.inserted_row_count+= session->rowCount();
512
 
  session->setAbortOnWarning(false);
513
 
  DRIZZLE_INSERT_DONE(0, session->rowCount());
514
 
 
 
476
  session->status_var.inserted_row_count+= session->row_count_func;
 
477
  session->abort_on_warning= 0;
 
478
  DRIZZLE_INSERT_DONE(0, session->row_count_func);
515
479
  return false;
 
480
 
 
481
abort:
 
482
  if (table != NULL)
 
483
    table->cursor->ha_release_auto_increment();
 
484
  if (!joins_freed)
 
485
    free_underlaid_joins(session, &session->lex->select_lex);
 
486
  session->abort_on_warning= 0;
 
487
  DRIZZLE_INSERT_DONE(1, 0);
 
488
  return true;
516
489
}
517
490
 
518
491
 
520
493
  Check if table can be updated
521
494
 
522
495
  SYNOPSIS
523
 
     prepare_insert_check_table()
 
496
     mysql_prepare_insert_check_table()
524
497
     session            Thread handle
525
498
     table_list         Table list
526
499
     fields             List of fields to be updated
532
505
     true  ERROR
533
506
*/
534
507
 
535
 
static bool prepare_insert_check_table(Session *session, TableList *table_list,
 
508
static bool mysql_prepare_insert_check_table(Session *session, TableList *table_list,
536
509
                                             List<Item> &,
537
510
                                             bool select_insert)
538
511
{
560
533
  Prepare items in INSERT statement
561
534
 
562
535
  SYNOPSIS
563
 
    prepare_insert()
 
536
    mysql_prepare_insert()
564
537
    session                     Thread handler
565
538
    table_list          Global/local table list
566
539
    table               Table to insert into (can be NULL if table should
587
560
    true  error
588
561
*/
589
562
 
590
 
bool prepare_insert(Session *session, TableList *table_list,
 
563
bool mysql_prepare_insert(Session *session, TableList *table_list,
591
564
                          Table *table, List<Item> &fields, List_item *values,
592
565
                          List<Item> &update_fields, List<Item> &update_values,
593
566
                          enum_duplicates duplic,
610
583
    inserting (for INSERT ... SELECT this is done by changing table_list,
611
584
    because INSERT ... SELECT share Select_Lex it with SELECT.
612
585
  */
613
 
  if (not select_insert)
 
586
  if (!select_insert)
614
587
  {
615
588
    for (Select_Lex_Unit *un= select_lex->first_inner_unit();
616
589
         un;
632
605
      return(true);
633
606
  }
634
607
 
635
 
  if (prepare_insert_check_table(session, table_list, fields, select_insert))
 
608
  if (mysql_prepare_insert_check_table(session, table_list, fields, select_insert))
636
609
    return(true);
637
610
 
638
611
 
658
631
 
659
632
    if (!res && check_fields)
660
633
    {
661
 
      bool saved_abort_on_warning= session->abortOnWarning();
662
 
 
663
 
      session->setAbortOnWarning(abort_on_warning);
 
634
      bool saved_abort_on_warning= session->abort_on_warning;
 
635
      session->abort_on_warning= abort_on_warning;
664
636
      res= check_that_all_fields_are_given_values(session,
665
637
                                                  table ? table :
666
638
                                                  context->table_list->table,
667
639
                                                  context->table_list);
668
 
      session->setAbortOnWarning(saved_abort_on_warning);
 
640
      session->abort_on_warning= saved_abort_on_warning;
669
641
    }
670
642
 
671
643
    if (!res && duplic == DUP_UPDATE)
676
648
    /* Restore the current context. */
677
649
    ctx_state.restore_state(context, table_list);
678
650
 
679
 
    if (not res)
 
651
    if (!res)
680
652
      res= setup_fields(session, 0, update_values, MARK_COLUMNS_READ, 0, 0);
681
653
  }
682
654
 
683
655
  if (res)
684
656
    return(res);
685
657
 
686
 
  if (not table)
 
658
  if (!table)
687
659
    table= table_list->table;
688
660
 
689
 
  if (not select_insert)
 
661
  if (!select_insert)
690
662
  {
691
663
    TableList *duplicate;
692
664
    if ((duplicate= unique_table(table_list, table_list->next_global, true)))
696
668
      return true;
697
669
    }
698
670
  }
699
 
 
700
671
  if (duplic == DUP_UPDATE || duplic == DUP_REPLACE)
701
672
    table->prepare_for_position();
702
673
 
745
716
int write_record(Session *session, Table *table,CopyInfo *info)
746
717
{
747
718
  int error;
748
 
  std::vector<unsigned char> key;
749
 
  boost::dynamic_bitset<> *save_read_set, *save_write_set;
 
719
  char *key=0;
 
720
  MyBitmap *save_read_set, *save_write_set;
750
721
  uint64_t prev_insert_id= table->cursor->next_insert_id;
751
722
  uint64_t insert_id_for_cur_row= 0;
752
723
 
816
787
          goto err;
817
788
        }
818
789
 
819
 
        if (not key.size())
 
790
        if (!key)
820
791
        {
821
 
          key.resize(table->getShare()->max_unique_length);
 
792
          if (!(key=(char*) malloc(table->getShare()->max_unique_length)))
 
793
          {
 
794
            error=ENOMEM;
 
795
            goto err;
 
796
          }
822
797
        }
823
 
        key_copy(&key[0], table->getInsertRecord(), table->key_info+key_nr, 0);
 
798
        key_copy((unsigned char*) key,table->getInsertRecord(),table->key_info+key_nr,0);
824
799
        if ((error=(table->cursor->index_read_idx_map(table->getUpdateRecord(),key_nr,
825
 
                                                    &key[0], HA_WHOLE_KEY,
 
800
                                                    (unsigned char*) key, HA_WHOLE_KEY,
826
801
                                                    HA_READ_KEY_EXACT))))
827
802
          goto err;
828
803
      }
848
823
          table->cursor->adjust_next_insert_id_after_explicit_value(
849
824
            table->next_number_field->val_int());
850
825
        info->touched++;
851
 
 
852
 
        if (! table->records_are_comparable() || table->compare_records())
 
826
        if ((table->cursor->getEngine()->check_flag(HTON_BIT_PARTIAL_COLUMN_READ) &&
 
827
             !bitmap_is_subset(table->write_set, table->read_set)) ||
 
828
            table->compare_record())
853
829
        {
854
830
          if ((error=table->cursor->updateRecord(table->getUpdateRecord(),
855
831
                                                table->getInsertRecord())) &&
870
846
          /*
871
847
            If ON DUP KEY UPDATE updates a row instead of inserting one, it's
872
848
            like a regular UPDATE statement: it should not affect the value of a
873
 
            next SELECT LAST_INSERT_ID() or insert_id().
 
849
            next SELECT LAST_INSERT_ID() or mysql_insert_id().
874
850
            Except if LAST_INSERT_ID(#) was in the INSERT query, which is
875
851
            handled separately by Session::arg_of_last_insert_id_function.
876
852
          */
939
915
    */
940
916
    if (table->read_set != save_read_set ||
941
917
        table->write_set != save_write_set)
942
 
      table->column_bitmaps_set(*save_read_set, *save_write_set);
 
918
      table->column_bitmaps_set(save_read_set, save_write_set);
943
919
  }
944
920
  else if ((error=table->cursor->insertRecord(table->getInsertRecord())))
945
921
  {
955
931
  session->record_first_successful_insert_id_in_cur_stmt(table->cursor->insert_id_for_cur_row);
956
932
 
957
933
gok_or_after_err:
 
934
  if (key)
 
935
    free(key);
958
936
  if (!table->cursor->has_transactions())
959
937
    session->transaction.stmt.markModifiedNonTransData();
960
938
  return(0);
968
946
 
969
947
before_err:
970
948
  table->cursor->restore_auto_increment(prev_insert_id);
971
 
  table->column_bitmaps_set(*save_read_set, *save_write_set);
972
 
  return 1;
 
949
  if (key)
 
950
    free(key);
 
951
  table->column_bitmaps_set(save_read_set, save_write_set);
 
952
  return(1);
973
953
}
974
954
 
975
955
 
1016
996
      }
1017
997
    }
1018
998
  }
1019
 
  return session->abortOnWarning() ? err : 0;
 
999
  return session->abort_on_warning ? err : 0;
1020
1000
}
1021
1001
 
1022
1002
/***************************************************************************
1028
1008
  make insert specific preparation and checks after opening tables
1029
1009
 
1030
1010
  SYNOPSIS
1031
 
    insert_select_prepare()
 
1011
    mysql_insert_select_prepare()
1032
1012
    session         thread handler
1033
1013
 
1034
1014
  RETURN
1036
1016
    true  Error
1037
1017
*/
1038
1018
 
1039
 
bool insert_select_prepare(Session *session)
 
1019
bool mysql_insert_select_prepare(Session *session)
1040
1020
{
1041
1021
  LEX *lex= session->lex;
1042
1022
  Select_Lex *select_lex= &lex->select_lex;
1046
1026
    clause if table is VIEW
1047
1027
  */
1048
1028
 
1049
 
  if (prepare_insert(session, lex->query_tables,
 
1029
  if (mysql_prepare_insert(session, lex->query_tables,
1050
1030
                           lex->query_tables->table, lex->field_list, 0,
1051
1031
                           lex->update_list, lex->value_list,
1052
1032
                           lex->duplicates,
1070
1050
                             List<Item> *update_fields,
1071
1051
                             List<Item> *update_values,
1072
1052
                             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)
 
1053
                             bool ignore_check_option_errors)
 
1054
  :table_list(table_list_par), table(table_par), fields(fields_par),
 
1055
   autoinc_value_of_last_inserted_row(0),
 
1056
   insert_into_view(table_list_par && 0 != 0)
1077
1057
{
 
1058
  memset(&info, 0, sizeof(info));
1078
1059
  info.handle_duplicates= duplic;
1079
1060
  info.ignore= ignore_check_option_errors;
1080
1061
  info.update_fields= update_fields;
1105
1086
 
1106
1087
  if (!res && fields->elements)
1107
1088
  {
1108
 
    bool saved_abort_on_warning= session->abortOnWarning();
1109
 
    session->setAbortOnWarning(not info.ignore);
 
1089
    bool saved_abort_on_warning= session->abort_on_warning;
 
1090
    session->abort_on_warning= !info.ignore;
1110
1091
    res= check_that_all_fields_are_given_values(session, table_list->table,
1111
1092
                                                table_list);
1112
 
    session->setAbortOnWarning(saved_abort_on_warning);
 
1093
    session->abort_on_warning= saved_abort_on_warning;
1113
1094
  }
1114
1095
 
1115
1096
  if (info.handle_duplicates == DUP_UPDATE && !res)
1202
1183
  table->next_number_field=table->found_next_number_field;
1203
1184
 
1204
1185
  session->cuted_fields=0;
1205
 
 
1206
1186
  if (info.ignore || info.handle_duplicates != DUP_ERROR)
1207
1187
    table->cursor->extra(HA_EXTRA_IGNORE_DUP_KEY);
1208
 
 
1209
1188
  if (info.handle_duplicates == DUP_REPLACE)
1210
1189
    table->cursor->extra(HA_EXTRA_WRITE_CAN_REPLACE);
1211
 
 
1212
1190
  if (info.handle_duplicates == DUP_UPDATE)
1213
1191
    table->cursor->extra(HA_EXTRA_INSERT_WITH_UPDATE);
1214
 
 
1215
 
  session->setAbortOnWarning(not info.ignore);
 
1192
  session->abort_on_warning= !info.ignore;
1216
1193
  table->mark_columns_needed_for_insert();
1217
1194
 
1218
1195
 
1261
1238
    table->cursor->ha_reset();
1262
1239
  }
1263
1240
  session->count_cuted_fields= CHECK_FIELD_IGNORE;
1264
 
  session->setAbortOnWarning(false);
 
1241
  session->abort_on_warning= 0;
1265
1242
  return;
1266
1243
}
1267
1244
 
1274
1251
  if (unit->offset_limit_cnt)
1275
1252
  {                                             // using limit offset,count
1276
1253
    unit->offset_limit_cnt--;
1277
 
    return false;
 
1254
    return(0);
1278
1255
  }
1279
1256
 
1280
1257
  session->count_cuted_fields= CHECK_FIELD_WARN;        // Calculate cuted fields
1281
1258
  store_values(values);
1282
1259
  session->count_cuted_fields= CHECK_FIELD_IGNORE;
1283
1260
  if (session->is_error())
1284
 
    return true;
 
1261
    return(1);
1285
1262
 
1286
1263
  // Release latches in case bulk insert takes a long time
1287
1264
  plugin::TransactionalStorageEngine::releaseTemporaryLatches(session);
1331
1308
    fill_record(session, table->getFields(), values, true);
1332
1309
}
1333
1310
 
1334
 
void select_insert::send_error(drizzled::error_t errcode,const char *err)
 
1311
void select_insert::send_error(uint32_t errcode,const char *err)
1335
1312
{
 
1313
 
 
1314
 
1336
1315
  my_message(errcode, err, MYF(0));
 
1316
 
 
1317
  return;
1337
1318
}
1338
1319
 
1339
1320
 
1382
1363
    (session->arg_of_last_insert_id_function ?
1383
1364
     session->first_successful_insert_id_in_prev_stmt :
1384
1365
     (info.copied ? autoinc_value_of_last_inserted_row : 0));
1385
 
  session->my_ok((ulong) session->rowCount(),
 
1366
  session->my_ok((ulong) session->row_count_func,
1386
1367
                 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());
 
1368
  session->status_var.inserted_row_count+= session->row_count_func; 
 
1369
  DRIZZLE_INSERT_SELECT_DONE(0, session->row_count_func);
1389
1370
  return 0;
1390
1371
}
1391
1372
 
1487
1468
                                      List<Item> *items,
1488
1469
                                      bool is_if_not_exists,
1489
1470
                                      DrizzleLock **lock,
1490
 
                                      identifier::Table::const_reference identifier)
 
1471
                                      TableIdentifier &identifier)
1491
1472
{
 
1473
  Table tmp_table;              // Used during 'CreateField()'
1492
1474
  TableShare share(message::Table::INTERNAL);
 
1475
  Table *table= 0;
1493
1476
  uint32_t select_field_count= items->elements;
1494
1477
  /* Add selected items to field list */
1495
1478
  List_iterator_fast<Item> it(*items);
1496
1479
  Item *item;
1497
1480
  Field *tmp_field;
 
1481
  bool not_used;
1498
1482
 
1499
1483
  if (not (identifier.isTmp()) && create_table->table->db_stat)
1500
1484
  {
1504
1488
      create_info->table_existed= 1;            // Mark that table existed
1505
1489
      push_warning_printf(session, DRIZZLE_ERROR::WARN_LEVEL_NOTE,
1506
1490
                          ER_TABLE_EXISTS_ERROR, ER(ER_TABLE_EXISTS_ERROR),
1507
 
                          create_table->getTableName());
 
1491
                          create_table->table_name);
1508
1492
      return create_table->table;
1509
1493
    }
1510
1494
 
1511
 
    my_error(ER_TABLE_EXISTS_ERROR, MYF(0), create_table->getTableName());
 
1495
    my_error(ER_TABLE_EXISTS_ERROR, MYF(0), create_table->table_name);
1512
1496
    return NULL;
1513
1497
  }
1514
1498
 
 
1499
  tmp_table.timestamp_field= 0;
 
1500
  tmp_table.setShare(&share);
 
1501
 
 
1502
  tmp_table.getMutableShare()->db_create_options= 0;
 
1503
  tmp_table.getMutableShare()->blob_ptr_size= portable_sizeof_char_ptr;
 
1504
 
 
1505
  if (not table_proto.engine().name().compare("MyISAM"))
 
1506
    tmp_table.getMutableShare()->db_low_byte_first= true;
 
1507
  else if (not table_proto.engine().name().compare("MEMORY"))
 
1508
    tmp_table.getMutableShare()->db_low_byte_first= true;
 
1509
 
 
1510
  tmp_table.null_row= false;
 
1511
  tmp_table.maybe_null= false;
 
1512
 
 
1513
  while ((item=it++))
1515
1514
  {
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
 
      }
 
1515
    CreateField *cr_field;
 
1516
    Field *field, *def_field;
 
1517
    if (item->type() == Item::FUNC_ITEM)
 
1518
      if (item->result_type() != STRING_RESULT)
 
1519
        field= item->tmp_table_field(&tmp_table);
1540
1520
      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
 
    }
 
1521
        field= item->tmp_table_field_from_field_type(&tmp_table, 0);
 
1522
    else
 
1523
      field= create_tmp_field(session, &tmp_table, item, item->type(),
 
1524
                              (Item ***) 0, &tmp_field, &def_field, false,
 
1525
                              false, false, 0);
 
1526
    if (!field ||
 
1527
        !(cr_field=new CreateField(field,(item->type() == Item::FIELD_ITEM ?
 
1528
                                           ((Item_field *)item)->field :
 
1529
                                           (Field*) 0))))
 
1530
      return NULL;
 
1531
    if (item->maybe_null)
 
1532
      cr_field->flags &= ~NOT_NULL_FLAG;
 
1533
    alter_info->create_list.push_back(cr_field);
1562
1534
  }
1563
1535
 
1564
1536
  /*
1568
1540
    creating base table on which name we have exclusive lock. So code below
1569
1541
    should not cause deadlocks or races.
1570
1542
  */
1571
 
  Table *table= 0;
1572
1543
  {
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))
 
1544
    if (not mysql_create_table_no_lock(session,
 
1545
                                       identifier,
 
1546
                                       create_info,
 
1547
                                       table_proto,
 
1548
                                       alter_info,
 
1549
                                       false,
 
1550
                                       select_field_count,
 
1551
                                       is_if_not_exists))
1581
1552
    {
1582
1553
      if (create_info->table_existed && not identifier.isTmp())
1583
1554
      {
1586
1557
          or it was created via different mysqld front-end to the
1587
1558
          cluster. We don't have much options but throw an error.
1588
1559
        */
1589
 
        my_error(ER_TABLE_EXISTS_ERROR, MYF(0), create_table->getTableName());
 
1560
        my_error(ER_TABLE_EXISTS_ERROR, MYF(0), create_table->table_name);
1590
1561
        return NULL;
1591
1562
      }
1592
1563
 
1593
1564
      if (not identifier.isTmp())
1594
1565
      {
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)
 
1566
        LOCK_open.lock(); /* CREATE TABLE... has found that the table already exists for insert and is adapting to use it */
 
1567
        if (session->reopen_name_locked_table(create_table, false))
1599
1568
        {
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
 
          }
 
1569
          quick_rm_table(*session, identifier);
1610
1570
        }
1611
1571
        else
1612
 
        {
1613
 
          (void)plugin::StorageEngine::dropTable(*session, identifier);
1614
 
        }
 
1572
          table= create_table->table;
 
1573
        LOCK_open.unlock();
1615
1574
      }
1616
1575
      else
1617
1576
      {
1624
1583
            it preparable for open. But let us do close_temporary_table() here
1625
1584
            just in case.
1626
1585
          */
1627
 
          session->drop_temporary_table(identifier);
 
1586
          session->drop_temporary_table(create_table);
1628
1587
        }
1629
1588
      }
1630
1589
    }
1631
 
    if (not table)                                   // open failed
 
1590
    if (!table)                                   // open failed
1632
1591
      return NULL;
1633
1592
  }
1634
1593
 
1635
1594
  table->reginfo.lock_type=TL_WRITE;
1636
 
  if (not ((*lock)= session->lockTables(&table, 1, DRIZZLE_LOCK_IGNORE_FLUSH)))
 
1595
  if (! ((*lock)= mysql_lock_tables(session, &table, 1,
 
1596
                                    DRIZZLE_LOCK_IGNORE_FLUSH, &not_used)))
1637
1597
  {
1638
1598
    if (*lock)
1639
1599
    {
1640
 
      session->unlockTables(*lock);
 
1600
      mysql_unlock_tables(session, *lock);
1641
1601
      *lock= 0;
1642
1602
    }
1643
1603
 
1698
1658
 
1699
1659
  /* Mark all fields that are given values */
1700
1660
  for (Field **f= field ; *f ; f++)
1701
 
  {
1702
 
    table->setWriteSet((*f)->position());
1703
 
  }
 
1661
    table->setWriteSet((*f)->field_index);
1704
1662
 
1705
1663
  /* Don't set timestamp if used */
1706
1664
  table->timestamp_field_type= TIMESTAMP_NO_AUTO_SET;
1710
1668
  session->cuted_fields=0;
1711
1669
  if (info.ignore || info.handle_duplicates != DUP_ERROR)
1712
1670
    table->cursor->extra(HA_EXTRA_IGNORE_DUP_KEY);
1713
 
 
1714
1671
  if (info.handle_duplicates == DUP_REPLACE)
1715
1672
    table->cursor->extra(HA_EXTRA_WRITE_CAN_REPLACE);
1716
 
 
1717
1673
  if (info.handle_duplicates == DUP_UPDATE)
1718
1674
    table->cursor->extra(HA_EXTRA_INSERT_WITH_UPDATE);
1719
 
 
1720
1675
  table->cursor->ha_start_bulk_insert((ha_rows) 0);
1721
 
  session->setAbortOnWarning(not info.ignore);
 
1676
  session->abort_on_warning= !info.ignore;
1722
1677
  if (check_that_all_fields_are_given_values(session, table, table_list))
1723
1678
    return(1);
1724
 
 
1725
1679
  table->mark_columns_needed_for_insert();
1726
1680
  table->cursor->extra(HA_EXTRA_WRITE_CACHE);
1727
1681
  return(0);
1733
1687
}
1734
1688
 
1735
1689
 
1736
 
void select_create::send_error(drizzled::error_t errcode,const char *err)
 
1690
void select_create::send_error(uint32_t errcode,const char *err)
1737
1691
{
1738
1692
  /*
1739
1693
    This will execute any rollbacks that are necessary before writing
1747
1701
 
1748
1702
  */
1749
1703
  select_insert::send_error(errcode, err);
 
1704
 
 
1705
  return;
1750
1706
}
1751
1707
 
1752
1708
 
1765
1721
    if (!table->getShare()->getType())
1766
1722
    {
1767
1723
      TransactionServices &transaction_services= TransactionServices::singleton();
1768
 
      transaction_services.autocommitOrRollback(*session, 0);
 
1724
      transaction_services.autocommitOrRollback(session, 0);
1769
1725
      (void) session->endActiveTransaction();
1770
1726
    }
1771
1727
 
1773
1729
    table->cursor->extra(HA_EXTRA_WRITE_CANNOT_REPLACE);
1774
1730
    if (m_plock)
1775
1731
    {
1776
 
      session->unlockTables(*m_plock);
 
1732
      mysql_unlock_tables(session, *m_plock);
1777
1733
      *m_plock= NULL;
1778
1734
      m_plock= NULL;
1779
1735
    }
1803
1759
 
1804
1760
  if (m_plock)
1805
1761
  {
1806
 
    session->unlockTables(*m_plock);
 
1762
    mysql_unlock_tables(session, *m_plock);
1807
1763
    *m_plock= NULL;
1808
1764
    m_plock= NULL;
1809
1765
  }