← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to drizzled/sql_table.cc

  • Committer: Paul McCullagh
  • Date: 2010-09-16 15:26:41 UTC
  • mto: (1771.3.1 trunk)
  • mto: This revision was merged to the branch mainline in revision 1785.
  • Revision ID: paul.mccullagh@primebase.org-20100916152641-9mwb1hga0qwz41nu
Merged with 1.1 trunk

Show diffs side-by-side

added added

removed removed

Lines of Context:
drizzled/sql_table.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
/* 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
  /*
 
153
    If we have the table in the definition cache, we don't have to check the
 
154
    .frm cursor to find if the table is a normal table (not view) and what
 
155
    engine to use.
 
156
  */
 
157
 
 
158
  for (table= tables; table; table= table->next_local)
 
159
  {
 
160
    TableIdentifier identifier(table->db, table->table_name);
 
161
    TableShare *share;
 
162
    table->setDbType(NULL);
 
163
 
 
164
    if ((share= TableShare::getShare(identifier)))
 
165
    {
 
166
      table->setDbType(share->db_type());
 
167
    }
 
168
  }
 
169
 
 
170
  if (not drop_temporary && lock_table_names_exclusively(session, tables))
 
171
  {
 
172
    LOCK_open.unlock();
 
173
    return 1;
 
174
  }
 
175
 
 
176
  /* Don't give warnings for not found errors, as we already generate notes */
 
177
  session->no_warnings_for_error= 1;
 
178
 
 
179
  for (table= tables; table; table= table->next_local)
 
180
  {
 
181
    char *db=table->db;
 
182
 
 
183
    error= session->drop_temporary_table(table);
 
184
 
 
185
    switch (error) {
 
186
    case  0:
 
187
      // removed temporary table
 
188
      continue;
 
189
    case -1:
 
190
      error= 1;
 
191
      goto err_with_placeholders;
 
192
    default:
 
193
      // temporary table not found
 
194
      error= 0;
 
195
    }
 
196
 
 
197
    if (drop_temporary == false)
 
198
    {
 
199
      Table *locked_table;
 
200
      TableIdentifier identifier(db, table->table_name);
 
201
      abort_locked_tables(session, identifier);
 
202
      remove_table_from_cache(session, identifier,
 
203
                              RTFC_WAIT_OTHER_THREAD_FLAG |
 
204
                              RTFC_CHECK_KILLED_FLAG);
 
205
      /*
 
206
        If the table was used in lock tables, remember it so that
 
207
        unlock_table_names can free it
 
208
      */
 
209
      if ((locked_table= drop_locked_tables(session, identifier)))
 
210
        table->table= locked_table;
 
211
 
 
212
      if (session->killed)
 
213
      {
 
214
        error= -1;
 
215
        goto err_with_placeholders;
 
216
      }
 
217
    }
 
218
    TableIdentifier identifier(db, table->table_name, table->getInternalTmpTable() ? message::Table::INTERNAL : message::Table::STANDARD);
 
219
 
 
220
    if (drop_temporary || not plugin::StorageEngine::doesTableExist(*session, identifier))
 
221
    {
 
222
      // Table was not found on disk and table can't be created from engine
 
223
      if (if_exists)
 
224
        push_warning_printf(session, DRIZZLE_ERROR::WARN_LEVEL_NOTE,
 
225
                            ER_BAD_TABLE_ERROR, ER(ER_BAD_TABLE_ERROR),
 
226
                            table->table_name);
 
227
      else
172
228
        error= 1;
173
 
        break;
174
 
      default:
175
 
        // temporary table not found
 
229
    }
 
230
    else
 
231
    {
 
232
      error= plugin::StorageEngine::dropTable(*session, identifier);
 
233
 
 
234
      if ((error == ENOENT || error == HA_ERR_NO_SUCH_TABLE) && if_exists)
 
235
      {
176
236
        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())
 
237
        session->clear_error();
 
238
      }
 
239
 
 
240
      if (error == HA_ERR_ROW_IS_REFERENCED)
 
241
      {
 
242
        /* the table is referenced by a foreign key constraint */
 
243
        foreign_key_error= true;
 
244
      }
 
245
    }
 
246
 
 
247
    if (error == 0 || (if_exists && foreign_key_error == false))
 
248
    {
 
249
      TransactionServices &transaction_services= TransactionServices::singleton();
 
250
      transaction_services.dropTable(session, string(db), string(table->table_name), if_exists);
 
251
    }
 
252
 
 
253
    if (error)
 
254
    {
 
255
      if (wrong_tables.length())
 
256
        wrong_tables.append(',');
 
257
      wrong_tables.append(String(table->table_name,system_charset_info));
 
258
    }
 
259
  }
 
260
  /*
 
261
    It's safe to unlock LOCK_open: we have an exclusive lock
 
262
    on the table name.
 
263
  */
 
264
  LOCK_open.unlock();
 
265
  error= 0;
 
266
 
 
267
  if (wrong_tables.length())
258
268
  {
259
269
    if (not foreign_key_error)
260
270
    {
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
271
      my_printf_error(ER_BAD_TABLE_ERROR, ER(ER_BAD_TABLE_ERROR), MYF(0),
273
 
                      table_error.c_str());
 
272
                      wrong_tables.c_ptr());
274
273
    }
275
274
    else
276
275
    {
279
278
    error= 1;
280
279
  }
281
280
 
 
281
  LOCK_open.lock(); /* final bit in rm table lock */
 
282
 
 
283
err_with_placeholders:
 
284
  unlock_table_names(tables, NULL);
 
285
  LOCK_open.unlock();
282
286
  session->no_warnings_for_error= 0;
283
287
 
284
288
  return error;
285
289
}
286
290
 
 
291
 
 
292
/*
 
293
  Quickly remove a table.
 
294
 
 
295
  SYNOPSIS
 
296
    quick_rm_table()
 
297
      base                      The plugin::StorageEngine handle.
 
298
      db                        The database name.
 
299
      table_name                The table name.
 
300
      is_tmp                    If the table is temp.
 
301
 
 
302
  RETURN
 
303
    0           OK
 
304
    != 0        Error
 
305
*/
 
306
bool quick_rm_table(Session& session,
 
307
                    TableIdentifier &identifier)
 
308
{
 
309
  return (plugin::StorageEngine::dropTable(session, identifier));
 
310
}
 
311
 
