← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to drizzled/sql_table.cc

Merge Revision revid:marko.makela@oracle.com-20100601140355-u3kxl0yl0ljl5tx9 from MySQL InnoDB

Original revid:marko.makela@oracle.com-20100601140355-u3kxl0yl0ljl5tx9

Original Authors: Marko Mäkelä <marko.makela@oracle.com>
Original commit message:
Merge a change from mysql-5.1-innodb:

  ------------------------------------------------------------
  revno: 3491
  revision-id: marko.makela@oracle.com-20100601134335-ccthwwru23kn09qw
  parent: marko.makela@oracle.com-20100601120751-1uq7bbta5n7ts0qr
  committer: Marko Mäkelä <marko.makela@oracle.com>
  branch nick: 5.1-innodb
  timestamp: Tue 2010-06-01 16:43:35 +0300
  message:
    Bug#48197: Concurrent rw_lock_free may cause assertion failure

    rw_lock_t: Remove magic_n unless UNIV_DEBUG is defined.
    rw_lock_free(): Invalidate magic_n only after removing from rw_lock_list.

Show diffs side-by-side

added added

removed removed

Lines of Context:
drizzled/sql_table.cc
15
15
 
16
16
/* drop and alter of tables */
17
17
 
18
 
#include <config.h>
 
18
#include "config.h"
19
19
#include <plugin/myisam/myisam.h>
20
20
#include <drizzled/show.h>
21
21
#include <drizzled/error.h>
26
26
#include <drizzled/sql_lex.h>
27
27
#include <drizzled/session.h>
28
28
#include <drizzled/sql_base.h>
29
 
#include <drizzled/strfunc.h>
 
29
#include "drizzled/strfunc.h"
 
30
#include <drizzled/db.h>
30
31
#include <drizzled/lock.h>
31
32
#include <drizzled/unireg.h>
32
33
#include <drizzled/item/int.h>
33
34
#include <drizzled/item/empty_string.h>
34
35
#include <drizzled/transaction_services.h>
35
 
#include <drizzled/transaction_services.h>
 
36
#include "drizzled/transaction_services.h"
36
37
#include <drizzled/table_proto.h>
37
38
#include <drizzled/plugin/client.h>
38
39
#include <drizzled/identifier.h>
39
 
#include <drizzled/internal/m_string.h>
40
 
#include <drizzled/global_charset_info.h>
41
 
#include <drizzled/charset.h>
42
 
 
43
 
#include <drizzled/definition/cache.h>
44
 
 
45
 
#include <drizzled/statement/alter_table.h>
46
 
#include <drizzled/sql_table.h>
47
 
#include <drizzled/pthread_globals.h>
48
 
#include <drizzled/typelib.h>
49
 
#include <drizzled/plugin/storage_engine.h>
 
40
#include "drizzled/internal/m_string.h"
 
41
#include "drizzled/global_charset_info.h"
 
42
#include "drizzled/charset.h"
 
43
 
 
44
 
 
45
#include "drizzled/statement/alter_table.h"
 
46
#include "drizzled/sql_table.h"
 
47
#include "drizzled/pthread_globals.h"
50
48
 