287
312
/*
288
313
  Sort keys in the following order:
289
314
  - PRIMARY KEY
483
508
    sql_field->length= 8; // Unireg field length
484
509
    (*blob_columns)++;
485
510
    break;
486
 
 
 
511
  case DRIZZLE_TYPE_VARCHAR:
 
512
    break;
487
513
  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:
 
514
    if (check_duplicates_in_interval("ENUM",
 
515
                                     sql_field->field_name,
 
516
                                     sql_field->interval,
 
517
                                     sql_field->charset,
 
518
                                     &dup_val_count))
 
519
      return 1;
 
520
    break;
 
521
  case DRIZZLE_TYPE_DATE:  // Rest of string types
 
522
  case DRIZZLE_TYPE_DATETIME:
 
523
  case DRIZZLE_TYPE_NULL:
 
524
    break;
 
525
  case DRIZZLE_TYPE_DECIMAL:
 
526
    break;
501
527
  case DRIZZLE_TYPE_TIMESTAMP:
502
528
    /* We should replace old TIMESTAMP fields with their newer analogs */
503
529
    if (sql_field->unireg_check == Field::TIMESTAMP_OLD_FIELD)
513
539
      }
514
540
    }
515
541
    else if (sql_field->unireg_check != Field::NONE)
516
 
    {
517
542
      (*timestamps_with_niladic)++;
518
 
    }
519
543
 
520
544
    (*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:
 
545
    /* fall-through */
 
546
  default:
535
547
    break;
536
548
  }
537
549
 
538
550
  return 0;
539
551
}
540
552
 
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)
 
553
static int mysql_prepare_create_table(Session *session,
 
554
                                      HA_CREATE_INFO *create_info,
 
555
                                      message::Table &create_proto,
 
556
                                      AlterInfo *alter_info,
 
557
                                      bool tmp_table,
 
558
                                      uint32_t *db_options,
 
559
                                      KeyInfo **key_info_buffer,
 
560
                                      uint32_t *key_count,
 
561
                                      int select_field_count)
550
562
{
551
563
  const char    *key_name;
552
564
  CreateField   *sql_field,*dup_field;
555
567
  KeyInfo               *key_info;
556
568
  KeyPartInfo *key_part_info;
557
569
  int           timestamps= 0, timestamps_with_niladic= 0;
558
 
  int           dup_no;
 
570
  int           field_no,dup_no;
559
571
  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());
 
572
  List_iterator<CreateField> it(alter_info->create_list);
 
573
  List_iterator<CreateField> it2(alter_info->create_list);
562
574
  uint32_t total_uneven_bit_length= 0;
563
575
 
564
576
  plugin::StorageEngine *engine= plugin::StorageEngine::findByName(create_proto.engine().name());
567
579
  null_fields=blob_columns=0;
568
580
  max_key_length= engine->max_key_length();
569
581
 
570
 
  for (int32_t field_no=0; (sql_field=it++) ; field_no++)
 
582
  for (field_no=0; (sql_field=it++) ; field_no++)
571
583
  {
572
584
    const CHARSET_INFO *save_cs;
573
585
 
577
589
      executing a prepared statement for the second time.
578
590
    */
579
591
    sql_field->length= sql_field->char_length;
580
 
 
581
592
    if (!sql_field->charset)
582
593
      sql_field->charset= create_info->default_table_charset;
583
 
 
584
594
    /*
585
595
      table_charset is set in ALTER Table if we want change character set
586
596
      for all varchar/char columns.
633
643
 
634
644
    if (sql_field->sql_type == DRIZZLE_TYPE_ENUM)
635
645
    {
636
 
      size_t dummy;
 
646
      uint32_t dummy;
637
647
      const CHARSET_INFO * const cs= sql_field->charset;
638
648
      TYPELIB *interval= sql_field->interval;
639
649
 
652
662
        interval= sql_field->interval= typelib(session->mem_root,
653
663
                                               sql_field->interval_list);
654
664
 
655
 
        List<String>::iterator int_it(sql_field->interval_list.begin());
 
665
        List_iterator<String> int_it(sql_field->interval_list);
656
666
        String conv, *tmp;
657
667
        char comma_buf[4];
658
668
        int comma_length= cs->cset->wc_mb(cs, ',', (unsigned char*) comma_buf,
666
676
          if (String::needs_conversion(tmp->length(), tmp->charset(),
667
677
                                       cs, &dummy))
668
678
          {
669
 
            size_t cnv_errs;
 
679
            uint32_t cnv_errs;
670
680
            conv.copy(tmp->ptr(), tmp->length(), tmp->charset(), cs, &cnv_errs);
671
681
            interval->type_names[i]= session->mem_root->strmake_root(conv.ptr(), conv.length());
672
682
            interval->type_lengths[i]= conv.length();
678
688
          interval->type_lengths[i]= lengthsp;
679
689
          ((unsigned char *)interval->type_names[i])[lengthsp]= '\0';
680
690
        }
681
 
        sql_field->interval_list.clear(); // Don't need interval_list anymore
 
691
        sql_field->interval_list.empty(); // Don't need interval_list anymore
682
692
      }
683
693
 
684
694
      /* DRIZZLE_TYPE_ENUM */
701
711
          else /* not NULL */
702
712
          {
703
713
            def->length(cs->cset->lengthsp(cs, def->ptr(), def->length()));
704
 
            if (interval->find_type2(def->ptr(), def->length(), cs) == 0) /* not found */
 
714
            if (find_type2(interval, def->ptr(), def->length(), cs) == 0) /* not found */
705
715
            {
706
716
              my_error(ER_INVALID_DEFAULT, MYF(0), sql_field->field_name);
707
717
              return(true);
708
718
            }
709
719
          }
710
720
        }
711
 
        uint32_t new_dummy;
712
 
        calculate_interval_lengths(cs, interval, &field_length, &new_dummy);
 
721
        calculate_interval_lengths(cs, interval, &field_length, &dummy);
713
722
        sql_field->length= field_length;
714
723
      }
715
724
      set_if_smaller(sql_field->length, (uint32_t)MAX_FIELD_WIDTH-1);
778
787
    if (not create_proto.engine().name().compare("MyISAM") &&
779
788
        ((sql_field->flags & BLOB_FLAG) ||
780
789
         (sql_field->sql_type == DRIZZLE_TYPE_VARCHAR)))
781
 
    {
782
790
      (*db_options)|= HA_OPTION_PACK_RECORD;
783
 
    }
784
 
 
785
 
    it2= alter_info->create_list.begin();
 
791
    it2.rewind();
786
792
  }
787
793
 
788
794
  /* record_offset will be increased with 'length-of-null-bits' later */
789
795
  record_offset= 0;
790
796
  null_fields+= total_uneven_bit_length;
791
797
 
792
 
  it= alter_info->create_list.begin();
 
798
  it.rewind();
793
799
  while ((sql_field=it++))
794
800
  {
795
801
    assert(sql_field->charset != 0);
829
835
 
830
836
  /* Create keys */
831
837
 
832
 
  List<Key>::iterator key_iterator(alter_info->key_list.begin());
833
 
  List<Key>::iterator key_iterator2(alter_info->key_list.begin());
 
838
  List_iterator<Key> key_iterator(alter_info->key_list);
 
839
  List_iterator<Key> key_iterator2(alter_info->key_list);
834
840
  uint32_t key_parts=0, fk_key_count=0;
835
841
  bool primary_key=0,unique_key=0;
836
842
  Key *key, *key2;
880
886
    }
881
887
    if (check_identifier_name(&key->name, ER_TOO_LONG_IDENT))
882
888
      return(true);
883
 
    key_iterator2= alter_info->key_list.begin();
 
889
    key_iterator2.rewind ();
884
890
    if (key->type != Key::FOREIGN_KEY)
885
891
    {
886
892
      while ((key2 = key_iterator2++) != key)
933
939
  if (!*key_info_buffer || ! key_part_info)
934
940
    return(true);                               // Out of memory
935
941
 
936
 
  key_iterator= alter_info->key_list.begin();
 
942
  key_iterator.rewind();
937
943
  key_number=0;
938
944
  for (; (key=key_iterator++) ; key_number++)
939
945
  {
992
998
 
993
999
    message::Table::Field *protofield= NULL;
994
1000
 
995
 
    List<Key_part_spec>::iterator cols(key->columns.begin());
996
 
    List<Key_part_spec>::iterator cols2(key->columns.begin());
 
1001
    List_iterator<Key_part_spec> cols(key->columns), cols2(key->columns);
997
1002
    for (uint32_t column_nr=0 ; (column=cols++) ; column_nr++)
998
1003
    {
999
1004
      uint32_t length;
1000
1005
      Key_part_spec *dup_column;
1001
1006
      int proto_field_nr= 0;
1002
1007
 
1003
 
      it= alter_info->create_list.begin();
 
1008
      it.rewind();
1004
1009
      field=0;
1005
1010
      while ((sql_field=it++) && ++proto_field_nr &&
1006
1011
             my_strcasecmp(system_charset_info,
1007
1012
                           column->field_name.str,
1008
1013
                           sql_field->field_name))
1009
 
      {
1010
1014
        field++;
1011
 
      }
1012
 
 
1013
1015
      if (!sql_field)
1014
1016
      {
1015
1017
        my_error(ER_KEY_COLUMN_DOES_NOT_EXITS, MYF(0), column->field_name.str);
1016
1018
        return(true);
1017
1019
      }
1018
 
 
1019
1020
      while ((dup_column= cols2++) != column)
1020
1021
      {
1021
1022
        if (!my_strcasecmp(system_charset_info,
1027
1028
          return(true);
1028
1029
        }
1029
1030
      }
1030
 
      cols2= key->columns.begin();
 
1031
      cols2.rewind();
1031
1032
 
1032
1033
      if (create_proto.field_size() > 0)
1033
1034
        protofield= create_proto.mutable_field(proto_field_nr - 1);
1048
1049
            return true;
1049
1050
          }
1050
1051
        }
1051
 
 
1052
1052
        if (! (sql_field->flags & NOT_NULL_FLAG))
1053
1053
        {
1054
1054
          if (key->type == Key::PRIMARY)
1061
1061
            {
1062
1062
              message::Table::Field::FieldConstraints *constraints;
1063
1063
              constraints= protofield->mutable_constraints();
1064
 
              constraints->set_is_notnull(true);
 
1064
              constraints->set_is_nullable(false);
1065
1065
            }
1066
1066
 
1067
1067
          }
1075
1075
            }
1076
1076
          }
1077
1077
        }
1078
 
 
1079
1078
        if (MTYP_TYPENR(sql_field->unireg_check) == Field::NEXT_NUMBER)
1080
1079
        {
1081
1080
          if (column_nr == 0 || (engine->check_flag(HTON_BIT_AUTO_PART_KEY)))
1200
1199
        key_info->name=(char*) key_name;
1201
1200
      }
1202
1201
    }
1203
 
 
1204
1202
    if (!key_info->name || check_column_name(key_info->name))
1205
1203
    {
1206
1204
      my_error(ER_WRONG_NAME_FOR_INDEX, MYF(0), key_info->name);
1207
1205
      return(true);
1208
1206
    }
1209
 
 
1210
1207
    if (!(key_info->flags & HA_NULL_PART_KEY))
1211
 
    {
1212
1208
      unique_key=1;
1213
 
    }
1214
 
 
1215
1209
    key_info->key_length=(uint16_t) key_length;
1216
 
 
1217
1210
    if (key_length > max_key_length)
1218
1211
    {
1219
1212
      my_error(ER_TOO_LONG_KEY,MYF(0),max_key_length);
1220
1213
      return(true);
1221
1214
    }
1222
 
 
1223
1215
    key_info++;
1224
1216
  }
1225
 
 
1226
1217
  if (!unique_key && !primary_key &&
1227
1218
      (engine->check_flag(HTON_BIT_REQUIRE_PRIMARY_KEY)))
1228
1219
  {
1229
1220
    my_message(ER_REQUIRES_PRIMARY_KEY, ER(ER_REQUIRES_PRIMARY_KEY), MYF(0));
1230
1221
    return(true);
1231
1222
  }
1232
 
 
1233
1223
  if (auto_increment > 0)
1234
1224
  {
1235
1225
    my_message(ER_WRONG_AUTO_KEY, ER(ER_WRONG_AUTO_KEY), MYF(0));
1240
1230
                     (qsort_cmp) sort_keys);
1241
1231
 
1242
1232
  /* Check fields. */
1243
 
  it= alter_info->create_list.begin();
 
1233
  it.rewind();
1244
1234
  while ((sql_field=it++))
1245
1235
  {
1246
1236
    Field::utype type= (Field::utype) MTYP_TYPENR(sql_field->unireg_check);
1247
1237
 
1248
1238
    if (session->variables.sql_mode & MODE_NO_ZERO_DATE &&
1249
1239
        !sql_field->def &&
1250
 
        (sql_field->sql_type == DRIZZLE_TYPE_TIMESTAMP  or sql_field->sql_type == DRIZZLE_TYPE_MICROTIME) &&
 
1240
        sql_field->sql_type == DRIZZLE_TYPE_TIMESTAMP &&
1251
1241
        (sql_field->flags & NOT_NULL_FLAG) &&
1252
1242
        (type == Field::NONE || type == Field::TIMESTAMP_UN_FIELD))
1253
1243
    {
1311
1301
}
1312
1302
 
1313
1303
static bool locked_create_event(Session *session,
1314
 
                                const identifier::Table &identifier,
 
1304
                                TableIdentifier &identifier,
1315
1305
                                HA_CREATE_INFO *create_info,
1316
1306
                                message::Table &table_proto,
1317
1307
                                AlterInfo *alter_info,
1346
1336
        return error;
1347
1337
      }
1348
1338
 
1349
 
      my_error(ER_TABLE_EXISTS_ERROR, identifier);
1350
 
 
 
1339
      my_error(ER_TABLE_EXISTS_ERROR, MYF(0), identifier.getSQLPath().c_str());
1351
1340
      return error;
1352
1341
    }