51
49
#include <algorithm>
52
50
#include <sstream>
58
56
namespace drizzled
59
57
{
60
58
 
 
59
extern pid_t current_pid;
 
60
 
61
61
bool is_primary_key(KeyInfo *key_info)
62
62
{
63
63
  static const char * primary_key_name="PRIMARY";
85
85
    let's fetch the database default character set and
86
86
    apply it to the table.
87
87
  */
88
 
  identifier::Schema identifier(db);
 
88
  SchemaIdentifier identifier(db);
89
89
  if (create_info->default_table_charset == NULL)
90
90
    create_info->default_table_charset= plugin::StorageEngine::getSchemaCollation(identifier);
91
91
}
105
105
    cursor
106
106
*/
107
107
 
108
 
void write_bin_log(Session *session, const std::string &query)
 
108
void write_bin_log(Session *session,
 
109
                   char const *query)
109
110
{
110
111
  TransactionServices &transaction_services= TransactionServices::singleton();
111
 
  transaction_services.rawStatement(*session, query);
 
112
  transaction_services.rawStatement(session, query);
112
113
}
113
114
 
114
115
/*
115
116
  Execute the drop of a normal or temporary table
116
117
 
117
118
  SYNOPSIS
118
 
    rm_table_part2()
 
119
    mysql_rm_table_part2()
119
120
    session                     Thread Cursor
120
121
    tables              Tables to drop
121
122
    if_exists           If set, don't give an error if table doesn't exists.
138
139
   -1   Thread was killed
139
140
*/
140
141
 
141
 
int rm_table_part2(Session *session, TableList *tables, bool if_exists,
142
 
                   bool drop_temporary)
 
142
int mysql_rm_table_part2(Session *session, TableList *tables, bool if_exists,
 
143
                         bool drop_temporary)
143
144
{
144
145
  TableList *table;
145
 
  util::string::vector wrong_tables;
 
146
  String wrong_tables;
146
147
  int error= 0;
147
148
  bool foreign_key_error= false;
148
149
 
149
 
  do
150
 
  {
151
 
    boost::mutex::scoped_lock scopedLock(table::Cache::singleton().mutex());
152
 
 
153
 
    if (not drop_temporary && session->lock_table_names_exclusively(tables))
154
 
    {
155
 
      return 1;
156
 
    }
157
 
 
158
 
    /* Don't give warnings for not found errors, as we already generate notes */
159
 
    session->no_warnings_for_error= 1;
160
 
 
161
 
    for (table= tables; table; table= table->next_local)
162
 
    {
163
 
      identifier::Table tmp_identifier(table->getSchemaName(), table->getTableName());
164
 
 
165
 
      error= session->drop_temporary_table(tmp_identifier);
166
 
 
167
 
      switch (error) {
168
 
      case  0:
169
 
        // removed temporary table
170
 
        continue;
171
 
      case -1:
 
150
  LOCK_open.lock(); /* Part 2 of rm a table */
 
151
 
 
152
  if (not drop_temporary && session->lock_table_names_exclusively(tables))
 
153
  {
 
154
    LOCK_open.unlock();
 
155
    return 1;
 
156
  }
 
157
 
 
158
  /* Don't give warnings for not found errors, as we already generate notes */
 
159
  session->no_warnings_for_error= 1;
 
160
 
 
161
  for (table= tables; table; table= table->next_local)
 
162
  {
 
163
    TableIdentifier tmp_identifier(table->getSchemaName(), table->getTableName());
 
164
 
 
165
    error= session->drop_temporary_table(tmp_identifier);
 
166
 
 
167
    switch (error) {
 
168
    case  0:
 
169
      // removed temporary table
 
170
      continue;
 
171
    case -1:
 
172
      error= 1;
 
173
      goto err_with_placeholders;
 
174
    default:
 
175
      // temporary table not found
 
176
      error= 0;
 
177
    }
 
178
 
 
179
    if (drop_temporary == false)
 
180
    {
 
181
      Table *locked_table;
 
182
      abort_locked_tables(session, tmp_identifier);
 
183
      table::Cache::singleton().removeTable(session, tmp_identifier,
 
184
                                            RTFC_WAIT_OTHER_THREAD_FLAG |
 
185
                                            RTFC_CHECK_KILLED_FLAG);
 
186
      /*
 
187
        If the table was used in lock tables, remember it so that
 
188
        unlock_table_names can free it
 
189
      */
 
190
      if ((locked_table= drop_locked_tables(session, tmp_identifier)))
 
191
        table->table= locked_table;
 
192
 
 
193
      if (session->getKilled())
 
194
      {
 
195
        error= -1;
 
196
        goto err_with_placeholders;
 
197
      }
 
198
    }
 
199
    TableIdentifier identifier(table->getSchemaName(), table->getTableName(), table->getInternalTmpTable() ? message::Table::INTERNAL : message::Table::STANDARD);
 
200
 
 
201
    if (drop_temporary || not plugin::StorageEngine::doesTableExist(*session, identifier))
 
202
    {
 
203
      // Table was not found on disk and table can't be created from engine
 
204
      if (if_exists)
 
205
        push_warning_printf(session, DRIZZLE_ERROR::WARN_LEVEL_NOTE,
 
206
                            ER_BAD_TABLE_ERROR, ER(ER_BAD_TABLE_ERROR),
 
207
                            table->getTableName());
 
208
      else
172
209
        error= 1;
173
 
        break;
174
 
      default:
175
 
        // temporary table not found
 
210
    }
 
211
    else
 
212
    {
 
213
      error= plugin::StorageEngine::dropTable(*session, identifier);
 
214
 
 
215
      if ((error == ENOENT || error == HA_ERR_NO_SUCH_TABLE) && if_exists)
 
216
      {
176
217
        error= 0;
177
 
      }
178
 
 
179
 
      if (drop_temporary == false)
180
 
      {
181
 
        Table *locked_table;
182
 
        abort_locked_tables(session, tmp_identifier);
183
 
        table::Cache::singleton().removeTable(session, tmp_identifier,
184
 
                                              RTFC_WAIT_OTHER_THREAD_FLAG |
185
 
                                              RTFC_CHECK_KILLED_FLAG);
186
 
        /*
187
 
          If the table was used in lock tables, remember it so that
188
 
          unlock_table_names can free it
189
 
        */
190
 
        if ((locked_table= drop_locked_tables(session, tmp_identifier)))
191
 
          table->table= locked_table;
192
 
 
193
 
        if (session->getKilled())
194
 
        {
195
 
          error= -1;
196
 
          break;
197
 
        }
198
 
      }
199
 
      identifier::Table identifier(table->getSchemaName(), table->getTableName(), table->getInternalTmpTable() ? message::Table::INTERNAL : message::Table::STANDARD);
200
 
 
201
 
      message::table::shared_ptr message= plugin::StorageEngine::getTableMessage(*session, identifier, true);
202
 
 
203
 
      if (drop_temporary || not plugin::StorageEngine::doesTableExist(*session, identifier))
204
 
      {
205
 
        // Table was not found on disk and table can't be created from engine
206
 
        if (if_exists)
207
 
        {
208
 
          push_warning_printf(session, DRIZZLE_ERROR::WARN_LEVEL_NOTE,
209
 
                              ER_BAD_TABLE_ERROR, ER(ER_BAD_TABLE_ERROR),
210
 
                              table->getTableName());
211
 
        }
212
 
        else
213
 
        {
214
 
          error= 1;
215
 
        }
216
 
      }
217
 
      else
218
 
      {
219
 
        drizzled::error_t local_error;
220
 
 
221
 
        /* Generate transaction event ONLY when we successfully drop */ 
222
 
        if (plugin::StorageEngine::dropTable(*session, identifier, local_error))
223
 
        {
224
 
          if (message) // If we have no definition, we don't know if the table should have been replicated
225
 
          {
226
 
            TransactionServices &transaction_services= TransactionServices::singleton();
227
 
            transaction_services.dropTable(*session, identifier, *message, if_exists);
228
 
          }
229
 
        }
230
 
        else
231
 
        {
232
 
          if (local_error == HA_ERR_NO_SUCH_TABLE and if_exists)
233
 
          {
234
 
            error= 0;
235
 
            session->clear_error();
236
 
          }
237
 
 
238
 
          if (local_error == HA_ERR_ROW_IS_REFERENCED)
239
 
          {
240
 
            /* the table is referenced by a foreign key constraint */
241
 
            foreign_key_error= true;
242
 
          }
243
 
          error= local_error;
244
 
        }
245
 
      }
246
 
 
247
 
      if (error)
248
 
      {
249
 
        wrong_tables.push_back(table->getTableName());
250
 
      }
251
 
    }
252
 
 
253
 
    tables->unlock_table_names();
254
 
 
255
 
  } while (0);
256
 
 
257
 
  if (wrong_tables.size())
 
218
        session->clear_error();
 
219
      }
 
220
 
 
221
      if (error == HA_ERR_ROW_IS_REFERENCED)
 
222
      {
 
223
        /* the table is referenced by a foreign key constraint */
 
224
        foreign_key_error= true;
 
225
      }
 
226
    }
 
227
 
 
228
    if (error == 0 || (if_exists && foreign_key_error == false))
 
229
    {
 
230
      TransactionServices &transaction_services= TransactionServices::singleton();
 
231
      transaction_services.dropTable(session, string(table->getSchemaName()), string(table->getTableName()), if_exists);
 
232
    }
 
233
 
 
234
    if (error)
 
235
    {
 
236
      if (wrong_tables.length())
 
237
        wrong_tables.append(',');
 
238
      wrong_tables.append(String(table->getTableName(), system_charset_info));
 
239
    }
 
240
  }
 
241
  /*
 
242
    It's safe to unlock LOCK_open: we have an exclusive lock
 
243
    on the table name.
 
244
  */
 
245
  LOCK_open.unlock();
 
246
  error= 0;
 
247
 
 
248
  if (wrong_tables.length())
258
249
  {
259
250
    if (not foreign_key_error)
260
251
    {
261
 
      std::string table_error;
262
 
 
263
 
      for (util::string::vector::iterator iter= wrong_tables.begin();
264
 
           iter != wrong_tables.end();
265
 
           iter++)
266
 
      {
267
 
        table_error+= *iter;
268
 
        table_error+= ',';
269
 
      }
270
 
      table_error.resize(table_error.size() -1);
271
 
 
272
252
      my_printf_error(ER_BAD_TABLE_ERROR, ER(ER_BAD_TABLE_ERROR), MYF(0),
273
 
                      table_error.c_str());
 
253
                      wrong_tables.c_ptr());
274
254
    }
275
255
    else
276
256
    {
279
259
    error= 1;
280
260
  }
281
261
 
 
262
  LOCK_open.lock(); /* final bit in rm table lock */
 
263
 
 
264
err_with_placeholders:
 
265
  tables->unlock_table_names();
 
266
  LOCK_open.unlock();
282
267
  session->no_warnings_for_error= 0;
283
268
 
284
269
  return error;
285
270
}
286
271
 
 
272
 
 
273
/*
 
274
  Quickly remove a table.
 
275
 
 
276
  SYNOPSIS
 
277
    quick_rm_table()
 
278
      base                      The plugin::StorageEngine handle.
 
279
      db                        The database name.
 
280
      table_name                The table name.
 
281
      is_tmp                    If the table is temp.
 
282
 
 
283
  RETURN
 
284
    0           OK
 
285
    != 0        Error
 
286
*/
 
287
bool quick_rm_table(Session& session,
 
288
                    TableIdentifier &identifier)
 
289
{
 
290
  return (plugin::StorageEngine::dropTable(session, identifier));
 
291
}
 
292
 
287
293
/*
288
294
  Sort keys in the following order:
289
295
  - PRIMARY KEY
483
489
    sql_field->length= 8; // Unireg field length
484
490
    (*blob_columns)++;
485
491
    break;
486
 
 
 
492
  case DRIZZLE_TYPE_VARCHAR:
 
493
    break;
487
494
  case DRIZZLE_TYPE_ENUM:
488
 
    {
489
 
      if (check_duplicates_in_interval("ENUM",
490
 
                                       sql_field->field_name,
491
 
                                       sql_field->interval,
492
 
                                       sql_field->charset,
493
 
                                       &dup_val_count))
494
 
      {
495
 
        return 1;
496
 
      }
497
 
    }
498
 
    break;
499
 
 
500
 
  case DRIZZLE_TYPE_MICROTIME:
 
495
    if (check_duplicates_in_interval("ENUM",
 
496
                                     sql_field->field_name,
 
497
                                     sql_field->interval,
 
498
                                     sql_field->charset,
 
499
                                     &dup_val_count))
 
500
      return 1;
 
501
    break;
 
502
  case DRIZZLE_TYPE_DATE:  // Rest of string types
 
503
  case DRIZZLE_TYPE_DATETIME:
 
504
  case DRIZZLE_TYPE_NULL:
 
505
    break;
 
506
  case DRIZZLE_TYPE_DECIMAL:
 
507
    break;
501
508
  case DRIZZLE_TYPE_TIMESTAMP:
502
509
    /* We should replace old TIMESTAMP fields with their newer analogs */
503
510
    if (sql_field->unireg_check == Field::TIMESTAMP_OLD_FIELD)
513
520
      }