1353
1342
 
1364
1353
      /*
1365
1354
        @todo improve this error condition.
1366
1355
      */
1367
 
      if (definition::Cache::singleton().find(identifier.getKey()))
 
1356
      if (TableShare::getShare(identifier))
1368
1357
      {
1369
 
        my_error(ER_TABLE_EXISTS_ERROR, identifier);
1370
 
 
 
1358
        my_error(ER_TABLE_EXISTS_ERROR, MYF(0), identifier.getSQLPath().c_str());
1371
1359
        return error;
1372
1360
      }
1373
1361
    }
1405
1393
  if (table_proto.type() == message::Table::STANDARD && not internal_tmp_table)
1406
1394
  {
1407
1395
    TransactionServices &transaction_services= TransactionServices::singleton();
1408
 
    transaction_services.createTable(*session, table_proto);
 
1396
    transaction_services.createTable(session, table_proto);
1409
1397
  }
1410
1398
 
1411
1399
  return false;
1418
1406
  Create a table
1419
1407
 
1420
1408
  SYNOPSIS
1421
 
    create_table_no_lock()
 
1409
    mysql_create_table_no_lock()
1422
1410
    session                     Thread object
1423
1411
    db                  Database
1424
1412
    table_name          Table name
1434
1422
 
1435
1423
    Note that this function assumes that caller already have taken
1436
1424
    name-lock on table being created or used some other way to ensure
1437
 
    that concurrent operations won't intervene. create_table()
 
1425
    that concurrent operations won't intervene. mysql_create_table()
1438
1426
    is a wrapper that can be used for this.
1439
1427
 
1440
1428
  RETURN VALUES
1442
1430
    true  error
1443
1431
*/
1444
1432
 
1445
 