514
521
    }
515
522
    else if (sql_field->unireg_check != Field::NONE)
516
 
    {
517
523
      (*timestamps_with_niladic)++;
518
 
    }
519
524
 
520
525
    (*timestamps)++;
521
 
 
522
 
    break;
523
 
 
524
 
  case DRIZZLE_TYPE_BOOLEAN:
525
 
  case DRIZZLE_TYPE_DATE:  // Rest of string types
526
 
  case DRIZZLE_TYPE_DATETIME:
527
 
  case DRIZZLE_TYPE_DECIMAL:
528
 
  case DRIZZLE_TYPE_DOUBLE:
529
 
  case DRIZZLE_TYPE_LONG:
530
 
  case DRIZZLE_TYPE_LONGLONG:
531
 
  case DRIZZLE_TYPE_NULL:
532
 
  case DRIZZLE_TYPE_TIME:
533
 
  case DRIZZLE_TYPE_UUID:
534
 
  case DRIZZLE_TYPE_VARCHAR:
 
526
    /* fall-through */
 
527
  default:
535
528
    break;
536
529
  }
537
530
 
538
531
  return 0;
539
532
}
540
533
 
541
 
static int prepare_create_table(Session *session,
542
 
                                HA_CREATE_INFO *create_info,
543
 
                                message::Table &create_proto,
544
 
                                AlterInfo *alter_info,
545
 
                                bool tmp_table,
546
 
                                uint32_t *db_options,
547
 
                                KeyInfo **key_info_buffer,
548
 
                                uint32_t *key_count,
549
 
                                int select_field_count)
 
534
static int mysql_prepare_create_table(Session *session,
 
535
                                      HA_CREATE_INFO *create_info,
 
536
                                      message::Table &create_proto,
 
537
                                      AlterInfo *alter_info,
 
538
                                      bool tmp_table,
 
539
                                      uint32_t *db_options,
 
540
                                      KeyInfo **key_info_buffer,
 
541
                                      uint32_t *key_count,
 
542
                                      int select_field_count)
550
543
{
551
544
  const char    *key_name;
552
545
  CreateField   *sql_field,*dup_field;
555
548
  KeyInfo               *key_info;
556
549
  KeyPartInfo *key_part_info;
557
550
  int           timestamps= 0, timestamps_with_niladic= 0;
558
 
  int           dup_no;
 
551
  int           field_no,dup_no;
559
552
  int           select_field_pos,auto_increment=0;
560
 
  List<CreateField>::iterator it(alter_info->create_list.begin());
561
 
  List<CreateField>::iterator it2(alter_info->create_list.begin());
 
553
  List_iterator<CreateField> it(alter_info->create_list);
 
554
  List_iterator<CreateField> it2(alter_info->create_list);
562
555
  uint32_t total_uneven_bit_length= 0;
563
556
 
564
557
  plugin::StorageEngine *engine= plugin::StorageEngine::findByName(create_proto.engine().name());
567
560
  null_fields=blob_columns=0;
568
561
  max_key_length= engine->max_key_length();
569
562
 
570
 
  for (int32_t field_no=0; (sql_field=it++) ; field_no++)
 
563
  for (field_no=0; (sql_field=it++) ; field_no++)
571
564
  {
572
565
    const CHARSET_INFO *save_cs;
573
566
 
577
570
      executing a prepared statement for the second time.
578
571
    */
579
572
    sql_field->length= sql_field->char_length;
580
 
 
581
573
    if (!sql_field->charset)
582
574
      sql_field->charset= create_info->default_table_charset;
583
 
 
584
575
    /*
585
576
      table_charset is set in ALTER Table if we want change character set
586
577
      for all varchar/char columns.
652
643
        interval= sql_field->interval= typelib(session->mem_root,
653
644
                                               sql_field->interval_list);
654
645
 
655
 
        List<String>::iterator int_it(sql_field->interval_list.begin());
 
646
        List_iterator<String> int_it(sql_field->interval_list);
656
647
        String conv, *tmp;
657
648
        char comma_buf[4];
658
649
        int comma_length= cs->cset->wc_mb(cs, ',', (unsigned char*) comma_buf,
678
669
          interval->type_lengths[i]= lengthsp;
679
670
          ((unsigned char *)interval->type_names[i])[lengthsp]= '\0';
680
671
        }
681
 
        sql_field->interval_list.clear(); // Don't need interval_list anymore
 
672
        sql_field->interval_list.empty(); // Don't need interval_list anymore
682
673
      }
683
674
 
684
675
      /* DRIZZLE_TYPE_ENUM */
701
692
          else /* not NULL */
702
693
          {
703
694
            def->length(cs->cset->lengthsp(cs, def->ptr(), def->length()));
704
 
            if (interval->find_type2(def->ptr(), def->length(), cs) == 0) /* not found */
 
695
            if (find_type2(interval, def->ptr(), def->length(), cs) == 0) /* not found */
705
696
            {
706
697
              my_error(ER_INVALID_DEFAULT, MYF(0), sql_field->field_name);
707
698
              return(true);
778
769
    if (not create_proto.engine().name().compare("MyISAM") &&
779
770
        ((sql_field->flags & BLOB_FLAG) ||
780
771
         (sql_field->sql_type == DRIZZLE_TYPE_VARCHAR)))
781
 
    {
782
772
      (*db_options)|= HA_OPTION_PACK_RECORD;
783
 
    }
784
 
 
785
 
    it2= alter_info->create_list.begin();
 
773
    it2.rewind();
786
774
  }
787
775
 
788
776
  /* record_offset will be increased with 'length-of-null-bits' later */
789
777
  record_offset= 0;
790
778
  null_fields+= total_uneven_bit_length;
791
779
 
792
 
  it= alter_info->create_list.begin();
 
780
  it.rewind();
793
781
  while ((sql_field=it++))
794
782
  {
795
783
    assert(sql_field->charset != 0);
829
817
 
830
818
  /* Create keys */
831
819
 
832
 
  List<Key>::iterator key_iterator(alter_info->key_list.begin());
833
 
  List<Key>::iterator key_iterator2(alter_info->key_list.begin());
 
820
  List_iterator<Key> key_iterator(alter_info->key_list);
 
821
  List_iterator<Key> key_iterator2(alter_info->key_list);
834
822
  uint32_t key_parts=0, fk_key_count=0;
835
823
  bool primary_key=0,unique_key=0;
836
824
  Key *key, *key2;
880
868
    }
881
869
    if (check_identifier_name(&key->name, ER_TOO_LONG_IDENT))
882
870
      return(true);
883
 
    key_iterator2= alter_info->key_list.begin();
 
871
    key_iterator2.rewind ();
884
872
    if (key->type != Key::FOREIGN_KEY)
885
873
    {
886
874
      while ((key2 = key_iterator2++) != key)
933
921
  if (!*key_info_buffer || ! key_part_info)
934
922
    return(true);                               // Out of memory
935
923
 
936
 
  key_iterator= alter_info->key_list.begin();
 
924
  key_iterator.rewind();
937
925
  key_number=0;
938
926
  for (; (key=key_iterator++) ; key_number++)
939
927
  {
992
980
 
993
981
    message::Table::Field *protofield= NULL;
994
982
 
995
 
    List<Key_part_spec>::iterator cols(key->columns.begin());
996
 
    List<Key_part_spec>::iterator cols2(key->columns.begin());
 
983
    List_iterator<Key_part_spec> cols(key->columns), cols2(key->columns);
997
984
    for (uint32_t column_nr=0 ; (column=cols++) ; column_nr++)
998
985
    {
999
986
      uint32_t length;
1000
987
      Key_part_spec *dup_column;
1001
988
      int proto_field_nr= 0;
1002
989
 
1003
 
      it= alter_info->create_list.begin();
 
990
      it.rewind();
1004
991
      field=0;
1005
992
      while ((sql_field=it++) && ++proto_field_nr &&
1006
993
             my_strcasecmp(system_charset_info,
1007
994
                           column->field_name.str,
1008
995
                           sql_field->field_name))
1009
 
      {
1010
996
        field++;
1011
 
      }
1012
 
 
1013
997
      if (!sql_field)
1014
998
      {
1015
999
        my_error(ER_KEY_COLUMN_DOES_NOT_EXITS, MYF(0), column->field_name.str);
1016
1000
        return(true);
1017
1001
      }
1018
 
 
1019
1002
      while ((dup_column= cols2++) != column)
1020
1003
      {
1021
1004
        if (!my_strcasecmp(system_charset_info,
1027
1010
          return(true);
1028
1011
        }
1029
1012
      }
1030
 
      cols2= key->columns.begin();
 
1013
      cols2.rewind();
1031
1014
 
1032
1015
      if (create_proto.field_size() > 0)
1033
1016
        protofield= create_proto.mutable_field(proto_field_nr - 1);
1048
1031
            return true;
1049
1032
          }
1050
1033
        }
1051
 
 
1052
1034
        if (! (sql_field->flags & NOT_NULL_FLAG))
1053
1035
        {
1054
1036
          if (key->type == Key::PRIMARY)
1061
1043
            {
1062
1044
              message::Table::Field::FieldConstraints *constraints;
1063
1045
              constraints= protofield->mutable_constraints();
1064
 
              constraints->set_is_notnull(true);
 
1046
              constraints->set_is_nullable(false);
1065
1047
            }
1066
1048
 
1067
1049
          }
1075
1057
            }
1076
1058
          }
1077
1059
        }
1078
 
 
1079
1060
        if (MTYP_TYPENR(sql_field->unireg_check) == Field::NEXT_NUMBER)
1080
1061
        {
1081
1062
          if (column_nr == 0 || (engine->check_flag(HTON_BIT_AUTO_PART_KEY)))
1200
1181
        key_info->name=(char*) key_name;
1201
1182
      }
1202
1183
    }
1203
 
 
1204
1184
    if (!key_info->name || check_column_name(key_info->name))
1205
1185
    {
1206
1186
      my_error(ER_WRONG_NAME_FOR_INDEX, MYF(0), key_info->name);
1207
1187
      return(true);
1208
1188
    }
1209
 
 
1210
1189
    if (!(key_info->flags & HA_NULL_PART_KEY))
1211
 
    {
1212
1190
      unique_key=1;
1213
 
    }
1214
 
 
1215
1191
    key_info->key_length=(uint16_t) key_length;
1216
 
 
1217
1192
    if (key_length > max_key_length)
1218
1193
    {
1219
1194
      my_error(ER_TOO_LONG_KEY,MYF(0),max_key_length);
1220
1195
      return(true);
1221
1196
    }
1222
 
 
1223
1197
    key_info++;
1224
1198
  }