bool create_table_no_lock(Session *session,
1446
 
                                const identifier::Table &identifier,
 
1433
bool mysql_create_table_no_lock(Session *session,
 
1434
                                TableIdentifier &identifier,
1447
1435
                                HA_CREATE_INFO *create_info,
1448
1436
                                message::Table &table_proto,
1449
1437
                                AlterInfo *alter_info,
1468
1456
  set_table_default_charset(create_info, identifier.getSchemaName().c_str());
1469
1457
 
1470
1458
  /* 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))
 
1459
  if (not mysql_prepare_create_table(session, create_info, table_proto, alter_info,
 
1460
                                 internal_tmp_table,
 
1461
                                 &db_options,
 
1462
                                 &key_info_buffer, &key_count,
 
1463
                                 select_field_count))
1476
1464
  {
1477
 
    boost_unique_lock_t lock(table::Cache::singleton().mutex()); /* CREATE TABLE (some confussion on naming, double check) */
 
1465
    boost::mutex::scoped_lock lock(LOCK_open); /* CREATE TABLE (some confussion on naming, double check) */
1478
1466
    error= locked_create_event(session,
1479
1467
                               identifier,
1480
1468
                               create_info,
1495
1483
  @note the following two methods implement create [temporary] table.
1496
1484
*/
1497
1485
static bool drizzle_create_table(Session *session,
1498
 
                                 const identifier::Table &identifier,
 
1486
                                 TableIdentifier &identifier,
1499
1487
                                 HA_CREATE_INFO *create_info,
1500
1488
                                 message::Table &table_proto,
1501
1489
                                 AlterInfo *alter_info,
1522
1510
    }
1523
1511
    else
1524
1512
    {
1525
 
      my_error(ER_TABLE_EXISTS_ERROR, identifier);
 
1513
      my_error(ER_TABLE_EXISTS_ERROR, MYF(0), identifier.getSQLPath().c_str());
1526
1514
      result= true;
1527
1515
    }
1528
1516
  }
1529
1517
  else
1530
1518
  {
1531
 
    result= create_table_no_lock(session,
 
1519
    result= mysql_create_table_no_lock(session,
1532
1520
                                       identifier,
1533
1521
                                       create_info,
1534
1522
                                       table_proto,
1540
1528
 
1541
1529
  if (name_lock)
1542
1530
  {
1543
 
    boost_unique_lock_t lock(table::Cache::singleton().mutex()); /* Lock for removing name_lock during table create */
 
1531
    boost::mutex::scoped_lock lock(LOCK_open); /* Lock for removing name_lock during table create */
1544
1532
    session->unlink_open_table(name_lock);
1545
1533
  }
1546
1534
 
1549
1537
 
1550
1538
 
1551
1539
/*
1552
 
  Database locking aware wrapper for create_table_no_lock(),
 
1540
  Database locking aware wrapper for mysql_create_table_no_lock(),
1553
1541
*/
1554
 
bool create_table(Session *session,
1555
 
                        const identifier::Table &identifier,
 
1542
bool mysql_create_table(Session *session,
 
1543
                        TableIdentifier &identifier,
1556
1544
                        HA_CREATE_INFO *create_info,
1557
1545
                        message::Table &table_proto,
1558
1546
                        AlterInfo *alter_info,
1562
1550
{
1563
1551
  if (identifier.isTmp())
1564
1552
  {
1565
 
    return create_table_no_lock(session,
 
1553
    return mysql_create_table_no_lock(session,
1566
1554
                                      identifier,
1567
1555
                                      create_info,
1568
1556
                                      table_proto,
1632
1620
  Rename a table.
1633
1621
 
1634
1622
  SYNOPSIS
1635
 
    rename_table()
 
1623
    mysql_rename_table()
1636
1624
      session
1637
1625
      base                      The plugin::StorageEngine handle.
1638
1626
      old_db                    The old database name.
1646
1634
*/
1647
1635
 
1648
1636
bool
1649
 
rename_table(Session &session,
 
1637
mysql_rename_table(Session &session,
1650
1638
                   plugin::StorageEngine *base,
1651
 
                   const identifier::Table &from,
1652
 
                   const identifier::Table &to)
 
1639
                   TableIdentifier &from,
 
1640
                   TableIdentifier &to)
1653
1641
{
1654
1642
  int error= 0;
1655
1643
 
1669
1657
  }
1670
1658
  else if (error)
1671
1659
  {
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();
 
1660
    const char *from_identifier= from.isTmp() ? "#sql-temporary" : from.getSQLPath().c_str();
 
1661
    const char *to_identifier= to.isTmp() ? "#sql-temporary" : to.getSQLPath().c_str();
1680
1662
 
1681
1663
    my_error(ER_ERROR_ON_RENAME, MYF(0), from_identifier, to_identifier, error);
1682
1664
  }
1700
1682
   the table is closed.
1701
1683
 
1702
1684
  PREREQUISITES
1703
 
    Lock on table::Cache::singleton().mutex()
 
1685
    Lock on LOCK_open
1704
1686
    Win32 clients must also have a WRITE LOCK on the table !
1705
1687
*/
1706
1688
 
1708
1690
                              enum ha_extra_function function)
1709
1691
{
1710
1692
 
1711
 
  safe_mutex_assert_owner(table::Cache::singleton().mutex().native_handle());
 
1693
  safe_mutex_assert_owner(LOCK_open.native_handle());
1712
1694
 
1713
1695
  table->cursor->extra(function);
1714
1696
  /* Mark all tables that are in use as 'old' */
1715
 
  session->abortLock(table);    /* end threads waiting on lock */
 
1697
  mysql_lock_abort(session, table);     /* end threads waiting on lock */
1716
1698
 
1717
1699
  /* Wait until all there are no other threads that has this table open */
1718
 
  identifier::Table identifier(table->getShare()->getSchemaName(), table->getShare()->getTableName());
1719
 
  table::Cache::singleton().removeTable(session, identifier, RTFC_WAIT_OTHER_THREAD_FLAG);
 
1700
  TableIdentifier identifier(table->getMutableShare()->getSchemaName(), table->getMutableShare()->getTableName());
 
1701
  remove_table_from_cache(session, identifier, RTFC_WAIT_OTHER_THREAD_FLAG);
1720
1702
}
1721
1703
 
1722
1704
/*
1732
1714
    reopen the table.
1733
1715
 
1734
1716
  PREREQUISITES
1735
 
    Lock on table::Cache::singleton().mutex()
 
1717
    Lock on LOCK_open
1736
1718
    Win32 clients must also have a WRITE LOCK on the table !
1737
1719
*/
1738
1720
 
1743
1725
  /* Close lock if this is not got with LOCK TABLES */
1744
1726
  if (lock)
1745
1727
  {
1746
 
    unlockTables(lock);
 
1728
    mysql_unlock_tables(this, lock);
1747
1729
    lock= NULL;                 // Start locked threads
1748
1730
  }
1749
1731
  /* Close all copies of 'table'.  This also frees all LOCK TABLES lock */
1750
1732
  unlink_open_table(table);
1751
1733
 
1752
 
  /* When lock on table::Cache::singleton().mutex() is freed other threads can continue */
1753
 
  locking::broadcast_refresh();
 
1734
  /* When lock on LOCK_open is freed other threads can continue */
 
1735
  broadcast_refresh();
1754
1736
}
1755
1737
 
1756
1738
/*
1759
1741
    true  Message should be sent by caller
1760
1742
          (admin operation or network communication failed)
1761
1743
*/
1762
 
static bool admin_table(Session* session, TableList* tables,
 
1744
static bool mysql_admin_table(Session* session, TableList* tables,
1763
1745
                              HA_CHECK_OPT* check_opt,
1764
1746
                              const char *operator_name,
1765
1747
                              thr_lock_type lock_type,
1768
1750
                                                            HA_CHECK_OPT *))
1769
1751
{
1770
1752
  TableList *table;
1771
 
  Select_Lex *select= &session->getLex()->select_lex;
 
1753
  Select_Lex *select= &session->lex->select_lex;
1772
1754
  List<Item> field_list;
1773
1755
  Item *item;
 
1756
  LEX *lex= session->lex;
1774
1757
  int result_code= 0;
1775
1758
  TransactionServices &transaction_services= TransactionServices::singleton();
1776
1759
  const CHARSET_INFO * const cs= system_charset_info;
1777
1760
 
1778
1761
  if (! session->endActiveTransaction())
1779
1762
    return 1;
1780
 
 
1781
1763
  field_list.push_back(item = new Item_empty_string("Table",
1782
1764
                                                    NAME_CHAR_LEN * 2,
1783
1765
                                                    cs));
1788
1770
  item->maybe_null = 1;
1789
1771
  field_list.push_back(item = new Item_empty_string("Msg_text", 255, cs));
1790
1772
  item->maybe_null = 1;
1791
 
  if (session->getClient()->sendFields(&field_list))
 
1773
  if (session->client->sendFields(&field_list))
1792
1774
    return true;
1793
1775
 
1794
1776
  for (table= tables; table; table= table->next_local)
1795
1777
  {
1796
 
    identifier::Table table_identifier(table->getSchemaName(), table->getTableName());
1797
 
    std::string table_name;
 
1778
    char table_name[NAME_LEN*2+2];
 
1779
    char* db = table->db;
1798
1780
    bool fatal_error=0;
1799
1781
 
1800
 
    table_identifier.getSQLPath(table_name);
1801
 
 
 
1782
    snprintf(table_name, sizeof(table_name), "%s.%s",db,table->table_name);
1802
1783
    table->lock_type= lock_type;
1803
1784
    /* open only one table from local list of command */
1804
1785
    {
1813
1794
        so it have to be prepared.
1814
1795
        @todo Investigate if we can put extra tables into argument instead of using lex->query_tables
1815
1796
      */
1816
 
      session->getLex()->query_tables= table;
1817
 
      session->getLex()->query_tables_last= &table->next_global;
1818
 
      session->getLex()->query_tables_own_last= 0;
 
1797
      lex->query_tables= table;
 
1798
      lex->query_tables_last= &table->next_global;
 
1799
      lex->query_tables_own_last= 0;
1819
1800
      session->no_warnings_for_error= 0;
1820
1801
 
1821
1802
      session->openTablesLock(table);
1845
1826
    {
1846
1827
      char buff[FN_REFLEN + DRIZZLE_ERRMSG_SIZE];
1847
1828
      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"));
 
1829
      session->client->store(table_name);
 
1830
      session->client->store(operator_name);
 
1831
      session->client->store(STRING_WITH_LEN("error"));
1851
1832
      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);
 
1833
                       table_name);
 
1834
      session->client->store(buff, length);
 
1835
      transaction_services.autocommitOrRollback(session, false);
1855
1836
      session->endTransaction(COMMIT);
1856
1837
      session->close_thread_tables();
1857
 
      session->getLex()->reset_query_tables_list(false);
 
1838
      lex->reset_query_tables_list(false);
1858
1839
      table->table=0;                           // For query cache
1859
 
      if (session->getClient()->flush())
 
1840
      if (session->client->flush())
1860
1841
        goto err;
1861
1842
      continue;
1862
1843
    }
1864
1845
    /* Close all instances of the table to allow repair to rename files */
1865
1846
    if (lock_type == TL_WRITE && table->table->getShare()->getVersion())
1866
1847
    {
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(),
 
1848
      LOCK_open.lock(); /* Lock type is TL_WRITE and we lock to repair the table */
 
1849
      const char *old_message=session->enter_cond(COND_refresh, LOCK_open,
1869
1850
                                                  "Waiting to get writelock");
1870
 
      session->abortLock(table->table);
1871
 
      identifier::Table identifier(table->table->getShare()->getSchemaName(), table->table->getShare()->getTableName());
1872
 
      table::Cache::singleton().removeTable(session, identifier, RTFC_WAIT_OTHER_THREAD_FLAG | RTFC_CHECK_KILLED_FLAG);
 
1851
      mysql_lock_abort(session,table->table);
 
1852
      TableIdentifier identifier(table->table->getMutableShare()->getSchemaName(), table->table->getMutableShare()->getTableName());
 
1853
      remove_table_from_cache(session, identifier,
 
1854
                              RTFC_WAIT_OTHER_THREAD_FLAG |
 
1855
                              RTFC_CHECK_KILLED_FLAG);
1873
1856
      session->exit_cond(old_message);
1874
 
      if (session->getKilled())
 
1857
      if (session->killed)
1875
1858
        goto err;
1876
1859
      open_for_modify= 0;
1877
1860
    }
1880
1863
 
1881
1864
send_result:
1882
1865
 
1883
 
    session->getLex()->cleanup_after_one_table_open();
 
1866
    lex->cleanup_after_one_table_open();
1884
1867
    session->clear_error();  // these errors shouldn't get client
1885
1868
    {
1886
 
      List<DRIZZLE_ERROR>::iterator it(session->warn_list.begin());
 
1869
      List_iterator_fast<DRIZZLE_ERROR> it(session->warn_list);
1887
1870
      DRIZZLE_ERROR *err;
1888
1871
      while ((err= it++))
1889
1872
      {
1890
 
        session->getClient()->store(table_name.c_str());
1891
 
        session->getClient()->store(operator_name);
1892
 
        session->getClient()->store(warning_level_names[err->level].str,
 
1873
        session->client->store(table_name);
 
1874
        session->client->store(operator_name);
 
1875
        session->client->store(warning_level_names[err->level].str,
1893
1876
                               warning_level_names[err->level].length);
1894
 
        session->getClient()->store(err->msg);
1895
 
        if (session->getClient()->flush())
 
1877
        session->client->store(err->msg);
 
1878
        if (session->client->flush())
1896
1879
          goto err;
1897
1880
      }
1898
1881
      drizzle_reset_errors(session, true);
1899
1882
    }
1900
 
    session->getClient()->store(table_name.c_str());
1901
 
    session->getClient()->store(operator_name);
 
1883
    session->client->store(table_name);
 
1884
    session->client->store(operator_name);
1902
1885
 
1903
1886
    switch (result_code) {
1904
1887
    case HA_ADMIN_NOT_IMPLEMENTED:
1906
1889
        char buf[ERRMSGSIZE+20];
1907
1890
        uint32_t length=snprintf(buf, ERRMSGSIZE,
1908
1891
                             ER(ER_CHECK_NOT_IMPLEMENTED), operator_name);
1909
 
        session->getClient()->store(STRING_WITH_LEN("note"));
1910
 
        session->getClient()->store(buf, length);
 
1892
        session->client->store(STRING_WITH_LEN("note"));
 
1893
        session->client->store(buf, length);
1911
1894
      }
1912
1895
      break;
1913
1896
 
1914
1897
    case HA_ADMIN_OK:
1915
 
      session->getClient()->store(STRING_WITH_LEN("status"));
1916
 
      session->getClient()->store(STRING_WITH_LEN("OK"));
 
1898
      session->client->store(STRING_WITH_LEN("status"));
 
1899
      session->client->store(STRING_WITH_LEN("OK"));
1917
1900
      break;
1918
1901
 
1919
1902
    case HA_ADMIN_FAILED:
1920
 
      session->getClient()->store(STRING_WITH_LEN("status"));
1921
 
      session->getClient()->store(STRING_WITH_LEN("Operation failed"));
 
1903
      session->client->store(STRING_WITH_LEN("status"));
 
1904
      session->client->store(STRING_WITH_LEN("Operation failed"));
1922
1905
      break;
1923
1906
 
1924
1907
    case HA_ADMIN_REJECT:
1925
 
      session->getClient()->store(STRING_WITH_LEN("status"));
1926
 
      session->getClient()->store(STRING_WITH_LEN("Operation need committed state"));
 
1908
      session->client->store(STRING_WITH_LEN("status"));
 
1909
      session->client->store(STRING_WITH_LEN("Operation need committed state"));
1927
1910
      open_for_modify= false;
1928
1911
      break;
1929
1912
 
1930
1913
    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"));
 
1914
      session->client->store(STRING_WITH_LEN("status"));
 
1915
      session->client->store(STRING_WITH_LEN("Table is already up to date"));
1933
1916
      break;
1934
1917
 
1935
1918
    case HA_ADMIN_CORRUPT:
1936
 
      session->getClient()->store(STRING_WITH_LEN("error"));
1937
 
      session->getClient()->store(STRING_WITH_LEN("Corrupt"));
 
1919
      session->client->store(STRING_WITH_LEN("error"));
 
1920
      session->client->store(STRING_WITH_LEN("Corrupt"));
1938
1921
      fatal_error=1;
1939
1922
      break;
1940
1923
 
1941
1924
    case HA_ADMIN_INVALID:
1942
 
      session->getClient()->store(STRING_WITH_LEN("error"));
1943
 
      session->getClient()->store(STRING_WITH_LEN("Invalid argument"));
 
1925
      session->client->store(STRING_WITH_LEN("error"));
 
1926
      session->client->store(STRING_WITH_LEN("Invalid argument"));
1944
1927
      break;
1945
1928
 
1946
1929
    default:                            // Probably HA_ADMIN_INTERNAL_ERROR
1949
1932
        uint32_t length=snprintf(buf, ERRMSGSIZE,
1950
1933
                             _("Unknown - internal error %d during operation"),
1951
1934
                             result_code);
1952
 
        session->getClient()->store(STRING_WITH_LEN("error"));
1953
 
        session->getClient()->store(buf, length);
 
1935
        session->client->store(STRING_WITH_LEN("error"));
 
1936
        session->client->store(buf, length);
1954
1937
        fatal_error=1;
1955
1938
        break;
1956
1939
      }
1969
1952
        }
1970
1953
        else
1971
1954
        {
1972
 
          boost::unique_lock<boost::mutex> lock(table::Cache::singleton().mutex());
1973
 
          identifier::Table identifier(table->table->getShare()->getSchemaName(), table->table->getShare()->getTableName());
1974
 
          table::Cache::singleton().removeTable(session, identifier, RTFC_NO_FLAG);
 
1955
          boost::mutex::scoped_lock lock(LOCK_open);
 
1956
          TableIdentifier identifier(table->table->getMutableShare()->getSchemaName(), table->table->getMutableShare()->getTableName());
 
1957
          remove_table_from_cache(session, identifier, RTFC_NO_FLAG);
1975
1958
        }
1976
1959
      }
1977
1960
    }
1978
 
    transaction_services.autocommitOrRollback(*session, false);
 
1961
    transaction_services.autocommitOrRollback(session, false);
1979
1962
    session->endTransaction(COMMIT);
1980
1963
    session->close_thread_tables();
1981
1964
    table->table=0;                             // For query cache
1982
 
    if (session->getClient()->flush())
 
1965
    if (session->client->flush())
1983
1966
      goto err;
1984
1967
  }
1985
1968
 
1987
1970
  return(false);
1988
1971
 
1989
1972
err:
1990
 
  transaction_services.autocommitOrRollback(*session, true);
 
1973
  transaction_services.autocommitOrRollback(session, true);
1991
1974
  session->endTransaction(ROLLBACK);
1992
1975
  session->close_thread_tables();                       // Shouldn't be needed
1993
1976
  if (table)
2001
1984
    Altough exclusive name-lock on target table protects us from concurrent
2002
1985
    DML and DDL operations on it we still want to wrap .FRM creation and call
2003
1986
    to plugin::StorageEngine::createTable() in critical section protected by
2004
 
    table::Cache::singleton().mutex() in order to provide minimal atomicity against operations which
 
1987
    LOCK_open in order to provide minimal atomicity against operations which
2005
1988
    disregard name-locks, like I_S implementation, for example. This is a
2006
1989
    temporary and should not be copied. Instead we should fix our code to
2007
1990
    always honor name-locks.
2008
1991
 
2009
 
    Also some engines (e.g. NDB cluster) require that table::Cache::singleton().mutex() should be held
 
1992
    Also some engines (e.g. NDB cluster) require that LOCK_open should be held
2010
1993
    during the call to plugin::StorageEngine::createTable().
2011
1994
    See bug #28614 for more info.
2012
1995
  */
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,
 
1996
static bool create_table_wrapper(Session &session, const message::Table& create_table_proto,
 
1997
                                 TableIdentifier &destination_identifier,
 
1998
                                 TableIdentifier &src_table,
2017
1999
                                 bool is_engine_set)
2018
2000
{
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);
 
2001
  int protoerr= EEXIST;
 
2002
  message::Table new_proto;
 
2003
  message::Table src_proto;
 
2004
 
 
2005
  protoerr= plugin::StorageEngine::getTableDefinition(session,
 
2006
                                                      src_table,
 
2007
                                                      src_proto);
 
2008
  new_proto.CopyFrom(src_proto);
2033
2009
 
2034
2010
  if (destination_identifier.isTmp())
2035
2011
  {
2036
 
    new_table_message.set_type(message::Table::TEMPORARY);
 
2012
    new_proto.set_type(message::Table::TEMPORARY);
2037
2013
  }
2038
2014
  else
2039
2015
  {
2040
 
    new_table_message.set_type(message::Table::STANDARD);
 
2016
    new_proto.set_type(message::Table::STANDARD);
2041
2017
  }
2042
2018
 
2043
2019
  if (is_engine_set)
2044
2020
  {
2045
 
    new_table_message.mutable_engine()->set_name(create_table_proto.engine().name());
 
2021
    new_proto.mutable_engine()->set_name(create_table_proto.engine().name());
2046
2022
  }
2047
2023
 
2048
2024
  { // 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());
 
2025
    new_proto.set_name(create_table_proto.name());
 
2026
    new_proto.set_schema(create_table_proto.schema());
 
2027
    new_proto.set_catalog(create_table_proto.catalog());
2052
2028
  }
2053
2029
 
2054
 
  /* Fix names of foreign keys being added */
2055
 
  for (int32_t j= 0; j < new_table_message.fk_constraint_size(); j++)
 
2030
  if (protoerr && protoerr != EEXIST)
2056
2031
  {
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
 
    }
 
2032
    if (errno == ENOENT)
 
2033
      my_error(ER_BAD_DB_ERROR,MYF(0), destination_identifier.getSchemaName().c_str());
 
2034
    else
 
2035
      my_error(ER_CANT_CREATE_FILE, MYF(0), destination_identifier.getPath().c_str(), errno);
 
2036
 
 
2037
    return false;
2069
2038
  }
2070
2039
 
2071
2040
  /*
2072
2041
    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).
 
2042
    creation, instead create the table directly (for both normal
 
2043
    and temporary tables).
2074
2044
  */
2075
 
  bool success= plugin::StorageEngine::createTable(session,
2076
 
                                                   destination_identifier,
2077
 
                                                   new_table_message);
 
2045
  int err= plugin::StorageEngine::createTable(session,
 
2046
                                              destination_identifier,
 
2047
                                              new_proto);
2078
2048
 
2079
 
  if (success && not destination_identifier.isTmp())
 
2049
  if (err == false && not destination_identifier.isTmp())
2080
2050
  {
2081
2051
    TransactionServices &transaction_services= TransactionServices::singleton();
2082
 
    transaction_services.createTable(session, new_table_message);
 
2052
    transaction_services.createTable(&session, new_proto);
2083
2053
  }
2084
2054
 
2085
 
  return success;
 
2055
  return err ? false : true;
2086
2056
}
2087
2057
 
2088
2058
/*
2089
2059
  Create a table identical to the specified table
2090
2060
 
2091
2061
  SYNOPSIS
2092
 
    create_like_table()
 
2062
    mysql_create_like_table()
2093
2063
    session             Thread object
2094
2064
    table       Table list element for target table
2095
2065
    src_table   Table list element for source table
2100
2070
    true  error
2101
2071
*/
2102
2072
 
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)
 
2073
bool mysql_create_like_table(Session* session,
 
2074
                             TableIdentifier &destination_identifier,
 
2075
                             TableList* table, TableList* src_table,
 
2076
                             message::Table &create_table_proto,
 
2077
                             bool is_if_not_exists,
 
2078
                             bool is_engine_set)
2109
2079
{
 
2080
  char *db= table->db;
 
2081
  char *table_name= table->table_name;
2110
2082
  bool res= true;
2111
 
  bool table_exists= false;
 
2083
  uint32_t not_used;
 
2084
 
 
2085
  /*
 
2086
    By opening source table we guarantee that it exists and no concurrent
 
2087
    DDL operation will mess with it. Later we also take an exclusive
 
2088
    name-lock on target table name, which makes copying of .frm cursor,
 
2089
    call to plugin::StorageEngine::createTable() and binlogging atomic
 
2090
    against concurrent DML and DDL operations on target table.
 
2091
    Thus by holding both these "locks" we ensure that our statement is
 
2092
    properly isolated from all concurrent operations which matter.
 
2093
  */
 
2094
  if (session->open_tables_from_list(&src_table, &not_used))
 
2095
    return true;
 
2096
 
 
2097
  TableIdentifier src_identifier(src_table->table->getMutableShare()->getSchemaName(),
 
2098
                                 src_table->table->getMutableShare()->getTableName(), src_table->table->getMutableShare()->getType());
 
2099
 
 
2100
 
2112
2101
 
2113
2102
  /*
2114
2103
    Check that destination tables does not exist. Note that its name
2116
2105
 
2117
2106
    For temporary tables we don't aim to grab locks.
2118
2107
  */
 
2108
  bool table_exists= false;
2119
2109
  if (destination_identifier.isTmp())
2120
2110
  {
2121
 
    if (session->find_temporary_table(destination_identifier))
 
2111
    if (session->find_temporary_table(db, table_name))
2122
2112
    {
2123
2113
      table_exists= true;
2124
2114
    }
2125
2115
    else
2126
2116
    {
2127
 
      bool was_created= create_table_wrapper(*session,
2128
 
                                             create_table_proto,
2129
 
                                             destination_identifier,
2130
 
                                             source_identifier,
2131
 
                                             is_engine_set);
 
2117
      bool was_created= create_table_wrapper(*session, create_table_proto, destination_identifier,
 
2118
                                             src_identifier, is_engine_set);
2132
2119
      if (not was_created) // This is pretty paranoid, but we assume something might not clean up after itself
2133
2120
      {
2134
2121
        (void) session->rm_temporary_table(destination_identifier, true);
2152
2139
    {
2153
2140
      if (name_lock)
2154
2141
      {
2155
 
        boost_unique_lock_t lock(table::Cache::singleton().mutex()); /* unlink open tables for create table like*/
 
2142
        boost::mutex::scoped_lock lock(LOCK_open); /* unlink open tables for create table like*/
2156
2143
        session->unlink_open_table(name_lock);
2157
2144
      }
2158
2145
 
2171
2158
    {
2172
2159
      bool was_created;
2173
2160
      {
2174
 
        boost_unique_lock_t lock(table::Cache::singleton().mutex()); /* We lock for CREATE TABLE LIKE to copy table definition */
 
2161
        boost::mutex::scoped_lock lock(LOCK_open); /* We lock for CREATE TABLE LIKE to copy table definition */
2175
2162
        was_created= create_table_wrapper(*session, create_table_proto, destination_identifier,
2176
 
                                          source_identifier, is_engine_set);
 
2163
                                               src_identifier, is_engine_set);
2177
2164
      }
2178
2165
 
2179
2166
      // So we blew the creation of the table, and we scramble to clean up
2180
2167
      // anything that might have been created (read... it is a hack)
2181
2168
      if (not was_created)
2182
2169
      {
2183
 
        plugin::StorageEngine::dropTable(*session, destination_identifier);
 
2170
        quick_rm_table(*session, destination_identifier);
2184
2171
      } 
2185
2172
      else
2186
2173
      {
2190
2177
 
2191
2178
    if (name_lock)
2192
2179
    {
2193
 
      boost_unique_lock_t lock(table::Cache::singleton().mutex()); /* unlink open tables for create table like*/
 
2180
      boost::mutex::scoped_lock lock(LOCK_open); /* unlink open tables for create table like*/
2194
2181
      session->unlink_open_table(name_lock);
2195
2182
    }
2196
2183
  }
2201
2188
    {
2202
2189
      char warn_buff[DRIZZLE_ERRMSG_SIZE];
2203
2190
      snprintf(warn_buff, sizeof(warn_buff),
2204
 
               ER(ER_TABLE_EXISTS_ERROR), destination_identifier.getTableName().c_str());
 
2191
               ER(ER_TABLE_EXISTS_ERROR), table_name);
2205
2192
      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;
 
2193
                   ER_TABLE_EXISTS_ERROR,warn_buff);
 
2194
      res= false;
 
2195
    }
 
2196
    else
 
2197
    {
 
2198
      my_error(ER_TABLE_EXISTS_ERROR, MYF(0), table_name);
 
2199
    }
2213
2200
  }
2214
2201
 
2215
 
  return res;
 
2202
  return(res);
2216
2203
}
2217
2204
 
2218
2205
 
2219
 
bool analyze_table(Session* session, TableList* tables, HA_CHECK_OPT* check_opt)
 
2206
bool mysql_analyze_table(Session* session, TableList* tables, HA_CHECK_OPT* check_opt)
2220
2207
{
2221
2208
  thr_lock_type lock_type = TL_READ_NO_INSERT;
2222
2209
 
2223
 
  return(admin_table(session, tables, check_opt,
 
2210
  return(mysql_admin_table(session, tables, check_opt,
2224
2211
                                "analyze", lock_type, true,
2225
2212
                                &Cursor::ha_analyze));
2226
2213
}
2227
2214
 
2228
2215
 
2229
 
bool check_table(Session* session, TableList* tables,HA_CHECK_OPT* check_opt)
 
2216
bool mysql_check_table(Session* session, TableList* tables,HA_CHECK_OPT* check_opt)
2230
2217
{
2231
2218
  thr_lock_type lock_type = TL_READ_NO_INSERT;
2232
2219
 
2233
 
  return(admin_table(session, tables, check_opt,
 
2220
  return(mysql_admin_table(session, tables, check_opt,
2234
2221
                                "check", lock_type,
2235
2222
                                false,
2236
2223
                                &Cursor::ha_check));