1225
 
 
1226
1199
  if (!unique_key && !primary_key &&
1227
1200
      (engine->check_flag(HTON_BIT_REQUIRE_PRIMARY_KEY)))
1228
1201
  {
1229
1202
    my_message(ER_REQUIRES_PRIMARY_KEY, ER(ER_REQUIRES_PRIMARY_KEY), MYF(0));
1230
1203
    return(true);
1231
1204
  }
1232
 
 
1233
1205
  if (auto_increment > 0)
1234
1206
  {
1235
1207
    my_message(ER_WRONG_AUTO_KEY, ER(ER_WRONG_AUTO_KEY), MYF(0));
1240
1212
                     (qsort_cmp) sort_keys);
1241
1213
 
1242
1214
  /* Check fields. */
1243
 
  it= alter_info->create_list.begin();
 
1215
  it.rewind();
1244
1216
  while ((sql_field=it++))
1245
1217
  {
1246
1218
    Field::utype type= (Field::utype) MTYP_TYPENR(sql_field->unireg_check);
1247
1219
 
1248
1220
    if (session->variables.sql_mode & MODE_NO_ZERO_DATE &&
1249
1221
        !sql_field->def &&
1250
 
        (sql_field->sql_type == DRIZZLE_TYPE_TIMESTAMP  or sql_field->sql_type == DRIZZLE_TYPE_MICROTIME) &&
 
1222
        sql_field->sql_type == DRIZZLE_TYPE_TIMESTAMP &&
1251
1223
        (sql_field->flags & NOT_NULL_FLAG) &&
1252
1224
        (type == Field::NONE || type == Field::TIMESTAMP_UN_FIELD))
1253
1225
    {
1311
1283
}
1312
1284
 
1313
1285
static bool locked_create_event(Session *session,
1314
 
                                const identifier::Table &identifier,
 
1286
                                TableIdentifier &identifier,
1315
1287
                                HA_CREATE_INFO *create_info,
1316
1288
                                message::Table &table_proto,
1317
1289
                                AlterInfo *alter_info,
1346
1318
        return error;
1347
1319
      }
1348
1320
 
1349
 
      my_error(ER_TABLE_EXISTS_ERROR, identifier);
1350
 
 
 
1321
      my_error(ER_TABLE_EXISTS_ERROR, MYF(0), identifier.getSQLPath().c_str());
1351
1322
      return error;
1352
1323
    }
1353
1324
 
1364
1335
      /*
1365
1336
        @todo improve this error condition.
1366
1337
      */
1367
 
      if (definition::Cache::singleton().find(identifier.getKey()))
 
1338
      if (TableShare::getShare(identifier))
1368
1339
      {
1369
 
        my_error(ER_TABLE_EXISTS_ERROR, identifier);
1370
 
 
 
1340
        my_error(ER_TABLE_EXISTS_ERROR, MYF(0), identifier.getSQLPath().c_str());
1371
1341
        return error;
1372
1342
      }
1373
1343
    }
1405
1375
  if (table_proto.type() == message::Table::STANDARD && not internal_tmp_table)
1406
1376
  {
1407
1377
    TransactionServices &transaction_services= TransactionServices::singleton();
1408
 
    transaction_services.createTable(*session, table_proto);
 
1378
    transaction_services.createTable(session, table_proto);
1409
1379
  }
1410
1380
 
1411
1381
  return false;
1418
1388
  Create a table
1419
1389
 
1420
1390
  SYNOPSIS
1421
 
    create_table_no_lock()
 
1391
    mysql_create_table_no_lock()
1422
1392
    session                     Thread object
1423
1393
    db                  Database
1424
1394
    table_name          Table name
1434
1404
 
1435
1405
    Note that this function assumes that caller already have taken
1436
1406
    name-lock on table being created or used some other way to ensure
1437
 
    that concurrent operations won't intervene. create_table()
 
1407
    that concurrent operations won't intervene. mysql_create_table()
1438
1408
    is a wrapper that can be used for this.
1439
1409
 
1440
1410
  RETURN VALUES
1442
1412
    true  error
1443
1413
*/
1444
1414
 
1445
 
bool create_table_no_lock(Session *session,
1446
 
                                const identifier::Table &identifier,
 
1415
bool mysql_create_table_no_lock(Session *session,
 
1416
                                TableIdentifier &identifier,
1447
1417
                                HA_CREATE_INFO *create_info,
1448
1418
                                message::Table &table_proto,
1449
1419
                                AlterInfo *alter_info,
1468
1438
  set_table_default_charset(create_info, identifier.getSchemaName().c_str());
1469
1439
 
1470
1440
  /* Build a Table object to pass down to the engine, and the do the actual create. */
1471
 
  if (not prepare_create_table(session, create_info, table_proto, alter_info,
1472
 
                               internal_tmp_table,
1473
 
                               &db_options,
1474
 
                               &key_info_buffer, &key_count,
1475
 
                               select_field_count))
 
1441
  if (not mysql_prepare_create_table(session, create_info, table_proto, alter_info,
 
1442
                                     internal_tmp_table,
 
1443
                                     &db_options,
 
1444
                                     &key_info_buffer, &key_count,
 
1445
                                     select_field_count))
1476
1446
  {
1477
 
    boost_unique_lock_t lock(table::Cache::singleton().mutex()); /* CREATE TABLE (some confussion on naming, double check) */
 
1447
    boost_unique_lock_t lock(LOCK_open); /* CREATE TABLE (some confussion on naming, double check) */
1478
1448
    error= locked_create_event(session,
1479
1449
                               identifier,
1480
1450
                               create_info,
1495
1465
  @note the following two methods implement create [temporary] table.
1496
1466
*/
1497
1467
static bool drizzle_create_table(Session *session,
1498
 
                                 const identifier::Table &identifier,
 
1468
                                 TableIdentifier &identifier,
1499
1469
                                 HA_CREATE_INFO *create_info,
1500
1470
                                 message::Table &table_proto,
1501
1471
                                 AlterInfo *alter_info,
1522
1492
    }
1523
1493
    else
1524
1494
    {
1525
 
      my_error(ER_TABLE_EXISTS_ERROR, identifier);
 
1495
      my_error(ER_TABLE_EXISTS_ERROR, MYF(0), identifier.getSQLPath().c_str());
1526
1496
      result= true;
1527
1497
    }
1528
1498
  }
1529
1499
  else
1530
1500
  {
1531
 
    result= create_table_no_lock(session,
 
1501
    result= mysql_create_table_no_lock(session,
1532
1502
                                       identifier,
1533
1503
                                       create_info,
1534
1504
                                       table_proto,
1540
1510
 
1541
1511
  if (name_lock)
1542
1512
  {
1543
 
    boost_unique_lock_t lock(table::Cache::singleton().mutex()); /* Lock for removing name_lock during table create */
 
1513
    boost_unique_lock_t lock(LOCK_open); /* Lock for removing name_lock during table create */
1544
1514
    session->unlink_open_table(name_lock);
1545
1515
  }
1546
1516
 
1549
1519
 
1550
1520
 
1551
1521
/*
1552
 
  Database locking aware wrapper for create_table_no_lock(),
 
1522
  Database locking aware wrapper for mysql_create_table_no_lock(),
1553
1523
*/
1554
 
bool create_table(Session *session,
1555
 
                        const identifier::Table &identifier,
 
1524
bool mysql_create_table(Session *session,
 
1525
                        TableIdentifier &identifier,
1556
1526
                        HA_CREATE_INFO *create_info,
1557
1527
                        message::Table &table_proto,
1558
1528
                        AlterInfo *alter_info,
1562
1532
{
1563
1533
  if (identifier.isTmp())
1564
1534
  {
1565
 
    return create_table_no_lock(session,
 
1535
    return mysql_create_table_no_lock(session,
1566
1536
                                      identifier,
1567
1537
                                      create_info,
1568
1538
                                      table_proto,
1632
1602
  Rename a table.
1633
1603
 
1634
1604
  SYNOPSIS
1635
 
    rename_table()
 
1605
    mysql_rename_table()
1636
1606
      session
1637
1607
      base                      The plugin::StorageEngine handle.
1638
1608
      old_db                    The old database name.
1646
1616
*/
1647
1617
 
1648
1618
bool
1649
 
rename_table(Session &session,
 
1619
mysql_rename_table(Session &session,
1650
1620
                   plugin::StorageEngine *base,
1651
 
                   const identifier::Table &from,
1652
 
                   const identifier::Table &to)
 
1621
                   TableIdentifier &from,
 
1622
                   TableIdentifier &to)
1653
1623
{
1654
1624
  int error= 0;
1655
1625
 
1669
1639
  }
1670
1640
  else if (error)
1671
1641
  {
1672
 
    std::string from_path;
1673
 
    std::string to_path;
1674
 
 
1675
 
    from.getSQLPath(from_path);
1676
 
    to.getSQLPath(to_path);
1677
 
 
1678
 
    const char *from_identifier= from.isTmp() ? "#sql-temporary" : from_path.c_str();
1679
 
    const char *to_identifier= to.isTmp() ? "#sql-temporary" : to_path.c_str();
 
1642
    const char *from_identifier= from.isTmp() ? "#sql-temporary" : from.getSQLPath().c_str();
 
1643
    const char *to_identifier= to.isTmp() ? "#sql-temporary" : to.getSQLPath().c_str();
1680
1644
 
1681
1645
    my_error(ER_ERROR_ON_RENAME, MYF(0), from_identifier, to_identifier, error);
1682
1646
  }
1700
1664
   the table is closed.
1701
1665
 
1702
1666
  PREREQUISITES
1703
 
    Lock on table::Cache::singleton().mutex()
 
1667
    Lock on LOCK_open
1704
1668
    Win32 clients must also have a WRITE LOCK on the table !
1705
1669
*/
1706
1670
 
1708
1672
                              enum ha_extra_function function)
1709
1673
{
1710
1674
 
1711
 
  safe_mutex_assert_owner(table::Cache::singleton().mutex().native_handle());
 
1675
  safe_mutex_assert_owner(LOCK_open.native_handle());
1712
1676
 
1713
1677
  table->cursor->extra(function);
1714
1678
  /* Mark all tables that are in use as 'old' */
1715
1679
  session->abortLock(table);    /* end threads waiting on lock */
1716
1680
 
1717
1681
  /* Wait until all there are no other threads that has this table open */
1718
 
  identifier::Table identifier(table->getShare()->getSchemaName(), table->getShare()->getTableName());
 
1682
  TableIdentifier identifier(table->getShare()->getSchemaName(), table->getShare()->getTableName());
1719
1683
  table::Cache::singleton().removeTable(session, identifier, RTFC_WAIT_OTHER_THREAD_FLAG);
1720
1684
}
1721
1685
 
1732
1696
    reopen the table.
1733
1697
 
1734
1698
  PREREQUISITES
1735
 
    Lock on table::Cache::singleton().mutex()
 
1699
    Lock on LOCK_open
1736
1700
    Win32 clients must also have a WRITE LOCK on the table !
1737
1701
*/
1738
1702
 
1749
1713
  /* Close all copies of 'table'.  This also frees all LOCK TABLES lock */
1750
1714
  unlink_open_table(table);
1751
1715
 
1752
 
  /* When lock on table::Cache::singleton().mutex() is freed other threads can continue */
 
1716
  /* When lock on LOCK_open is freed other threads can continue */
1753
1717
  locking::broadcast_refresh();
1754
1718
}
1755
1719
 
1759
1723
    true  Message should be sent by caller
1760
1724
          (admin operation or network communication failed)
1761
1725
*/
1762
 
static bool admin_table(Session* session, TableList* tables,
 
1726
static bool mysql_admin_table(Session* session, TableList* tables,
1763
1727
                              HA_CHECK_OPT* check_opt,
1764
1728
                              const char *operator_name,
1765
1729
                              thr_lock_type lock_type,
1768
1732
                                                            HA_CHECK_OPT *))
1769
1733
{
1770
1734
  TableList *table;
1771
 
  Select_Lex *select= &session->getLex()->select_lex;
 
1735
  Select_Lex *select= &session->lex->select_lex;
1772
1736
  List<Item> field_list;
1773
1737
  Item *item;
 
1738
  LEX *lex= session->lex;
1774
1739
  int result_code= 0;
1775
1740
  TransactionServices &transaction_services= TransactionServices::singleton();
1776
1741
  const CHARSET_INFO * const cs= system_charset_info;
1777
1742
 
1778
1743
  if (! session->endActiveTransaction())
1779
1744
    return 1;
1780
 
 
1781
1745
  field_list.push_back(item = new Item_empty_string("Table",
1782
1746
                                                    NAME_CHAR_LEN * 2,
1783
1747
                                                    cs));
1788
1752
  item->maybe_null = 1;
1789
1753
  field_list.push_back(item = new Item_empty_string("Msg_text", 255, cs));
1790
1754
  item->maybe_null = 1;
1791
 
  if (session->getClient()->sendFields(&field_list))
 
1755
  if (session->client->sendFields(&field_list))
1792
1756
    return true;
1793
1757
 
1794
1758
  for (table= tables; table; table= table->next_local)
1795
1759
  {
1796
 
    identifier::Table table_identifier(table->getSchemaName(), table->getTableName());
1797
 
    std::string table_name;
 
1760
    char table_name[NAME_LEN*2+2];
1798
1761
    bool fatal_error=0;
1799
1762
 
1800
 
    table_identifier.getSQLPath(table_name);
1801
 
 
 
1763
    snprintf(table_name, sizeof(table_name), "%s.%s", table->getSchemaName(), table->getTableName());
1802
1764
    table->lock_type= lock_type;
1803
1765
    /* open only one table from local list of command */
1804
1766
    {
1813
1775
        so it have to be prepared.
1814
1776
        @todo Investigate if we can put extra tables into argument instead of using lex->query_tables
1815
1777
      */
1816
 
      session->getLex()->query_tables= table;
1817
 
      session->getLex()->query_tables_last= &table->next_global;
1818
 
      session->getLex()->query_tables_own_last= 0;
 
1778
      lex->query_tables= table;
 
1779
      lex->query_tables_last= &table->next_global;
 
1780
      lex->query_tables_own_last= 0;
1819
1781
      session->no_warnings_for_error= 0;
1820
1782
 
1821
1783
      session->openTablesLock(table);
1845
1807
    {
1846
1808
      char buff[FN_REFLEN + DRIZZLE_ERRMSG_SIZE];
1847
1809
      uint32_t length;
1848
 
      session->getClient()->store(table_name.c_str());
1849
 
      session->getClient()->store(operator_name);
1850
 
      session->getClient()->store(STRING_WITH_LEN("error"));
 
1810
      session->client->store(table_name);
 
1811
      session->client->store(operator_name);
 
1812
      session->client->store(STRING_WITH_LEN("error"));
1851
1813
      length= snprintf(buff, sizeof(buff), ER(ER_OPEN_AS_READONLY),
1852
 
                       table_name.c_str());
1853
 
      session->getClient()->store(buff, length);
1854
 
      transaction_services.autocommitOrRollback(*session, false);
 
1814
                       table_name);
 
1815
      session->client->store(buff, length);
 
1816
      transaction_services.autocommitOrRollback(session, false);
1855
1817
      session->endTransaction(COMMIT);
1856
1818
      session->close_thread_tables();
1857
 
      session->getLex()->reset_query_tables_list(false);
 
1819
      lex->reset_query_tables_list(false);
1858
1820
      table->table=0;                           // For query cache
1859
 
      if (session->getClient()->flush())
 
1821
      if (session->client->flush())
1860
1822
        goto err;
1861
1823
      continue;
1862
1824
    }
1864
1826
    /* Close all instances of the table to allow repair to rename files */
1865
1827
    if (lock_type == TL_WRITE && table->table->getShare()->getVersion())
1866
1828
    {
1867
 
      table::Cache::singleton().mutex().lock(); /* Lock type is TL_WRITE and we lock to repair the table */
1868
 
      const char *old_message=session->enter_cond(COND_refresh, table::Cache::singleton().mutex(),
 
1829
      LOCK_open.lock(); /* Lock type is TL_WRITE and we lock to repair the table */
 
1830
      const char *old_message=session->enter_cond(COND_refresh, LOCK_open,
1869
1831
                                                  "Waiting to get writelock");
1870
1832
      session->abortLock(table->table);
1871
 
      identifier::Table identifier(table->table->getShare()->getSchemaName(), table->table->getShare()->getTableName());
 
1833
      TableIdentifier identifier(table->table->getShare()->getSchemaName(), table->table->getShare()->getTableName());
1872
1834
      table::Cache::singleton().removeTable(session, identifier, RTFC_WAIT_OTHER_THREAD_FLAG | RTFC_CHECK_KILLED_FLAG);
1873
1835
      session->exit_cond(old_message);
1874
1836
      if (session->getKilled())
1880
1842
 
1881
1843
send_result:
1882
1844
 
1883
 
    session->getLex()->cleanup_after_one_table_open();
 
1845
    lex->cleanup_after_one_table_open();
1884
1846
    session->clear_error();  // these errors shouldn't get client
1885
1847
    {
1886
 
      List<DRIZZLE_ERROR>::iterator it(session->warn_list.begin());
 
1848
      List_iterator_fast<DRIZZLE_ERROR> it(session->warn_list);
1887
1849
      DRIZZLE_ERROR *err;
1888
1850
      while ((err= it++))
1889
1851
      {
1890
 
        session->getClient()->store(table_name.c_str());
1891
 
        session->getClient()->store(operator_name);
1892
 
        session->getClient()->store(warning_level_names[err->level].str,
 
1852
        session->client->store(table_name);
 
1853
        session->client->store(operator_name);
 
1854
        session->client->store(warning_level_names[err->level].str,
1893
1855
                               warning_level_names[err->level].length);
1894
 
        session->getClient()->store(err->msg);
1895
 
        if (session->getClient()->flush())
 
1856
        session->client->store(err->msg);
 
1857
        if (session->client->flush())
1896
1858
          goto err;
1897
1859
      }
1898
1860
      drizzle_reset_errors(session, true);
1899
1861
    }
1900
 
    session->getClient()->store(table_name.c_str());
1901
 
    session->getClient()->store(operator_name);
 
1862
    session->client->store(table_name);
 
1863
    session->client->store(operator_name);
1902
1864
 
1903
1865
    switch (result_code) {
1904
1866
    case HA_ADMIN_NOT_IMPLEMENTED:
1906
1868
        char buf[ERRMSGSIZE+20];
1907
1869
        uint32_t length=snprintf(buf, ERRMSGSIZE,
1908
1870
                             ER(ER_CHECK_NOT_IMPLEMENTED), operator_name);
1909
 
        session->getClient()->store(STRING_WITH_LEN("note"));
1910
 
        session->getClient()->store(buf, length);
 
1871
        session->client->store(STRING_WITH_LEN("note"));
 
1872
        session->client->store(buf, length);
1911
1873
      }
1912
1874
      break;
1913
1875
 
1914
1876
    case HA_ADMIN_OK:
1915
 
      session->getClient()->store(STRING_WITH_LEN("status"));
1916
 
      session->getClient()->store(STRING_WITH_LEN("OK"));
 
1877
      session->client->store(STRING_WITH_LEN("status"));
 
1878
      session->client->store(STRING_WITH_LEN("OK"));
1917
1879
      break;
1918
1880
 
1919
1881
    case HA_ADMIN_FAILED:
1920
 
      session->getClient()->store(STRING_WITH_LEN("status"));
1921
 
      session->getClient()->store(STRING_WITH_LEN("Operation failed"));
 
1882
      session->client->store(STRING_WITH_LEN("status"));
 
1883
      session->client->store(STRING_WITH_LEN("Operation failed"));
1922
1884
      break;
1923
1885
 
1924
1886
    case HA_ADMIN_REJECT:
1925
 
      session->getClient()->store(STRING_WITH_LEN("status"));
1926
 
      session->getClient()->store(STRING_WITH_LEN("Operation need committed state"));
 
1887
      session->client->store(STRING_WITH_LEN("status"));
 
1888
      session->client->store(STRING_WITH_LEN("Operation need committed state"));
1927
1889
      open_for_modify= false;
1928
1890
      break;
1929
1891
 
1930
1892
    case HA_ADMIN_ALREADY_DONE:
1931
 
      session->getClient()->store(STRING_WITH_LEN("status"));
1932
 
      session->getClient()->store(STRING_WITH_LEN("Table is already up to date"));
 
1893
      session->client->store(STRING_WITH_LEN("status"));
 
1894
      session->client->store(STRING_WITH_LEN("Table is already up to date"));
1933
1895
      break;
1934
1896
 
1935
1897
    case HA_ADMIN_CORRUPT:
1936
 
      session->getClient()->store(STRING_WITH_LEN("error"));
1937
 
      session->getClient()->store(STRING_WITH_LEN("Corrupt"));
 
1898
      session->client->store(STRING_WITH_LEN("error"));
 
1899
      session->client->store(STRING_WITH_LEN("Corrupt"));
1938
1900
      fatal_error=1;
1939
1901
      break;
1940
1902
 
1941
1903
    case HA_ADMIN_INVALID:
1942
 
      session->getClient()->store(STRING_WITH_LEN("error"));
1943
 
      session->getClient()->store(STRING_WITH_LEN("Invalid argument"));
 
1904
      session->client->store(STRING_WITH_LEN("error"));
 
1905
      session->client->store(STRING_WITH_LEN("Invalid argument"));
1944
1906
      break;
1945
1907
 
1946
1908
    default:                            // Probably HA_ADMIN_INTERNAL_ERROR
1949
1911
        uint32_t length=snprintf(buf, ERRMSGSIZE,
1950
1912
                             _("Unknown - internal error %d during operation"),
1951
1913
                             result_code);
1952
 
        session->getClient()->store(STRING_WITH_LEN("error"));
1953
 
        session->getClient()->store(buf, length);
 
1914
        session->client->store(STRING_WITH_LEN("error"));
 
1915
        session->client->store(buf, length);
1954
1916
        fatal_error=1;
1955
1917
        break;
1956
1918
      }
1969
1931
        }
1970
1932
        else
1971
1933
        {
1972
 
          boost::unique_lock<boost::mutex> lock(table::Cache::singleton().mutex());
1973
 
          identifier::Table identifier(table->table->getShare()->getSchemaName(), table->table->getShare()->getTableName());
 
1934
          boost::unique_lock<boost::mutex> lock(LOCK_open);
 
1935
          TableIdentifier identifier(table->table->getShare()->getSchemaName(), table->table->getShare()->getTableName());
1974
1936
          table::Cache::singleton().removeTable(session, identifier, RTFC_NO_FLAG);
1975
1937
        }
1976
1938
      }
1977
1939
    }
1978
 
    transaction_services.autocommitOrRollback(*session, false);
 
1940
    transaction_services.autocommitOrRollback(session, false);
1979
1941
    session->endTransaction(COMMIT);
1980
1942
    session->close_thread_tables();
1981
1943
    table->table=0;                             // For query cache
1982
 
    if (session->getClient()->flush())
 
1944
    if (session->client->flush())
1983
1945
      goto err;
1984
1946
  }
1985
1947
 
1987
1949
  return(false);
1988
1950
 
1989
1951
err:
1990
 
  transaction_services.autocommitOrRollback(*session, true);
 
1952
  transaction_services.autocommitOrRollback(session, true);
1991
1953
  session->endTransaction(ROLLBACK);
1992
1954
  session->close_thread_tables();                       // Shouldn't be needed
1993
1955
  if (table)
2001
1963
    Altough exclusive name-lock on target table protects us from concurrent
2002
1964
    DML and DDL operations on it we still want to wrap .FRM creation and call
2003
1965
    to plugin::StorageEngine::createTable() in critical section protected by
2004
 
    table::Cache::singleton().mutex() in order to provide minimal atomicity against operations which
 
1966
    LOCK_open in order to provide minimal atomicity against operations which
2005
1967
    disregard name-locks, like I_S implementation, for example. This is a
2006
1968
    temporary and should not be copied. Instead we should fix our code to
2007
1969
    always honor name-locks.
2008
1970
 
2009
 
    Also some engines (e.g. NDB cluster) require that table::Cache::singleton().mutex() should be held
 
1971
    Also some engines (e.g. NDB cluster) require that LOCK_open should be held
2010
1972
    during the call to plugin::StorageEngine::createTable().
2011
1973
    See bug #28614 for more info.
2012
1974
  */
2013
 
static bool create_table_wrapper(Session &session,
2014
 
                                 const message::Table& create_table_proto,
2015
 
                                 identifier::Table::const_reference destination_identifier,
2016
 
                                 identifier::Table::const_reference source_identifier,
 
1975
static bool create_table_wrapper(Session &session, const message::Table& create_table_proto,
 
1976
                                 TableIdentifier &destination_identifier,
 
1977
                                 TableIdentifier &src_table,
2017
1978
                                 bool is_engine_set)
2018
1979
{
2019
 
  // We require an additional table message because during parsing we used
2020
 
  // a "new" message and it will not have all of the information that the
2021
 
  // source table message would have.
2022
 
  message::Table new_table_message;
2023
 
 
2024
 
  message::table::shared_ptr source_table_message= plugin::StorageEngine::getTableMessage(session, source_identifier);
2025
 
 
2026
 
  if (not source_table_message)
2027
 
  {
2028
 
    my_error(ER_TABLE_UNKNOWN, source_identifier);
2029
 
    return false;
2030
 
  }
2031
 
 
2032
 
  new_table_message.CopyFrom(*source_table_message);
 
1980
  int protoerr= EEXIST;
 
1981
  message::Table new_proto;
 
1982
  message::TablePtr src_proto;
 
1983
 
 
1984
  protoerr= plugin::StorageEngine::getTableDefinition(session,
 
1985
                                                      src_table,
 
1986
                                                      src_proto);
 
1987
  new_proto.CopyFrom(*src_proto);
2033
1988
 
2034
1989
  if (destination_identifier.isTmp())
2035
1990
  {
2036
 
    new_table_message.set_type(message::Table::TEMPORARY);
 
1991
    new_proto.set_type(message::Table::TEMPORARY);
2037
1992
  }
2038
1993
  else
2039
1994
  {
2040
 
    new_table_message.set_type(message::Table::STANDARD);
 
1995
    new_proto.set_type(message::Table::STANDARD);
2041
1996
  }
2042
1997
 
2043
1998
  if (is_engine_set)
2044
1999
  {
2045
 
    new_table_message.mutable_engine()->set_name(create_table_proto.engine().name());
 
2000
    new_proto.mutable_engine()->set_name(create_table_proto.engine().name());
2046
2001
  }
2047
2002
 
2048
2003
  { // We now do a selective copy of elements on to the new table.
2049
 
    new_table_message.set_name(create_table_proto.name());
2050
 
    new_table_message.set_schema(create_table_proto.schema());
2051
 
    new_table_message.set_catalog(create_table_proto.catalog());
 
2004
    new_proto.set_name(create_table_proto.name());
 
2005
    new_proto.set_schema(create_table_proto.schema());
 
2006
    new_proto.set_catalog(create_table_proto.catalog());
2052
2007
  }
2053
2008
 
2054
 
  /* Fix names of foreign keys being added */
2055
 
  for (int32_t j= 0; j < new_table_message.fk_constraint_size(); j++)
 
2009
  if (protoerr && protoerr != EEXIST)
2056
2010
  {
2057
 
    if (new_table_message.fk_constraint(j).has_name())
2058
 
    {
2059
 
      std::string name(new_table_message.name());
2060
 
      char number[20];
2061
 
 
2062
 
      name.append("_ibfk_");
2063
 
      snprintf(number, sizeof(number), "%d", j+1);
2064
 
      name.append(number);
2065
 
 
2066
 
      message::Table::ForeignKeyConstraint *pfkey= new_table_message.mutable_fk_constraint(j);
2067
 
      pfkey->set_name(name);
2068
 
    }
 
2011
    if (errno == ENOENT)
 
2012
      my_error(ER_BAD_DB_ERROR,MYF(0), destination_identifier.getSchemaName().c_str());
 
2013
    else
 
2014
      my_error(ER_CANT_CREATE_FILE, MYF(0), destination_identifier.getPath().c_str(), errno);
 
2015
 
 
2016
    return false;
2069
2017
  }
2070
2018
 
2071
2019
  /*
2072
2020
    As mysql_truncate don't work on a new table at this stage of
2073
 
    creation, instead create the table directly (for both normal and temporary tables).
 
2021
    creation, instead create the table directly (for both normal
 
2022
    and temporary tables).
2074
2023
  */
2075
 
  bool success= plugin::StorageEngine::createTable(session,
2076
 
                                                   destination_identifier,
2077
 
                                                   new_table_message);
 
2024
  int err= plugin::StorageEngine::createTable(session,
 
2025
                                              destination_identifier,
 
2026
                                              new_proto);
2078
2027
 
2079
 
  if (success && not destination_identifier.isTmp())
 
2028
  if (err == false && not destination_identifier.isTmp())
2080
2029
  {
2081
2030
    TransactionServices &transaction_services= TransactionServices::singleton();
2082
 
    transaction_services.createTable(session, new_table_message);
 
2031
    transaction_services.createTable(&session, new_proto);
2083
2032
  }
2084
2033
 
2085
 
  return success;
 
2034
  return err ? false : true;
2086
2035
}
2087
2036
 
2088
2037
/*
2089
2038
  Create a table identical to the specified table
2090
2039
 
2091
2040
  SYNOPSIS
2092
 
    create_like_table()
 
2041
    mysql_create_like_table()
2093
2042
    session             Thread object
2094
2043
    table       Table list element for target table
2095
2044
    src_table   Table list element for source table
2100
2049
    true  error
2101
2050
*/
2102
2051
 
2103
 
bool create_like_table(Session* session,
2104
 
                       identifier::Table::const_reference destination_identifier,
2105
 
                       identifier::Table::const_reference source_identifier,
2106
 
                       message::Table &create_table_proto,
2107
 
                       bool is_if_not_exists,
2108
 
                       bool is_engine_set)
 
2052
bool mysql_create_like_table(Session* session,
 
2053
                             TableIdentifier &destination_identifier,
 
2054
                             TableList* table, TableList* src_table,
 
2055
                             message::Table &create_table_proto,
 
2056
                             bool is_if_not_exists,
 
2057
                             bool is_engine_set)
2109
2058
{
2110
2059
  bool res= true;
2111
 
  bool table_exists= false;
 
2060
  uint32_t not_used;
 
2061
 
 
2062
  /*
 
2063
    By opening source table we guarantee that it exists and no concurrent
 
2064
    DDL operation will mess with it. Later we also take an exclusive
 
2065
    name-lock on target table name, which makes copying of .frm cursor,
 
2066
    call to plugin::StorageEngine::createTable() and binlogging atomic
 
2067
    against concurrent DML and DDL operations on target table.
 
2068
    Thus by holding both these "locks" we ensure that our statement is
 
2069
    properly isolated from all concurrent operations which matter.
 
2070
  */
 
2071
  if (session->open_tables_from_list(&src_table, &not_used))
 
2072
    return true;
 
2073
 
 
2074
  TableIdentifier src_identifier(src_table->table->getShare()->getSchemaName(),
 
2075
                                 src_table->table->getShare()->getTableName(), src_table->table->getShare()->getType());
 
2076
 
 
2077
 
2112
2078
 
2113
2079
  /*
2114
2080
    Check that destination tables does not exist. Note that its name
2116
2082
 
2117
2083
    For temporary tables we don't aim to grab locks.
2118
2084
  */
 
2085
  bool table_exists= false;
2119
2086
  if (destination_identifier.isTmp())
2120
2087
  {
2121
2088
    if (session->find_temporary_table(destination_identifier))
2124
2091
    }
2125
2092
    else
2126
2093
    {
2127
 
      bool was_created= create_table_wrapper(*session,
2128
 
                                             create_table_proto,
2129
 
                                             destination_identifier,
2130
 
                                             source_identifier,
2131
 
                                             is_engine_set);
 
2094
      bool was_created= create_table_wrapper(*session, create_table_proto, destination_identifier,
 
2095
                                             src_identifier, is_engine_set);
2132
2096
      if (not was_created) // This is pretty paranoid, but we assume something might not clean up after itself
2133
2097
      {
2134
2098
        (void) session->rm_temporary_table(destination_identifier, true);
2152
2116
    {
2153
2117
      if (name_lock)
2154
2118
      {
2155
 
        boost_unique_lock_t lock(table::Cache::singleton().mutex()); /* unlink open tables for create table like*/
 
2119
        boost_unique_lock_t lock(LOCK_open); /* unlink open tables for create table like*/
2156
2120
        session->unlink_open_table(name_lock);
2157
2121
      }
2158
2122
 
2171
2135
    {
2172
2136
      bool was_created;
2173
2137
      {
2174
 
        boost_unique_lock_t lock(table::Cache::singleton().mutex()); /* We lock for CREATE TABLE LIKE to copy table definition */
 
2138
        boost_unique_lock_t lock(LOCK_open); /* We lock for CREATE TABLE LIKE to copy table definition */
2175
2139
        was_created= create_table_wrapper(*session, create_table_proto, destination_identifier,
2176
 
                                          source_identifier, is_engine_set);
 
2140
                                               src_identifier, is_engine_set);
2177
2141
      }
2178
2142
 
2179
2143
      // So we blew the creation of the table, and we scramble to clean up
2180
2144
      // anything that might have been created (read... it is a hack)
2181
2145
      if (not was_created)
2182
2146
      {
2183
 
        plugin::StorageEngine::dropTable(*session, destination_identifier);
 
2147
        quick_rm_table(*session, destination_identifier);
2184
2148
      } 
2185
2149
      else
2186
2150
      {
2190
2154
 
2191
2155
    if (name_lock)
2192
2156
    {
2193
 
      boost_unique_lock_t lock(table::Cache::singleton().mutex()); /* unlink open tables for create table like*/
 
2157
      boost_unique_lock_t lock(LOCK_open); /* unlink open tables for create table like*/
2194
2158
      session->unlink_open_table(name_lock);
2195
2159
    }
2196
2160
  }
2201
2165
    {
2202
2166
      char warn_buff[DRIZZLE_ERRMSG_SIZE];
2203
2167
      snprintf(warn_buff, sizeof(warn_buff),
2204
 
               ER(ER_TABLE_EXISTS_ERROR), destination_identifier.getTableName().c_str());
 
2168
               ER(ER_TABLE_EXISTS_ERROR), table->getTableName());
2205
2169
      push_warning(session, DRIZZLE_ERROR::WARN_LEVEL_NOTE,
2206
 
                   ER_TABLE_EXISTS_ERROR, warn_buff);
2207
 
      return false;
2208
 
    }
2209
 
 
2210
 
    my_error(ER_TABLE_EXISTS_ERROR, destination_identifier);
2211
 
 
2212
 
    return true;
 
2170
                   ER_TABLE_EXISTS_ERROR,warn_buff);
 
2171
      res= false;
 
2172
    }
 
2173
    else
 
2174
    {
 
2175
      my_error(ER_TABLE_EXISTS_ERROR, MYF(0), table->getTableName());
 
2176
    }
2213
2177
  }
2214
2178
 
2215
 
  return res;
 
2179
  return(res);
2216
2180
}
2217
2181
 
2218
2182
 
2219
 
bool analyze_table(Session* session, TableList* tables, HA_CHECK_OPT* check_opt)
 
2183
bool mysql_analyze_table(Session* session, TableList* tables, HA_CHECK_OPT* check_opt)
2220
2184
{
2221
2185
  thr_lock_type lock_type = TL_READ_NO_INSERT;
2222
2186
 
2223
 
  return(admin_table(session, tables, check_opt,
 
2187
  return(mysql_admin_table(session, tables, check_opt,
2224
2188
                                "analyze", lock_type, true,
2225
2189
                                &Cursor::ha_analyze));
2226
2190
}
2227
2191
 
2228
2192
 
2229
 
bool check_table(Session* session, TableList* tables,HA_CHECK_OPT* check_opt)
 
2193
bool mysql_check_table(Session* session, TableList* tables,HA_CHECK_OPT* check_opt)
2230
2194
{
2231
2195
  thr_lock_type lock_type = TL_READ_NO_INSERT;
2232
2196
 
2233
 
  return(admin_table(session, tables, check_opt,
 
2197
  return(mysql_admin_table(session, tables, check_opt,
2234
2198
                                "check", lock_type,
2235
2199
                                false,
2236
2200
                                &Cursor::ha_check));