← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to drizzled/sql_table.cc

  • Committer: Brian Aker
  • Date: 2009-12-18 18:31:01 UTC
  • mfrom: (1241.2.7 build)
  • Revision ID: brian@gaz-20091218183101-igqg1dtowpa0o70s
Fixed from Monty.

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 <drizzled/server_includes.h>
19
19
#include <plugin/myisam/myisam.h>
20
20
#include <drizzled/show.h>
21
21
#include <drizzled/error.h>
22
22
#include <drizzled/gettext.h>
23
23
#include <drizzled/data_home.h>
24
24
#include <drizzled/sql_parse.h>
25
 
#include <drizzled/my_hash.h>
 
25
#include <mysys/hash.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"
30
29
#include <drizzled/db.h>
31
30
#include <drizzled/lock.h>
32
31
#include <drizzled/unireg.h>
33
32
#include <drizzled/item/int.h>
34
33
#include <drizzled/item/empty_string.h>
35
 
#include <drizzled/transaction_services.h>
36
 
#include "drizzled/transaction_services.h"
 
34
#include <drizzled/replication_services.h>
37
35
#include <drizzled/table_proto.h>
38
36
#include <drizzled/plugin/client.h>
39
 
#include <drizzled/identifier.h>
40
 
#include "drizzled/internal/m_string.h"
41
 
#include "drizzled/global_charset_info.h"
42
 
#include "drizzled/charset.h"
43
 
 
44
 
#include "drizzled/definition/cache.h"
45
 
 
 
37
#include <drizzled/table_identifier.h>
46
38
 
47
39
#include "drizzled/statement/alter_table.h"
48
 
#include "drizzled/sql_table.h"
49
 
#include "drizzled/pthread_globals.h"
50
 
#include "drizzled/plugin/storage_engine.h"
 
40
#include "drizzled/plugin/info_schema_table.h"
51
41
 
52
42
#include <algorithm>
53
 
#include <sstream>
54
 
 
55
 
#include <boost/unordered_set.hpp>
56
43
 
57
44
using namespace std;
58
 
 
59
 
namespace drizzled
60
 
{
61
 
 
62
 
bool is_primary_key(KeyInfo *key_info)
 
45
using namespace drizzled;
 
46
 
 
47
static const char hexchars[]= "0123456789abcdef";
 
48
bool is_primary_key(KEY *key_info)
63
49
{
64
50
  static const char * primary_key_name="PRIMARY";
65
51
  return (strcmp(key_info->name, primary_key_name)==0);
74
60
    return NULL;
75
61
}
76
62
 
77
 
static bool check_if_keyname_exists(const char *name,KeyInfo *start, KeyInfo *end);
78
 
static char *make_unique_key_name(const char *field_name,KeyInfo *start,KeyInfo *end);
 
63
static bool check_if_keyname_exists(const char *name,KEY *start, KEY *end);
 
64
static char *make_unique_key_name(const char *field_name,KEY *start,KEY *end);
79
65
 
80
66
static bool prepare_blob_field(Session *session, CreateField *sql_field);
81
67
 
86
72
    let's fetch the database default character set and
87
73
    apply it to the table.
88
74
  */
89
 
  identifier::Schema identifier(db);
90
75
  if (create_info->default_table_charset == NULL)
91
 
    create_info->default_table_charset= plugin::StorageEngine::getSchemaCollation(identifier);
 
76
    create_info->default_table_charset= get_default_db_collation(db);
 
77
}
 
78
 
 
79
/*
 
80
  Translate a cursor name to a table name (WL #1324).
 
81
 
 
82
  SYNOPSIS
 
83
    filename_to_tablename()
 
84
      from                      The cursor name
 
85
      to                OUT     The table name
 
86
      to_length                 The size of the table name buffer.
 
87
 
 
88
  RETURN
 
89
    Table name length.
 
90
*/
 
91
uint32_t filename_to_tablename(const char *from, char *to, uint32_t to_length)
 
92
{
 
93
  uint32_t length= 0;
 
94
 
 
95
  if (!memcmp(from, TMP_FILE_PREFIX, TMP_FILE_PREFIX_LENGTH))
 
96
  {
 
97
    /* Temporary table name. */
 
98
    length= strlen(strncpy(to, from, to_length));
 
99
  }
 
100
  else
 
101
  {
 
102
    for (; *from  && length < to_length; length++, from++)
 
103
    {
 
104
      if (*from != '@')
 
105
      {
 
106
        to[length]= *from;
 
107
        continue;
 
108
      }
 
109
      /* We've found an escaped char - skip the @ */
 
110
      from++;
 
111
      to[length]= 0;
 
112
      /* There will be a two-position hex-char version of the char */
 
113
      for (int x=1; x >= 0; x--)
 
114
      {
 
115
        if (*from >= '0' && *from <= '9')
 
116
          to[length] += ((*from++ - '0') << (4 * x));
 
117
        else if (*from >= 'a' && *from <= 'f')
 
118
          to[length] += ((*from++ - 'a' + 10) << (4 * x));
 
119
      }
 
120
      /* Backup because we advanced extra in the inner loop */
 
121
      from--;
 
122
    } 
 
123
  }
 
124
 
 
125
  return length;
 
126
}
 
127
 
 
128
 
 
129
/*
 
130
  Translate a table name to a cursor name (WL #1324).
 
131
 
 
132
  SYNOPSIS
 
133
    tablename_to_filename()
 
134
      from                      The table name
 
135
      to                OUT     The cursor name
 
136
      to_length                 The size of the cursor name buffer.
 
137
 
 
138
  RETURN
 
139
    true if errors happen. false on success.
 
140
*/
 
141
bool tablename_to_filename(const char *from, char *to, size_t to_length)
 
142
{
 
143
  
 
144
  size_t length= 0;
 
145
  for (; *from  && length < to_length; length++, from++)
 
146
  {
 
147
    if ((*from >= '0' && *from <= '9') ||
 
148
        (*from >= 'A' && *from <= 'Z') ||
 
149
        (*from >= 'a' && *from <= 'z') ||
 
150
/* OSX defines an extra set of high-bit and multi-byte characters
 
151
   that cannot be used on the filesystem. Instead of trying to sort
 
152
   those out, we'll just escape encode all high-bit-set chars on OSX.
 
153
   It won't really hurt anything - it'll just make some filenames ugly. */
 
154
#if !defined(TARGET_OS_OSX)
 
155
        ((unsigned char)*from >= 128) ||
 
156
#endif
 
157
        (*from == '_') ||
 
158
        (*from == ' ') ||
 
159
        (*from == '-'))
 
160
    {
 
161
      to[length]= *from;
 
162
      continue;
 
163
    }
 
164
   
 
165
    if (length + 3 >= to_length)
 
166
      return true;
 
167
 
 
168
    /* We need to escape this char in a way that can be reversed */
 
169
    to[length++]= '@';
 
170
    to[length++]= hexchars[(*from >> 4) & 15];
 
171
    to[length]= hexchars[(*from) & 15];
 
172
  }
 
173
 
 
174
  if (check_if_legal_tablename(to) &&
 
175
      length + 4 < to_length)
 
176
  {
 
177
    memcpy(to + length, "@@@", 4);
 
178
    length+= 3;
 
179
  }
 
180
  return false;
 
181
}
 
182
 
 
183
 
 
184
/*
 
185
  Creates path to a cursor: drizzle_data_dir/db/table.ext
 
186
 
 
187
  SYNOPSIS
 
188
   build_table_filename()
 
189
     buff                       Where to write result
 
190
                                This may be the same as table_name.
 
191
     bufflen                    buff size
 
192
     db                         Database name
 
193
     table_name                 Table name
 
194
     ext                        File extension.
 
195
     flags                      FN_FROM_IS_TMP or FN_TO_IS_TMP
 
196
                                table_name is temporary, do not change.
 
197
 
 
198
  NOTES
 
199
 
 
200
    Uses database and table name, and extension to create
 
201
    a cursor name in drizzle_data_dir. Database and table
 
202
    names are converted from system_charset_info into "fscs".
 
203
    Unless flags indicate a temporary table name.
 
204
    'db' is always converted.
 
205
    'ext' is not converted.
 
206
 
 
207
    The conversion suppression is required for ALTER Table. This
 
208
    statement creates intermediate tables. These are regular
 
209
    (non-temporary) tables with a temporary name. Their path names must
 
210
    be derivable from the table name. So we cannot use
 
211
    build_tmptable_filename() for them.
 
212
 
 
213
  RETURN
 
214
    path length on success, 0 on failure
 
215
*/
 
216
 
 
217
size_t build_table_filename(char *buff, size_t bufflen, const char *db, const char *table_name, bool is_tmp)
 
218
{
 
219
  char dbbuff[FN_REFLEN];
 
220
  char tbbuff[FN_REFLEN];
 
221
  bool conversion_error= false;
 
222
 
 
223
  memset(tbbuff, 0, sizeof(tbbuff));
 
224
  if (is_tmp) // FN_FROM_IS_TMP | FN_TO_IS_TMP
 
225
    strncpy(tbbuff, table_name, sizeof(tbbuff));
 
226
  else
 
227
  {
 
228
    conversion_error= tablename_to_filename(table_name, tbbuff, sizeof(tbbuff));
 
229
    if (conversion_error)
 
230
    {
 
231
      errmsg_printf(ERRMSG_LVL_ERROR,
 
232
                    _("Table name cannot be encoded and fit within filesystem "
 
233
                      "name length restrictions."));
 
234
      return 0;
 
235
    }
 
236
  }
 
237
  memset(dbbuff, 0, sizeof(dbbuff));
 
238
  conversion_error= tablename_to_filename(db, dbbuff, sizeof(dbbuff));
 
239
  if (conversion_error)
 
240
  {
 
241
    errmsg_printf(ERRMSG_LVL_ERROR,
 
242
                  _("Schema name cannot be encoded and fit within filesystem "
 
243
                    "name length restrictions."));
 
244
    return 0;
 
245
  }
 
246
   
 
247
 
 
248
  int rootdir_len= strlen(FN_ROOTDIR);
 
249
  string table_path(drizzle_data_home);
 
250
  int without_rootdir= table_path.length()-rootdir_len;
 
251
 
 
252
  /* Don't add FN_ROOTDIR if dirzzle_data_home already includes it */
 
253
  if (without_rootdir >= 0)
 
254
  {
 
255
    const char *tmp= table_path.c_str()+without_rootdir;
 
256
    if (memcmp(tmp, FN_ROOTDIR, rootdir_len) != 0)
 
257
      table_path.append(FN_ROOTDIR);
 
258
  }
 
259
 
 
260
  table_path.append(dbbuff);
 
261
  table_path.append(FN_ROOTDIR);
 
262
  table_path.append(tbbuff);
 
263
 
 
264
  if (bufflen < table_path.length())
 
265
    return 0;
 
266
 
 
267
  strcpy(buff, table_path.c_str());
 
268
 
 
269
  return table_path.length();
 
270
}
 
271
 
 
272
 
 
273
/*
 
274
  Creates path to a cursor: drizzle_tmpdir/#sql1234_12_1.ext
 
275
 
 
276
  SYNOPSIS
 
277
   build_tmptable_filename()
 
278
     session                    The thread handle.
 
279
     buff                       Where to write result
 
280
     bufflen                    buff size
 
281
 
 
282
  NOTES
 
283
 
 
284
    Uses current_pid, thread_id, and tmp_table counter to create
 
285
    a cursor name in drizzle_tmpdir.
 
286
 
 
287
  RETURN
 
288
    path length on success, 0 on failure
 
289
*/
 
290
 
 
291
size_t build_tmptable_filename(char *buff, size_t bufflen)
 
292
{
 
293
  size_t length;
 
294
  ostringstream path_str, post_tmpdir_str;
 
295
  string tmp;
 
296
 
 
297
  Session *session= current_session;
 
298
 
 
299
  path_str << drizzle_tmpdir;
 
300
  post_tmpdir_str << "/" << TMP_FILE_PREFIX << current_pid;
 
301
  post_tmpdir_str << session->thread_id << session->tmp_table++;
 
302
  tmp= post_tmpdir_str.str();
 
303
 
 
304
  transform(tmp.begin(), tmp.end(), tmp.begin(), ::tolower);
 
305
 
 
306
  path_str << tmp;
 
307
 
 
308
  if (bufflen < path_str.str().length())
 
309
    length= 0;
 
310
  else
 
311
    length= unpack_filename(buff, path_str.str().c_str());
 
312
 
 
313
  return length;
92
314
}
93
315
 
94
316
/*
106
328
    cursor
107
329
*/
108
330
 
109
 
void write_bin_log(Session *session, const std::string &query)
110
 
{
111
 
  TransactionServices &transaction_services= TransactionServices::singleton();
112
 
  transaction_services.rawStatement(*session, query);
 
331
void write_bin_log(Session *session,
 
332
                   char const *query, size_t query_length)
 
333
{
 
334
  ReplicationServices &replication_services= ReplicationServices::singleton();
 
335
  replication_services.rawStatement(session, query, query_length);
 
336
}
 
337
 
 
338
 
 
339
/* Should should be refactored to go away */
 
340
void write_bin_log_drop_table(Session *session, bool if_exists, const char *db_name, const char *table_name)
 
341
{
 
342
  ReplicationServices &replication_services= ReplicationServices::singleton();
 
343
  string built_query;
 
344
 
 
345
  if (if_exists)
 
346
    built_query.append("DROP TABLE IF EXISTS ");
 
347
  else
 
348
    built_query.append("DROP TABLE ");
 
349
 
 
350
  built_query.append("`");
 
351
  if (session->db.empty() || strcmp(db_name, session->db.c_str()) != 0)
 
352
  {
 
353
    built_query.append(db_name);
 
354
    built_query.append("`.`");
 
355
  }
 
356
 
 
357
  built_query.append(table_name);
 
358
  built_query.append("`");
 
359
  replication_services.rawStatement(session, built_query.c_str(), built_query.length());
113
360
}
114
361
 
115
362
/*
116
363
  Execute the drop of a normal or temporary table
117
364
 
118
365
  SYNOPSIS
119
 
    rm_table_part2()
 
366
    mysql_rm_table_part2()
120
367
    session                     Thread Cursor
121
368
    tables              Tables to drop
122
369
    if_exists           If set, don't give an error if table doesn't exists.
123
370
                        In this case we give an warning of level 'NOTE'
124
371
    drop_temporary      Only drop temporary tables
125
372
 
126
 
  @todo
 
373
  TODO:
127
374
    When logging to the binary log, we should log
128
375
    tmp_tables and transactional tables as separate statements if we
129
376
    are in a transaction;  This is needed to get these tables into the
139
386
   -1   Thread was killed
140
387
*/
141
388
 
142
 
int rm_table_part2(Session *session, TableList *tables, bool if_exists,
143
 
                   bool drop_temporary)
 
389
int mysql_rm_table_part2(Session *session, TableList *tables, bool if_exists,
 
390
                         bool drop_temporary)
144
391
{
145
392
  TableList *table;
 
393
  char path[FN_REFLEN];
 
394
  uint32_t path_length= 0;
146
395
  String wrong_tables;
147
396
  int error= 0;
148
397
  bool foreign_key_error= false;
149
398
 
150
 
  do
151
 
  {
152
 
    boost::mutex::scoped_lock scopedLock(table::Cache::singleton().mutex());
153
 
 
154
 
    if (not drop_temporary && session->lock_table_names_exclusively(tables))
155
 
    {
156
 
      return 1;
157
 
    }
158
 
 
159
 
    /* Don't give warnings for not found errors, as we already generate notes */
160
 
    session->no_warnings_for_error= 1;
161
 
 
162
 
    for (table= tables; table; table= table->next_local)
163
 
    {
164
 
      identifier::Table tmp_identifier(table->getSchemaName(), table->getTableName());
165
 
 
166
 
      error= session->drop_temporary_table(tmp_identifier);
167
 
 
168
 
      switch (error) {
169
 
      case  0:
170
 
        // removed temporary table
171
 
        continue;
172
 
      case -1:
 
399
  pthread_mutex_lock(&LOCK_open); /* Part 2 of rm a table */
 
400
 
 
401
  /*
 
402
    If we have the table in the definition cache, we don't have to check the
 
403
    .frm cursor to find if the table is a normal table (not view) and what
 
404
    engine to use.
 
405
  */
 
406
 
 
407
  for (table= tables; table; table= table->next_local)
 
408
  {
 
409
    TableShare *share;
 
410
    table->db_type= NULL;
 
411
    if ((share= TableShare::getShare(table->db, table->table_name)))
 
412
      table->db_type= share->db_type();
 
413
  }
 
414
 
 
415
  if (!drop_temporary && lock_table_names_exclusively(session, tables))
 
416
  {
 
417
    pthread_mutex_unlock(&LOCK_open);
 
418
    return 1;
 
419
  }
 
420
 
 
421
  /* Don't give warnings for not found errors, as we already generate notes */
 
422
  session->no_warnings_for_error= 1;
 
423
 
 
424
  for (table= tables; table; table= table->next_local)
 
425
  {
 
426
    char *db=table->db;
 
427
    plugin::StorageEngine *table_type;
 
428
 
 
429
    error= session->drop_temporary_table(table);
 
430
 
 
431
    switch (error) {
 
432
    case  0:
 
433
      // removed temporary table
 
434
      continue;
 
435
    case -1:
 
436
      error= 1;
 
437
      goto err_with_placeholders;
 
438
    default:
 
439
      // temporary table not found
 
440
      error= 0;
 
441
    }
 
442
 
 
443
    table_type= table->db_type;
 
444
    if (drop_temporary == false)
 
445
    {
 
446
      Table *locked_table;
 
447
      abort_locked_tables(session, db, table->table_name);
 
448
      remove_table_from_cache(session, db, table->table_name,
 
449
                              RTFC_WAIT_OTHER_THREAD_FLAG |
 
450
                              RTFC_CHECK_KILLED_FLAG);
 
451
      /*
 
452
        If the table was used in lock tables, remember it so that
 
453
        unlock_table_names can free it
 
454
      */
 
455
      if ((locked_table= drop_locked_tables(session, db, table->table_name)))
 
456
        table->table= locked_table;
 
457
 
 
458
      if (session->killed)
 
459
      {
 
460
        error= -1;
 
461
        goto err_with_placeholders;
 
462
      }
 
463
      /* remove .frm cursor and engine files */
 
464
      path_length= build_table_filename(path, sizeof(path), db, table->table_name, table->internal_tmp_table);
 
465
    }
 
466
    TableIdentifier identifier(db, table->table_name, table->internal_tmp_table ? INTERNAL_TMP_TABLE : NO_TMP_TABLE);
 
467
 
 
468
    if (drop_temporary ||
 
469
        ((table_type == NULL
 
470
          && (plugin::StorageEngine::getTableDefinition(*session,
 
471
                                                        identifier) != EEXIST))))
 
472
    {
 
473
      // Table was not found on disk and table can't be created from engine
 
474
      if (if_exists)
 
475
        push_warning_printf(session, DRIZZLE_ERROR::WARN_LEVEL_NOTE,
 
476
                            ER_BAD_TABLE_ERROR, ER(ER_BAD_TABLE_ERROR),
 
477
                            table->table_name);
 
478
      else
173
479
        error= 1;
174
 
        break;
175
 
      default:
176
 
        // temporary table not found
177
 
        error= 0;
178
 
      }
179
 
 
180
 
      if (drop_temporary == false)
181
 
      {
182
 
        Table *locked_table;
183
 
        abort_locked_tables(session, tmp_identifier);
184
 
        table::Cache::singleton().removeTable(session, tmp_identifier,
185
 
                                              RTFC_WAIT_OTHER_THREAD_FLAG |
186
 
                                              RTFC_CHECK_KILLED_FLAG);
187
 
        /*
188
 
          If the table was used in lock tables, remember it so that
189
 
          unlock_table_names can free it
190
 
        */
191
 
        if ((locked_table= drop_locked_tables(session, tmp_identifier)))
192
 
          table->table= locked_table;
193
 
 
194
 
        if (session->getKilled())
195
 
        {
196
 
          error= -1;
197
 
          break;
198
 
        }
199
 
      }
200
 
      identifier::Table identifier(table->getSchemaName(), table->getTableName(), table->getInternalTmpTable() ? message::Table::INTERNAL : message::Table::STANDARD);
201
 
 
202
 
      if (drop_temporary || not plugin::StorageEngine::doesTableExist(*session, identifier))
203
 
      {
204
 
        // Table was not found on disk and table can't be created from engine
205
 
        if (if_exists)
206
 
          push_warning_printf(session, DRIZZLE_ERROR::WARN_LEVEL_NOTE,
207
 
                              ER_BAD_TABLE_ERROR, ER(ER_BAD_TABLE_ERROR),
208
 
                              table->getTableName());
209
 
        else
210
 
        {
211
 
          error= 1;
212
 
        }
213
 
      }
214
 
      else
215
 
      {
216
 
        drizzled::error_t local_error;
217
 
 
218
 
        /* Generate transaction event ONLY when we successfully drop */ 
219
 
        if (plugin::StorageEngine::dropTable(*session, identifier, local_error))
220
 
        {
221
 
          TransactionServices &transaction_services= TransactionServices::singleton();
222
 
          transaction_services.dropTable(*session, identifier, if_exists);
223
 
        }
224
 
        else
225
 
        {
226
 
          if (local_error == HA_ERR_NO_SUCH_TABLE and if_exists)
227
 
          {
228
 
            error= 0;
229
 
            session->clear_error();
230
 
          }
231
 
 
232
 
          if (local_error == HA_ERR_ROW_IS_REFERENCED)
233
 
          {
234
 
            /* the table is referenced by a foreign key constraint */
235
 
            foreign_key_error= true;
236
 
          }
237
 
          error= local_error;
238
 
        }
239
 
      }
240
 
 
241
 
      if (error)
242
 
      {
243
 
        if (wrong_tables.length())
244
 
          wrong_tables.append(',');
245
 
        wrong_tables.append(String(table->getTableName(), system_charset_info));
246
 
      }
247
 
    }
248
 
 
249
 
    tables->unlock_table_names();
250
 
 
251
 
  } while (0);
252
 
 
 
480
    }
 
481
    else
 
482
    {
 
483
      error= plugin::StorageEngine::dropTable(*session,
 
484
                                              identifier,
 
485
                                              true);
 
486
 
 
487
      if ((error == ENOENT || error == HA_ERR_NO_SUCH_TABLE) && if_exists)
 
488
      {
 
489
        error= 0;
 
490
        session->clear_error();
 
491
      }
 
492
 
 
493
      if (error == HA_ERR_ROW_IS_REFERENCED)
 
494
      {
 
495
        /* the table is referenced by a foreign key constraint */
 
496
        foreign_key_error= true;
 
497
      }
 
498
    }
 
499
 
 
500
    if (error == 0 || (if_exists && foreign_key_error == false))
 
501
        write_bin_log_drop_table(session, if_exists, db, table->table_name);
 
502
 
 
503
    if (error)
 
504
    {
 
505
      if (wrong_tables.length())
 
506
        wrong_tables.append(',');
 
507
      wrong_tables.append(String(table->table_name,system_charset_info));
 
508
    }
 
509
  }
 
510
  /*
 
511
    It's safe to unlock LOCK_open: we have an exclusive lock
 
512
    on the table name.
 
513
  */
 
514
  pthread_mutex_unlock(&LOCK_open);
 
515
  error= 0;
253
516
  if (wrong_tables.length())
254
517
  {
255
 
    if (not foreign_key_error)
256
 
    {
 
518
    if (!foreign_key_error)
257
519
      my_printf_error(ER_BAD_TABLE_ERROR, ER(ER_BAD_TABLE_ERROR), MYF(0),
258
520
                      wrong_tables.c_ptr());
259
 
    }
260
521
    else
261
522
    {
262
523
      my_message(ER_ROW_IS_REFERENCED, ER(ER_ROW_IS_REFERENCED), MYF(0));
264
525
    error= 1;
265
526
  }
266
527
 
 
528
  pthread_mutex_lock(&LOCK_open); /* final bit in rm table lock */
 
529
err_with_placeholders:
 
530
  unlock_table_names(tables, NULL);
 
531
  pthread_mutex_unlock(&LOCK_open);
267
532
  session->no_warnings_for_error= 0;
268
533
 
269
 
  return error;
 
534
  return(error);
 
535
}
 
536
 
 
537
 
 
538
/*
 
539
  Quickly remove a table.
 
540
 
 
541
  SYNOPSIS
 
542
    quick_rm_table()
 
543
      base                      The plugin::StorageEngine handle.
 
544
      db                        The database name.
 
545
      table_name                The table name.
 
546
      is_tmp                    If the table is temp.
 
547
 
 
548
  RETURN
 
549
    0           OK
 
550
    != 0        Error
 
551
*/
 
552
bool quick_rm_table(Session& session,
 
553
                    TableIdentifier &identifier)
 
554
{
 
555
  return (plugin::StorageEngine::dropTable(session, identifier, false));
270
556
}
271
557
 
272
558
/*
282
568
  PRIMARY keys are prioritized.
283
569
*/
284
570
 
285
 
static int sort_keys(KeyInfo *a, KeyInfo *b)
 
571
static int sort_keys(KEY *a, KEY *b)
286
572
{
287
573
  ulong a_flags= a->flags, b_flags= b->flags;
288
574
 
334
620
    1             Error
335
621
*/
336
622
 
337
 
class typelib_set_member
338
 
{
339
 
public:
340
 
  string s;
341
 
  const CHARSET_INFO * const cs;
342
 
 
343
 
  typelib_set_member(const char* value, unsigned int length,
344
 
                     const CHARSET_INFO * const charset)
345
 
    : s(value, length),
346
 
      cs(charset)
347
 
  {}
348
 
};
349
 
 
350
 
static bool operator==(typelib_set_member const& a, typelib_set_member const& b)
351
 
{
352
 
  return (my_strnncoll(a.cs,
353
 
                       (const unsigned char*)a.s.c_str(), a.s.length(),
354
 
                       (const unsigned char*)b.s.c_str(), b.s.length())==0);
355
 
}
356
 
 
357
 
 
358
 
namespace
359
 
{
360
 
class typelib_set_member_hasher
361
 
{
362
 
  boost::hash<string> hasher;
363
 
public:
364
 
  std::size_t operator()(const typelib_set_member& t) const
365
 
  {
366
 
    return hasher(t.s);
367
 
  }
368
 
};
369
 
}
370
 
 
371
623
static bool check_duplicates_in_interval(const char *set_or_name,
372
624
                                         const char *name, TYPELIB *typelib,
373
625
                                         const CHARSET_INFO * const cs,
378
630
  unsigned int *cur_length= typelib->type_lengths;
379
631
  *dup_val_count= 0;
380
632
 
381
 
  boost::unordered_set<typelib_set_member, typelib_set_member_hasher> interval_set;
382
 
 
383
 
  for ( ; tmp.count > 0; cur_value++, cur_length++)
 
633
  for ( ; tmp.count > 1; cur_value++, cur_length++)
384
634
  {
385
635
    tmp.type_names++;
386
636
    tmp.type_lengths++;
387
637
    tmp.count--;
388
 
    if (interval_set.find(typelib_set_member(*cur_value, *cur_length, cs)) != interval_set.end())
 
638
    if (find_type2(&tmp, (const char*)*cur_value, *cur_length, cs))
389
639
    {
390
640
      my_error(ER_DUPLICATED_VALUE_IN_TYPE, MYF(0),
391
641
               name,*cur_value,set_or_name);
392
642
      return 1;
393
643
    }
394
 
    else
395
 
      interval_set.insert(typelib_set_member(*cur_value, *cur_length, cs));
396
644
  }
397
645
  return 0;
398
646
}
465
713
 
466
714
  switch (sql_field->sql_type) {
467
715
  case DRIZZLE_TYPE_BLOB:
 
716
    sql_field->pack_flag= pack_length_to_packflag(sql_field->pack_length - portable_sizeof_char_ptr);
468
717
    sql_field->length= 8; // Unireg field length
469
718
    (*blob_columns)++;
470
719
    break;
471
 
 
 
720
  case DRIZZLE_TYPE_VARCHAR:
 
721
    sql_field->pack_flag=0;
 
722
    break;
472
723
  case DRIZZLE_TYPE_ENUM:
473
 
    {
474
 
      if (check_duplicates_in_interval("ENUM",
475
 
                                       sql_field->field_name,
476
 
                                       sql_field->interval,
477
 
                                       sql_field->charset,
478
 
                                       &dup_val_count))
479
 
      {
480
 
        return 1;
481
 
      }
482
 
    }
483
 
    break;
484
 
 
485
 
  case DRIZZLE_TYPE_MICROTIME:
 
724
    sql_field->pack_flag=pack_length_to_packflag(sql_field->pack_length);
 
725
    if (check_duplicates_in_interval("ENUM",
 
726
                                     sql_field->field_name,
 
727
                                     sql_field->interval,
 
728
                                     sql_field->charset,
 
729
                                     &dup_val_count))
 
730
      return 1;
 
731
    break;
 
732
  case DRIZZLE_TYPE_DATE:  // Rest of string types
 
733
  case DRIZZLE_TYPE_DATETIME:
 
734
  case DRIZZLE_TYPE_NULL:
 
735
    sql_field->pack_flag=f_settype((uint32_t) sql_field->sql_type);
 
736
    break;
 
737
  case DRIZZLE_TYPE_DECIMAL:
 
738
    sql_field->pack_flag= 0;
 
739
    break;
486
740
  case DRIZZLE_TYPE_TIMESTAMP:
487
741
    /* We should replace old TIMESTAMP fields with their newer analogs */
488
742
    if (sql_field->unireg_check == Field::TIMESTAMP_OLD_FIELD)
493
747
        (*timestamps_with_niladic)++;
494
748
      }
495
749
      else
496
 
      {
497
750
        sql_field->unireg_check= Field::NONE;
498
 
      }
499
751
    }
500
752
    else if (sql_field->unireg_check != Field::NONE)
501
 
    {
502
753
      (*timestamps_with_niladic)++;
503
 
    }
504
754
 
505
755
    (*timestamps)++;
506
 
 
507
 
    break;
508
 
 
509
 
  case DRIZZLE_TYPE_BOOLEAN:
510
 
  case DRIZZLE_TYPE_DATE:  // Rest of string types
511
 
  case DRIZZLE_TYPE_DATETIME:
512
 
  case DRIZZLE_TYPE_DECIMAL:
513
 
  case DRIZZLE_TYPE_DOUBLE:
514
 
  case DRIZZLE_TYPE_LONG:
515
 
  case DRIZZLE_TYPE_LONGLONG:
516
 
  case DRIZZLE_TYPE_NULL:
517
 
  case DRIZZLE_TYPE_TIME:
518
 
  case DRIZZLE_TYPE_UUID:
519
 
  case DRIZZLE_TYPE_VARCHAR:
 
756
    /* fall-through */
 
757
  default:
 
758
    sql_field->pack_flag=(0 |
 
759
                          f_settype((uint32_t) sql_field->sql_type));
520
760
    break;
521
761
  }
522
 
 
523
762
  return 0;
524
763
}
525
764
 
526
 
static int prepare_create_table(Session *session,
527
 
                                HA_CREATE_INFO *create_info,
528
 
                                message::Table &create_proto,
529
 
                                AlterInfo *alter_info,
530
 
                                bool tmp_table,
531
 
                                uint32_t *db_options,
532
 
                                KeyInfo **key_info_buffer,
533
 
                                uint32_t *key_count,
534
 
                                int select_field_count)
 
765
int mysql_prepare_create_table(Session *session,
 
766
                               HA_CREATE_INFO *create_info,
 
767
                               message::Table *create_proto,
 
768
                               AlterInfo *alter_info,
 
769
                               bool tmp_table,
 
770
                               uint32_t *db_options,
 
771
                               Cursor *cursor,
 
772
                               KEY **key_info_buffer,
 
773
                               uint32_t *key_count,
 
774
                               int select_field_count)
535
775
{
536
776
  const char    *key_name;
537
777
  CreateField   *sql_field,*dup_field;
538
778
  uint          field,null_fields,blob_columns,max_key_length;
539
779
  ulong         record_offset= 0;
540
 
  KeyInfo               *key_info;
541
 
  KeyPartInfo *key_part_info;
 
780
  KEY           *key_info;
 
781
  KEY_PART_INFO *key_part_info;
542
782
  int           timestamps= 0, timestamps_with_niladic= 0;
543
 
  int           dup_no;
 
783
  int           field_no,dup_no;
544
784
  int           select_field_pos,auto_increment=0;
545
785
  List_iterator<CreateField> it(alter_info->create_list);
546
786
  List_iterator<CreateField> it2(alter_info->create_list);
547
787
  uint32_t total_uneven_bit_length= 0;
548
788
 
549
 
  plugin::StorageEngine *engine= plugin::StorageEngine::findByName(create_proto.engine().name());
550
 
 
551
789
  select_field_pos= alter_info->create_list.elements - select_field_count;
552
790
  null_fields=blob_columns=0;
553
 
  max_key_length= engine->max_key_length();
 
791
  max_key_length= cursor->getEngine()->max_key_length();
554
792
 
555
 
  for (int32_t field_no=0; (sql_field=it++) ; field_no++)
 
793
  for (field_no=0; (sql_field=it++) ; field_no++)
556
794
  {
557
795
    const CHARSET_INFO *save_cs;
558
796
 
562
800
      executing a prepared statement for the second time.
563
801
    */
564
802
    sql_field->length= sql_field->char_length;
565
 
 
566
803
    if (!sql_field->charset)
567
804
      sql_field->charset= create_info->default_table_charset;
568
 
 
569
805
    /*
570
806
      table_charset is set in ALTER Table if we want change character set
571
807
      for all varchar/char columns.
618
854
 
619
855
    if (sql_field->sql_type == DRIZZLE_TYPE_ENUM)
620
856
    {
621
 
      size_t dummy;
 
857
      uint32_t dummy;
622
858
      const CHARSET_INFO * const cs= sql_field->charset;
623
859
      TYPELIB *interval= sql_field->interval;
624
860
 
651
887
          if (String::needs_conversion(tmp->length(), tmp->charset(),
652
888
                                       cs, &dummy))
653
889
          {
654
 
            size_t cnv_errs;
 
890
            uint32_t cnv_errs;
655
891
            conv.copy(tmp->ptr(), tmp->length(), tmp->charset(), cs, &cnv_errs);
656
 
            interval->type_names[i]= session->mem_root->strmake_root(conv.ptr(), conv.length());
 
892
            interval->type_names[i]= strmake_root(session->mem_root, conv.ptr(),
 
893
                                                  conv.length());
657
894
            interval->type_lengths[i]= conv.length();
658
895
          }
659
896
 
693
930
            }
694
931
          }
695
932
        }
696
 
        uint32_t new_dummy;
697
 
        calculate_interval_lengths(cs, interval, &field_length, &new_dummy);
 
933
        calculate_interval_lengths(cs, interval, &field_length, &dummy);
698
934
        sql_field->length= field_length;
699
935
      }
700
936
      set_if_smaller(sql_field->length, (uint32_t)MAX_FIELD_WIDTH-1);
758
994
        }
759
995
      }
760
996
    }
761
 
 
762
 
    /** @todo Get rid of this MyISAM-specific crap. */
763
 
    if (not create_proto.engine().name().compare("MyISAM") &&
764
 
        ((sql_field->flags & BLOB_FLAG) ||
765
 
         (sql_field->sql_type == DRIZZLE_TYPE_VARCHAR)))
766
 
    {
 
997
    /* Don't pack rows in old tables if the user has requested this */
 
998
    if ((sql_field->flags & BLOB_FLAG) ||
 
999
        (sql_field->sql_type == DRIZZLE_TYPE_VARCHAR && create_info->row_type != ROW_TYPE_FIXED))
767
1000
      (*db_options)|= HA_OPTION_PACK_RECORD;
768
 
    }
769
 
 
770
1001
    it2.rewind();
771
1002
  }
772
1003
 
798
1029
    return(true);
799
1030
  }
800
1031
  if (auto_increment &&
801
 
      (engine->check_flag(HTON_BIT_NO_AUTO_INCREMENT)))
 
1032
      (cursor->getEngine()->check_flag(HTON_BIT_NO_AUTO_INCREMENT)))
802
1033
  {
803
1034
    my_message(ER_TABLE_CANT_HANDLE_AUTO_INCREMENT,
804
1035
               ER(ER_TABLE_CANT_HANDLE_AUTO_INCREMENT), MYF(0));
805
1036
    return(true);
806
1037
  }
807
1038
 
808
 
  if (blob_columns && (engine->check_flag(HTON_BIT_NO_BLOBS)))
 
1039
  if (blob_columns && (cursor->getEngine()->check_flag(HTON_BIT_NO_BLOBS)))
809
1040
  {
810
1041
    my_message(ER_TABLE_CANT_HANDLE_BLOB, ER(ER_TABLE_CANT_HANDLE_BLOB),
811
1042
               MYF(0));
833
1064
      fk_key_count++;
834
1065
      if (((Foreign_key *)key)->validate(alter_info->create_list))
835
1066
        return true;
836
 
 
837
1067
      Foreign_key *fk_key= (Foreign_key*) key;
838
 
 
839
 
      add_foreign_key_to_table_message(&create_proto,
840
 
                                       fk_key->name.str,
841
 
                                       fk_key->columns,
842
 
                                       fk_key->ref_table,
843
 
                                       fk_key->ref_columns,
844
 
                                       fk_key->delete_opt,
845
 
                                       fk_key->update_opt,
846
 
                                       fk_key->match_opt);
847
 
 
848
1068
      if (fk_key->ref_columns.elements &&
849
1069
          fk_key->ref_columns.elements != fk_key->columns.elements)
850
1070
      {
857
1077
      continue;
858
1078
    }
859
1079
    (*key_count)++;
860
 
    tmp= engine->max_key_parts();
 
1080
    tmp=cursor->getEngine()->max_key_parts();
861
1081
    if (key->columns.elements > tmp)
862
1082
    {
863
1083
      my_error(ER_TOO_MANY_KEY_PARTS,MYF(0),tmp);
879
1099
             key2->name.str != ignore_key &&
880
1100
             !foreign_key_prefix(key, key2)))
881
1101
        {
882
 
          /* @todo issue warning message */
 
1102
          /* TODO: issue warning message */
883
1103
          /* mark that the generated key should be ignored */
884
1104
          if (!key2->generated ||
885
1105
              (key->generated && key->columns.elements <
906
1126
      return(true);
907
1127
    }
908
1128
  }
909
 
  tmp= engine->max_keys();
 
1129
  tmp=cursor->getEngine()->max_keys();
910
1130
  if (*key_count > tmp)
911
1131
  {
912
1132
    my_error(ER_TOO_MANY_KEYS,MYF(0),tmp);
913
1133
    return(true);
914
1134
  }
915
1135
 
916
 
  (*key_info_buffer)= key_info= (KeyInfo*) memory::sql_calloc(sizeof(KeyInfo) * (*key_count));
917
 
  key_part_info=(KeyPartInfo*) memory::sql_calloc(sizeof(KeyPartInfo)*key_parts);
 
1136
  (*key_info_buffer)= key_info= (KEY*) sql_calloc(sizeof(KEY) * (*key_count));
 
1137
  key_part_info=(KEY_PART_INFO*) sql_calloc(sizeof(KEY_PART_INFO)*key_parts);
918
1138
  if (!*key_info_buffer || ! key_part_info)
919
1139
    return(true);                               // Out of memory
920
1140
 
954
1174
    key_info->usable_key_parts= key_number;
955
1175
    key_info->algorithm= key->key_create_info.algorithm;
956
1176
 
 
1177
    /* Take block size from key part or table part */
 
1178
    /*
 
1179
      TODO: Add warning if block size changes. We can't do it here, as
 
1180
      this may depend on the size of the key
 
1181
    */
 
1182
    key_info->block_size= (key->key_create_info.block_size ?
 
1183
                           key->key_create_info.block_size :
 
1184
                           create_proto->options().key_block_size());
 
1185
 
 
1186
    if (key_info->block_size)
 
1187
      key_info->flags|= HA_USES_BLOCK_SIZE;
 
1188
 
957
1189
    uint32_t tmp_len= system_charset_info->cset->charpos(system_charset_info,
958
1190
                                           key->key_create_info.comment.str,
959
1191
                                           key->key_create_info.comment.str +
990
1222
             my_strcasecmp(system_charset_info,
991
1223
                           column->field_name.str,
992
1224
                           sql_field->field_name))
993
 
      {
994
1225
        field++;
995
 
      }
996
 
 
997
1226
      if (!sql_field)
998
1227
      {
999
1228
        my_error(ER_KEY_COLUMN_DOES_NOT_EXITS, MYF(0), column->field_name.str);
1000
1229
        return(true);
1001
1230
      }
1002
 
 
1003
1231
      while ((dup_column= cols2++) != column)
1004
1232
      {
1005
1233
        if (!my_strcasecmp(system_charset_info,
1013
1241
      }
1014
1242
      cols2.rewind();
1015
1243
 
1016
 
      if (create_proto.field_size() > 0)
1017
 
        protofield= create_proto.mutable_field(proto_field_nr - 1);
 
1244
      if (create_proto->field_size() > 0)
 
1245
        protofield= create_proto->mutable_field(proto_field_nr - 1);
1018
1246
 
1019
1247
      {
1020
1248
        column->length*= sql_field->charset->mbmaxlen;
1021
1249
 
1022
1250
        if (sql_field->sql_type == DRIZZLE_TYPE_BLOB)
1023
1251
        {
1024
 
          if (! (engine->check_flag(HTON_BIT_CAN_INDEX_BLOBS)))
 
1252
          if (! (cursor->getEngine()->check_flag(HTON_BIT_CAN_INDEX_BLOBS)))
1025
1253
          {
1026
1254
            my_error(ER_BLOB_USED_AS_KEY, MYF(0), column->field_name.str);
1027
1255
            return true;
1032
1260
            return true;
1033
1261
          }
1034
1262
        }
1035
 
 
1036
1263
        if (! (sql_field->flags & NOT_NULL_FLAG))
1037
1264
        {
1038
1265
          if (key->type == Key::PRIMARY)
1045
1272
            {
1046
1273
              message::Table::Field::FieldConstraints *constraints;
1047
1274
              constraints= protofield->mutable_constraints();
1048
 
              constraints->set_is_notnull(true);
 
1275
              constraints->set_is_nullable(false);
1049
1276
            }
1050
1277
 
1051
1278
          }
1052
1279
          else
1053
1280
          {
1054
1281
            key_info->flags|= HA_NULL_PART_KEY;
1055
 
            if (! (engine->check_flag(HTON_BIT_NULL_IN_KEY)))
 
1282
            if (! (cursor->getEngine()->check_flag(HTON_BIT_NULL_IN_KEY)))
1056
1283
            {
1057
1284
              my_error(ER_NULL_COLUMN_IN_INDEX, MYF(0), column->field_name.str);
1058
1285
              return true;
1059
1286
            }
1060
1287
          }
1061
1288
        }
1062
 
 
1063
1289
        if (MTYP_TYPENR(sql_field->unireg_check) == Field::NEXT_NUMBER)
1064
1290
        {
1065
 
          if (column_nr == 0 || (engine->check_flag(HTON_BIT_AUTO_PART_KEY)))
 
1291
          if (column_nr == 0 || (cursor->getEngine()->check_flag(HTON_BIT_AUTO_PART_KEY)))
1066
1292
            auto_increment--;                   // Field is used
1067
1293
        }
1068
1294
      }
1069
1295
 
1070
1296
      key_part_info->fieldnr= field;
1071
1297
      key_part_info->offset=  (uint16_t) sql_field->offset;
1072
 
      key_part_info->key_type= 0;
 
1298
      key_part_info->key_type=sql_field->pack_flag;
1073
1299
      length= sql_field->key_length;
1074
1300
 
1075
1301
      if (column->length)
1077
1303
        if (sql_field->sql_type == DRIZZLE_TYPE_BLOB)
1078
1304
        {
1079
1305
          if ((length=column->length) > max_key_length ||
1080
 
              length > engine->max_key_part_length())
 
1306
              length > cursor->getEngine()->max_key_part_length())
1081
1307
          {
1082
 
            length= min(max_key_length, engine->max_key_part_length());
 
1308
            length= min(max_key_length, cursor->getEngine()->max_key_part_length());
1083
1309
            if (key->type == Key::MULTIPLE)
1084
1310
            {
1085
1311
              /* not a critical problem */
1104
1330
          my_message(ER_WRONG_SUB_KEY, ER(ER_WRONG_SUB_KEY), MYF(0));
1105
1331
          return(true);
1106
1332
        }
1107
 
        else if (! (engine->check_flag(HTON_BIT_NO_PREFIX_CHAR_KEYS)))
 
1333
        else if (! (cursor->getEngine()->check_flag(HTON_BIT_NO_PREFIX_CHAR_KEYS)))
1108
1334
        {
1109
1335
          length=column->length;
1110
1336
        }
1114
1340
        my_error(ER_WRONG_KEY_COLUMN, MYF(0), column->field_name.str);
1115
1341
          return(true);
1116
1342
      }
1117
 
      if (length > engine->max_key_part_length())
 
1343
      if (length > cursor->getEngine()->max_key_part_length())
1118
1344
      {
1119
 
        length= engine->max_key_part_length();
 
1345
        length= cursor->getEngine()->max_key_part_length();
1120
1346
        if (key->type == Key::MULTIPLE)
1121
1347
        {
1122
1348
          /* not a critical problem */
1137
1363
      key_part_info->length=(uint16_t) length;
1138
1364
      /* Use packed keys for long strings on the first column */
1139
1365
      if (!((*db_options) & HA_OPTION_NO_PACK_KEYS) &&
1140
 
          (length >= KEY_DEFAULT_PACK_LENGTH &&
1141
 
           (sql_field->sql_type == DRIZZLE_TYPE_VARCHAR ||
1142
 
            sql_field->sql_type == DRIZZLE_TYPE_BLOB)))
 
1366
          (length >= KEY_DEFAULT_PACK_LENGTH &&
 
1367
           (sql_field->sql_type == DRIZZLE_TYPE_VARCHAR ||
 
1368
      sql_field->sql_type == DRIZZLE_TYPE_BLOB)))
1143
1369
      {
1144
1370
        if ((column_nr == 0 && sql_field->sql_type == DRIZZLE_TYPE_BLOB) ||
1145
1371
            sql_field->sql_type == DRIZZLE_TYPE_VARCHAR)
1146
 
        {
1147
1372
          key_info->flags|= HA_BINARY_PACK_KEY | HA_VAR_LENGTH_KEY;
1148
 
        }
1149
1373
        else
1150
 
        {
1151
1374
          key_info->flags|= HA_PACK_KEY;
1152
 
        }
1153
1375
      }
1154
1376
      /* Check if the key segment is partial, set the key flag accordingly */
1155
1377
      if (length != sql_field->key_length)
1184
1406
        key_info->name=(char*) key_name;
1185
1407
      }
1186
1408
    }
1187
 
 
1188
1409
    if (!key_info->name || check_column_name(key_info->name))
1189
1410
    {
1190
1411
      my_error(ER_WRONG_NAME_FOR_INDEX, MYF(0), key_info->name);
1191
1412
      return(true);
1192
1413
    }
1193
 
 
1194
1414
    if (!(key_info->flags & HA_NULL_PART_KEY))
1195
 
    {
1196
1415
      unique_key=1;
1197
 
    }
1198
 
 
1199
1416
    key_info->key_length=(uint16_t) key_length;
1200
 
 
1201
1417
    if (key_length > max_key_length)
1202
1418
    {
1203
1419
      my_error(ER_TOO_LONG_KEY,MYF(0),max_key_length);
1204
1420
      return(true);
1205
1421
    }
1206
 
 
1207
1422
    key_info++;
1208
1423
  }
1209
 
 
1210
1424
  if (!unique_key && !primary_key &&
1211
 
      (engine->check_flag(HTON_BIT_REQUIRE_PRIMARY_KEY)))
 
1425
      (cursor->getEngine()->check_flag(HTON_BIT_REQUIRE_PRIMARY_KEY)))
1212
1426
  {
1213
1427
    my_message(ER_REQUIRES_PRIMARY_KEY, ER(ER_REQUIRES_PRIMARY_KEY), MYF(0));
1214
1428
    return(true);
1215
1429
  }
1216
 
 
1217
1430
  if (auto_increment > 0)
1218
1431
  {
1219
1432
    my_message(ER_WRONG_AUTO_KEY, ER(ER_WRONG_AUTO_KEY), MYF(0));
1220
1433
    return(true);
1221
1434
  }
1222
1435
  /* Sort keys in optimized order */
1223
 
  internal::my_qsort((unsigned char*) *key_info_buffer, *key_count, sizeof(KeyInfo),
1224
 
                     (qsort_cmp) sort_keys);
 
1436
  my_qsort((unsigned char*) *key_info_buffer, *key_count, sizeof(KEY),
 
1437
           (qsort_cmp) sort_keys);
1225
1438
 
1226
1439
  /* Check fields. */
1227
1440
  it.rewind();
1294
1507
  return 0;
1295
1508
}
1296
1509
 
1297
 
static bool locked_create_event(Session *session,
1298
 
                                const identifier::Table &identifier,
1299
 
                                HA_CREATE_INFO *create_info,
1300
 
                                message::Table &table_proto,
1301
 
                                AlterInfo *alter_info,
1302
 
                                bool is_if_not_exists,
1303
 
                                bool internal_tmp_table,
1304
 
                                uint db_options,
1305
 
                                uint key_count,
1306
 
                                KeyInfo *key_info_buffer)
1307
 
{
1308
 
  bool error= true;
1309
 
 
1310
 
  {
1311
 
 
1312
 
    /*
1313
 
      @note if we are building a temp table we need to check to see if a temp table
1314
 
      already exists, otherwise we just need to find out if a normal table exists (aka it is fine
1315
 
      to create a table under a temporary table.
1316
 
    */
1317
 
    bool exists= 
1318
 
      plugin::StorageEngine::doesTableExist(*session, identifier, 
1319
 
                                            identifier.getType() != message::Table::STANDARD );
1320
 
 
1321
 
    if (exists)
1322
 
    {
1323
 
      if (is_if_not_exists)
1324
 
      {
1325
 
        error= false;
1326
 
        push_warning_printf(session, DRIZZLE_ERROR::WARN_LEVEL_NOTE,
1327
 
                            ER_TABLE_EXISTS_ERROR, ER(ER_TABLE_EXISTS_ERROR),
1328
 
                            identifier.getTableName().c_str());
1329
 
        create_info->table_existed= 1;          // Mark that table existed
1330
 
        return error;
1331
 
      }
1332
 
 
1333
 
      my_error(ER_TABLE_EXISTS_ERROR, identifier);
1334
 
 
1335
 
      return error;
1336
 
    }
1337
 
 
1338
 
    if (identifier.getType() == message::Table::STANDARD) // We have a real table
1339
 
    {
1340
 
      /*
1341
 
        We don't assert here, but check the result, because the table could be
1342
 
        in the table definition cache and in the same time the .frm could be
1343
 
        missing from the disk, in case of manual intervention which deletes
1344
 
        the .frm cursor. The user has to use FLUSH TABLES; to clear the cache.
1345
 
        Then she could create the table. This case is pretty obscure and
1346
 
        therefore we don't introduce a new error message only for it.
1347
 
      */
1348
 
      /*
1349
 
        @todo improve this error condition.
1350
 
      */
1351
 
      if (definition::Cache::singleton().find(identifier.getKey()))
1352
 
      {
1353
 
        my_error(ER_TABLE_EXISTS_ERROR, identifier);
1354
 
 
1355
 
        return error;
1356
 
      }
1357
 
    }
1358
 
  }
1359
 
 
1360
 
  session->set_proc_info("creating table");
1361
 
  create_info->table_existed= 0;                // Mark that table is created
1362
 
 
1363
 
  create_info->table_options= db_options;
1364
 
 
1365
 
  if (not rea_create_table(session, identifier,
1366
 
                           table_proto,
1367
 
                           create_info, alter_info->create_list,
1368
 
                           key_count, key_info_buffer))
1369
 
  {
1370
 
    return error;
1371
 
  }
1372
 
 
1373
 
  if (identifier.getType() == message::Table::TEMPORARY)
1374
 
  {
1375
 
    /* Open table and put in temporary table list */
1376
 
    if (not (session->open_temporary_table(identifier)))
1377
 
    {
1378
 
      (void) session->rm_temporary_table(identifier);
1379
 
      return error;
1380
 
    }
1381
 
  }
1382
 
 
1383
 
  /* 
1384
 
    We keep this behind the lock to make sure ordering is correct for a table.
1385
 
    This is a very unlikely problem where before we would write out to the
1386
 
    trans log, someone would do a delete/create operation.
1387
 
  */
1388
 
 
1389
 
  if (table_proto.type() == message::Table::STANDARD && not internal_tmp_table)
1390
 
  {
1391
 
    TransactionServices &transaction_services= TransactionServices::singleton();
1392
 
    transaction_services.createTable(*session, table_proto);
1393
 
  }
1394
 
 
1395
 
  return false;
1396
 
}
1397
 
 
1398
1510
 
1399
1511
/*
1400
1512
  Ignore the name of this function... it locks :(
1402
1514
  Create a table
1403
1515
 
1404
1516
  SYNOPSIS
1405
 
    create_table_no_lock()
 
1517
    mysql_create_table_no_lock()
1406
1518
    session                     Thread object
1407
1519
    db                  Database
1408
1520
    table_name          Table name
1418
1530
 
1419
1531
    Note that this function assumes that caller already have taken
1420
1532
    name-lock on table being created or used some other way to ensure
1421
 
    that concurrent operations won't intervene. create_table()
 
1533
    that concurrent operations won't intervene. mysql_create_table()
1422
1534
    is a wrapper that can be used for this.
1423
1535
 
1424
1536
  RETURN VALUES
1426
1538
    true  error
1427
1539
*/
1428
1540
 
1429
 
bool create_table_no_lock(Session *session,
1430
 
                                const identifier::Table &identifier,
 
1541
bool mysql_create_table_no_lock(Session *session,
 
1542
                                TableIdentifier &identifier,
1431
1543
                                HA_CREATE_INFO *create_info,
1432
 
                                message::Table &table_proto,
 
1544
                                message::Table *table_proto,
1433
1545
                                AlterInfo *alter_info,
1434
1546
                                bool internal_tmp_table,
1435
1547
                                uint32_t select_field_count,
1436
1548
                                bool is_if_not_exists)
1437
1549
{
1438
1550
  uint          db_options, key_count;
1439
 
  KeyInfo               *key_info_buffer;
 
1551
  KEY           *key_info_buffer;
 
1552
  Cursor        *cursor;
1440
1553
  bool          error= true;
 
1554
  TableShare share;
 
1555
  bool lex_identified_temp_table=
 
1556
    (table_proto->type() == drizzled::message::Table::TEMPORARY);
1441
1557
 
1442
1558
  /* Check for duplicate fields and check type of table to create */
1443
 
  if (not alter_info->create_list.elements)
 
1559
  if (!alter_info->create_list.elements)
1444
1560
  {
1445
1561
    my_message(ER_TABLE_MUST_HAVE_COLUMNS, ER(ER_TABLE_MUST_HAVE_COLUMNS),
1446
1562
               MYF(0));
1447
1563
    return true;
1448
1564
  }
1449
 
  assert(identifier.getTableName() == table_proto.name());
 
1565
  assert(strcmp(identifier.getTableName(), table_proto->name().c_str())==0);
1450
1566
  db_options= create_info->table_options;
1451
 
 
1452
 
  set_table_default_charset(create_info, identifier.getSchemaName().c_str());
1453
 
 
1454
 
  /* Build a Table object to pass down to the engine, and the do the actual create. */
1455
 
  if (not prepare_create_table(session, create_info, table_proto, alter_info,
1456
 
                               internal_tmp_table,
1457
 
                               &db_options,
1458
 
                               &key_info_buffer, &key_count,
1459
 
                               select_field_count))
1460
 
  {
1461
 
    boost_unique_lock_t lock(table::Cache::singleton().mutex()); /* CREATE TABLE (some confussion on naming, double check) */
1462
 
    error= locked_create_event(session,
1463
 
                               identifier,
1464
 
                               create_info,
1465
 
                               table_proto,
1466
 
                               alter_info,
1467
 
                               is_if_not_exists,
1468
 
                               internal_tmp_table,
1469
 
                               db_options, key_count,
1470
 
                               key_info_buffer);
1471
 
  }
1472
 
 
1473
 
  session->set_proc_info("After create");
1474
 
 
1475
 
  return(error);
1476
 
}
1477
 
 
1478
 
/**
1479
 
  @note the following two methods implement create [temporary] table.
1480
 
*/
1481
 
static bool drizzle_create_table(Session *session,
1482
 
                                 const identifier::Table &identifier,
1483
 
                                 HA_CREATE_INFO *create_info,
1484
 
                                 message::Table &table_proto,
1485
 
                                 AlterInfo *alter_info,
1486
 
                                 bool internal_tmp_table,
1487
 
                                 uint32_t select_field_count,
1488
 
                                 bool is_if_not_exists)
1489
 
{
1490
 
  Table *name_lock= NULL;
1491
 
  bool result;
1492
 
 
1493
 
  if (session->lock_table_name_if_not_cached(identifier, &name_lock))
1494
 
  {
1495
 
    result= true;
1496
 
  }
1497
 
  else if (name_lock == NULL)
 
1567
  if (create_info->row_type == ROW_TYPE_DYNAMIC)
 
1568
    db_options|=HA_OPTION_PACK_RECORD;
 
1569
  if (!(cursor= create_info->db_type->getCursor(share, session->mem_root)))
 
1570
  {
 
1571
    my_error(ER_OUTOFMEMORY, MYF(0), sizeof(Cursor));
 
1572
    return true;
 
1573
  }
 
1574
 
 
1575
  set_table_default_charset(create_info, identifier.getDBName());
 
1576
 
 
1577
  /* Check if table exists */
 
1578
  if (mysql_prepare_create_table(session, create_info, table_proto, alter_info,
 
1579
                                 internal_tmp_table,
 
1580
                                 &db_options, cursor,
 
1581
                                 &key_info_buffer, &key_count,
 
1582
                                 select_field_count))
 
1583
    goto err;
 
1584
 
 
1585
  /* Check if table already exists */
 
1586
  if (lex_identified_temp_table &&
 
1587
      session->find_temporary_table(identifier.getDBName(), identifier.getTableName()))
1498
1588
  {
1499
1589
    if (is_if_not_exists)
1500
1590
    {
 
1591
      create_info->table_existed= 1;            // Mark that table existed
1501
1592
      push_warning_printf(session, DRIZZLE_ERROR::WARN_LEVEL_NOTE,
1502
1593
                          ER_TABLE_EXISTS_ERROR, ER(ER_TABLE_EXISTS_ERROR),
1503
 
                          identifier.getTableName().c_str());
1504
 
      create_info->table_existed= 1;
1505
 
      result= false;
1506
 
    }
1507
 
    else
1508
 
    {
1509
 
      my_error(ER_TABLE_EXISTS_ERROR, identifier);
1510
 
      result= true;
1511
 
    }
1512
 
  }
1513
 
  else
1514
 
  {
1515
 
    result= create_table_no_lock(session,
1516
 
                                       identifier,
1517
 
                                       create_info,
1518
 
                                       table_proto,
1519
 
                                       alter_info,
1520
 
                                       internal_tmp_table,
1521
 
                                       select_field_count,
1522
 
                                       is_if_not_exists);
1523
 
  }
1524
 
 
1525
 
  if (name_lock)
1526
 
  {
1527
 
    boost_unique_lock_t lock(table::Cache::singleton().mutex()); /* Lock for removing name_lock during table create */
1528
 
    session->unlink_open_table(name_lock);
1529
 
  }
1530
 
 
1531
 
  return(result);
 
1594
                          identifier.getTableName());
 
1595
      error= 0;
 
1596
      goto err;
 
1597
    }
 
1598
    my_error(ER_TABLE_EXISTS_ERROR, MYF(0), identifier.getTableName());
 
1599
    goto err;
 
1600
  }
 
1601
 
 
1602
  pthread_mutex_lock(&LOCK_open); /* CREATE TABLE (some confussion on naming, double check) */
 
1603
  if (!internal_tmp_table && ! lex_identified_temp_table)
 
1604
  {
 
1605
    if (plugin::StorageEngine::getTableDefinition(*session,
 
1606
                                                  identifier)==EEXIST)
 
1607
    {
 
1608
      if (is_if_not_exists)
 
1609
      {
 
1610
        error= false;
 
1611
        push_warning_printf(session, DRIZZLE_ERROR::WARN_LEVEL_NOTE,
 
1612
                            ER_TABLE_EXISTS_ERROR, ER(ER_TABLE_EXISTS_ERROR),
 
1613
                            identifier.getTableName());
 
1614
        create_info->table_existed= 1;          // Mark that table existed
 
1615
      }
 
1616
      else 
 
1617
        my_error(ER_TABLE_EXISTS_ERROR, MYF(0), identifier.getTableName());
 
1618
 
 
1619
      goto unlock_and_end;
 
1620
    }
 
1621
    /*
 
1622
      We don't assert here, but check the result, because the table could be
 
1623
      in the table definition cache and in the same time the .frm could be
 
1624
      missing from the disk, in case of manual intervention which deletes
 
1625
      the .frm cursor. The user has to use FLUSH TABLES; to clear the cache.
 
1626
      Then she could create the table. This case is pretty obscure and
 
1627
      therefore we don't introduce a new error message only for it.
 
1628
    */
 
1629
    if (TableShare::getShare(identifier.getDBName(), identifier.getTableName()))
 
1630
    {
 
1631
      my_error(ER_TABLE_EXISTS_ERROR, MYF(0), identifier.getTableName());
 
1632
      goto unlock_and_end;
 
1633
    }
 
1634
  }
 
1635
 
 
1636
  /*
 
1637
    Check that table with given name does not already
 
1638
    exist in any storage engine. In such a case it should
 
1639
    be discovered and the error ER_TABLE_EXISTS_ERROR be returned
 
1640
    unless user specified CREATE TABLE IF EXISTS
 
1641
    The LOCK_open mutex has been locked to make sure no
 
1642
    one else is attempting to discover the table. Since
 
1643
    it's not on disk as a frm cursor, no one could be using it!
 
1644
  */
 
1645
  if (! lex_identified_temp_table)
 
1646
  {
 
1647
    int retcode= plugin::StorageEngine::getTableDefinition(*session, identifier);
 
1648
 
 
1649
    switch (retcode)
 
1650
    {
 
1651
      case ENOENT:
 
1652
        /* Normal case, no table exists. we can go and create it */
 
1653
        break;
 
1654
      case EEXIST:
 
1655
        if (is_if_not_exists)
 
1656
        {
 
1657
          error= false;
 
1658
          push_warning_printf(session, DRIZZLE_ERROR::WARN_LEVEL_NOTE,
 
1659
                              ER_TABLE_EXISTS_ERROR, ER(ER_TABLE_EXISTS_ERROR),
 
1660
                              identifier.getTableName());
 
1661
          create_info->table_existed= 1;                // Mark that table existed
 
1662
          goto unlock_and_end;
 
1663
        }
 
1664
        my_error(ER_TABLE_EXISTS_ERROR, MYF(0), identifier.getTableName());
 
1665
        goto unlock_and_end;
 
1666
      default:
 
1667
        my_error(retcode, MYF(0), identifier.getTableName());
 
1668
        goto unlock_and_end;
 
1669
    }
 
1670
  }
 
1671
 
 
1672
  session->set_proc_info("creating table");
 
1673
  create_info->table_existed= 0;                // Mark that table is created
 
1674
 
 
1675
  create_info->table_options= db_options;
 
1676
 
 
1677
  if (rea_create_table(session, identifier,
 
1678
                       table_proto,
 
1679
                       create_info, alter_info->create_list,
 
1680
                       key_count, key_info_buffer))
 
1681
    goto unlock_and_end;
 
1682
 
 
1683
  if (lex_identified_temp_table)
 
1684
  {
 
1685
    /* Open table and put in temporary table list */
 
1686
    if (!(session->open_temporary_table(identifier)))
 
1687
    {
 
1688
      (void) session->rm_temporary_table(create_info->db_type, identifier);
 
1689
      goto unlock_and_end;
 
1690
    }
 
1691
  }
 
1692
 
 
1693
  /*
 
1694
    Don't write statement if:
 
1695
    - It is an internal temporary table,
 
1696
    - Row-based logging is used and it we are creating a temporary table, or
 
1697
    - The binary log is not open.
 
1698
    Otherwise, the statement shall be binlogged.
 
1699
   */
 
1700
  if (!internal_tmp_table && ! lex_identified_temp_table)
 
1701
    write_bin_log(session, session->query, session->query_length);
 
1702
  error= false;
 
1703
unlock_and_end:
 
1704
  pthread_mutex_unlock(&LOCK_open);
 
1705
 
 
1706
err:
 
1707
  session->set_proc_info("After create");
 
1708
  delete cursor;
 
1709
  return(error);
1532
1710
}
1533
1711
 
1534
1712
 
1535
1713
/*
1536
 
  Database locking aware wrapper for create_table_no_lock(),
 
1714
  Database locking aware wrapper for mysql_create_table_no_lock(),
1537
1715
*/
1538
 
bool create_table(Session *session,
1539
 
                        const identifier::Table &identifier,
 
1716
 
 
1717
bool mysql_create_table(Session *session,
 
1718
                        TableIdentifier &identifier,
1540
1719
                        HA_CREATE_INFO *create_info,
1541
 
                        message::Table &table_proto,
 
1720
                        message::Table *table_proto,
1542
1721
                        AlterInfo *alter_info,
1543
1722
                        bool internal_tmp_table,
1544
1723
                        uint32_t select_field_count,
1545
1724
                        bool is_if_not_exists)
1546
1725
{
1547
 
  if (identifier.isTmp())
1548
 
  {
1549
 
    return create_table_no_lock(session,
1550
 
                                      identifier,
1551
 
                                      create_info,
1552
 
                                      table_proto,
1553
 
                                      alter_info,
1554
 
                                      internal_tmp_table,
1555
 
                                      select_field_count,
1556
 
                                      is_if_not_exists);
1557
 
  }
1558
 
 
1559
 
  return drizzle_create_table(session,
1560
 
                              identifier,
1561
 
                              create_info,
1562
 
                              table_proto,
1563
 
                              alter_info,
1564
 
                              internal_tmp_table,
1565
 
                              select_field_count,
1566
 
                              is_if_not_exists);
 
1726
  Table *name_lock= NULL;
 
1727
  bool result;
 
1728
  bool lex_identified_temp_table=
 
1729
    (table_proto->type() == drizzled::message::Table::TEMPORARY);
 
1730
 
 
1731
  if (! lex_identified_temp_table)
 
1732
  {
 
1733
    if (session->lock_table_name_if_not_cached(identifier.getDBName(),
 
1734
                                               identifier.getTableName(),
 
1735
                                               &name_lock))
 
1736
    {
 
1737
      result= true;
 
1738
      goto unlock;
 
1739
    }
 
1740
    if (name_lock == NULL)
 
1741
    {
 
1742
      if (is_if_not_exists)
 
1743
      {
 
1744
        push_warning_printf(session, DRIZZLE_ERROR::WARN_LEVEL_NOTE,
 
1745
                            ER_TABLE_EXISTS_ERROR, ER(ER_TABLE_EXISTS_ERROR),
 
1746
                            identifier.getTableName());
 
1747
        create_info->table_existed= 1;
 
1748
        result= false;
 
1749
      }
 
1750
      else
 
1751
      {
 
1752
        my_error(ER_TABLE_EXISTS_ERROR, MYF(0), identifier.getTableName());
 
1753
        result= true;
 
1754
      }
 
1755
      goto unlock;
 
1756
    }
 
1757
  }
 
1758
 
 
1759
  result= mysql_create_table_no_lock(session,
 
1760
                                     identifier,
 
1761
                                     create_info,
 
1762
                                     table_proto,
 
1763
                                     alter_info,
 
1764
                                     internal_tmp_table,
 
1765
                                     select_field_count,
 
1766
                                     is_if_not_exists);
 
1767
 
 
1768
unlock:
 
1769
  if (name_lock)
 
1770
  {
 
1771
    pthread_mutex_lock(&LOCK_open); /* Lock for removing name_lock during table create */
 
1772
    session->unlink_open_table(name_lock);
 
1773
    pthread_mutex_unlock(&LOCK_open);
 
1774
  }
 
1775
 
 
1776
  return(result);
1567
1777
}
1568
1778
 
1569
1779
 
1572
1782
**/
1573
1783
 
1574
1784
static bool
1575
 
check_if_keyname_exists(const char *name, KeyInfo *start, KeyInfo *end)
 
1785
check_if_keyname_exists(const char *name, KEY *start, KEY *end)
1576
1786
{
1577
 
  for (KeyInfo *key=start ; key != end ; key++)
 
1787
  for (KEY *key=start ; key != end ; key++)
1578
1788
    if (!my_strcasecmp(system_charset_info,name,key->name))
1579
1789
      return 1;
1580
1790
  return 0;
1582
1792
 
1583
1793
 
1584
1794
static char *
1585
 
make_unique_key_name(const char *field_name,KeyInfo *start,KeyInfo *end)
 
1795
make_unique_key_name(const char *field_name,KEY *start,KEY *end)
1586
1796
{
1587
1797
  char buff[MAX_FIELD_NAME],*buff_end;
1588
1798
 
1600
1810
  for (uint32_t i=2 ; i< 100; i++)
1601
1811
  {
1602
1812
    *buff_end= '_';
1603
 
    internal::int10_to_str(i, buff_end+1, 10);
 
1813
    int10_to_str(i, buff_end+1, 10);
1604
1814
    if (!check_if_keyname_exists(buff,start,end))
1605
 
      return memory::sql_strdup(buff);
 
1815
      return sql_strdup(buff);
1606
1816
  }
1607
1817
  return (char*) "not_specified";               // Should never happen
1608
1818
}
1616
1826
  Rename a table.
1617
1827
 
1618
1828
  SYNOPSIS
1619
 
    rename_table()
1620
 
      session
 
1829
    mysql_rename_table()
1621
1830
      base                      The plugin::StorageEngine handle.
1622
1831
      old_db                    The old database name.
1623
1832
      old_name                  The old table name.
1624
1833
      new_db                    The new database name.
1625
1834
      new_name                  The new table name.
 
1835
      flags                     flags for build_table_filename().
 
1836
                                FN_FROM_IS_TMP old_name is temporary.
 
1837
                                FN_TO_IS_TMP   new_name is temporary.
1626
1838
 
1627
1839
  RETURN
1628
1840
    false   OK
1630
1842
*/
1631
1843
 
1632
1844
bool
1633
 
rename_table(Session &session,
1634
 
                   plugin::StorageEngine *base,
1635
 
                   const identifier::Table &from,
1636
 
                   const identifier::Table &to)
 
1845
mysql_rename_table(plugin::StorageEngine *base, const char *old_db,
 
1846
                   const char *old_name, const char *new_db,
 
1847
                   const char *new_name, uint32_t flags)
1637
1848
{
 
1849
  Session *session= current_session;
 
1850
  char from[FN_REFLEN], to[FN_REFLEN];
 
1851
  char *from_base= from, *to_base= to;
1638
1852
  int error= 0;
1639
1853
 
1640
1854
  assert(base);
1641
1855
 
1642
 
  if (not plugin::StorageEngine::doesSchemaExist(to))
 
1856
  build_table_filename(from, sizeof(from), old_db, old_name,
 
1857
                       flags & FN_FROM_IS_TMP);
 
1858
  build_table_filename(to, sizeof(to), new_db, new_name,
 
1859
                       flags & FN_TO_IS_TMP);
 
1860
 
 
1861
  if (!(error= base->renameTable(session, from_base, to_base)))
1643
1862
  {
1644
 
    my_error(ER_NO_DB_ERROR, MYF(0), to.getSchemaName().c_str());
1645
 
    return true;
 
1863
    if (base->check_flag(HTON_BIT_HAS_DATA_DICTIONARY) == 0
 
1864
       && rename_table_proto_file(from_base, to_base))
 
1865
    {
 
1866
      error= my_errno;
 
1867
      base->renameTable(session, to_base, from_base);
 
1868
    }
1646
1869
  }
1647
1870
 
1648
 
  error= base->renameTable(session, from, to);
1649
 
 
1650
1871
  if (error == HA_ERR_WRONG_COMMAND)
1651
 
  {
1652
1872
    my_error(ER_NOT_SUPPORTED_YET, MYF(0), "ALTER Table");
1653
 
  }
1654
1873
  else if (error)
1655
 
  {
1656
 
    std::string from_path;
1657
 
    std::string to_path;
1658
 
 
1659
 
    from.getSQLPath(from_path);
1660
 
    to.getSQLPath(to_path);
1661
 
 
1662
 
    const char *from_identifier= from.isTmp() ? "#sql-temporary" : from_path.c_str();
1663
 
    const char *to_identifier= to.isTmp() ? "#sql-temporary" : to_path.c_str();
1664
 
 
1665
 
    my_error(ER_ERROR_ON_RENAME, MYF(0), from_identifier, to_identifier, error);
1666
 
  }
1667
 
 
1668
 
  return error ? true : false; 
 
1874
    my_error(ER_ERROR_ON_RENAME, MYF(0), from, to, error);
 
1875
  return(error != 0);
1669
1876
}
1670
1877
 
1671
1878
 
1684
1891
   the table is closed.
1685
1892
 
1686
1893
  PREREQUISITES
1687
 
    Lock on table::Cache::singleton().mutex()
 
1894
    Lock on LOCK_open
1688
1895
    Win32 clients must also have a WRITE LOCK on the table !
1689
1896
*/
1690
1897
 
1692
1899
                              enum ha_extra_function function)
1693
1900
{
1694
1901
 
1695
 
  safe_mutex_assert_owner(table::Cache::singleton().mutex().native_handle());
 
1902
  safe_mutex_assert_owner(&LOCK_open);
1696
1903
 
1697
1904
  table->cursor->extra(function);
1698
1905
  /* Mark all tables that are in use as 'old' */
1699
 
  session->abortLock(table);    /* end threads waiting on lock */
 
1906
  mysql_lock_abort(session, table);     /* end threads waiting on lock */
1700
1907
 
1701
1908
  /* Wait until all there are no other threads that has this table open */
1702
 
  identifier::Table identifier(table->getShare()->getSchemaName(), table->getShare()->getTableName());
1703
 
  table::Cache::singleton().removeTable(session, identifier, RTFC_WAIT_OTHER_THREAD_FLAG);
 
1909
  remove_table_from_cache(session, table->s->db.str,
 
1910
                          table->s->table_name.str,
 
1911
                          RTFC_WAIT_OTHER_THREAD_FLAG);
1704
1912
}
1705
1913
 
1706
1914
/*
1716
1924
    reopen the table.
1717
1925
 
1718
1926
  PREREQUISITES
1719
 
    Lock on table::Cache::singleton().mutex()
 
1927
    Lock on LOCK_open
1720
1928
    Win32 clients must also have a WRITE LOCK on the table !
1721
1929
*/
1722
1930
 
1727
1935
  /* Close lock if this is not got with LOCK TABLES */
1728
1936
  if (lock)
1729
1937
  {
1730
 
    unlockTables(lock);
 
1938
    mysql_unlock_tables(this, lock);
1731
1939
    lock= NULL;                 // Start locked threads
1732
1940
  }
1733
1941
  /* Close all copies of 'table'.  This also frees all LOCK TABLES lock */
1734
1942
  unlink_open_table(table);
1735
1943
 
1736
 
  /* When lock on table::Cache::singleton().mutex() is freed other threads can continue */
1737
 
  locking::broadcast_refresh();
 
1944
  /* When lock on LOCK_open is freed other threads can continue */
 
1945
  broadcast_refresh();
1738
1946
}
1739
1947
 
1740
1948
/*
1743
1951
    true  Message should be sent by caller
1744
1952
          (admin operation or network communication failed)
1745
1953
*/
1746
 
static bool admin_table(Session* session, TableList* tables,
 
1954
static bool mysql_admin_table(Session* session, TableList* tables,
1747
1955
                              HA_CHECK_OPT* check_opt,
1748
1956
                              const char *operator_name,
1749
1957
                              thr_lock_type lock_type,
1757
1965
  Item *item;
1758
1966
  LEX *lex= session->lex;
1759
1967
  int result_code= 0;
1760
 
  TransactionServices &transaction_services= TransactionServices::singleton();
1761
1968
  const CHARSET_INFO * const cs= system_charset_info;
1762
1969
 
1763
1970
  if (! session->endActiveTransaction())
1772
1979
  item->maybe_null = 1;
1773
1980
  field_list.push_back(item = new Item_empty_string("Msg_text", 255, cs));
1774
1981
  item->maybe_null = 1;
1775
 
  if (session->getClient()->sendFields(&field_list))
 
1982
  if (session->client->sendFields(&field_list))
1776
1983
    return true;
1777
1984
 
1778
1985
  for (table= tables; table; table= table->next_local)
1779
1986
  {
1780
1987
    char table_name[NAME_LEN*2+2];
 
1988
    char* db = table->db;
1781
1989
    bool fatal_error=0;
1782
1990
 
1783
 
    snprintf(table_name, sizeof(table_name), "%s.%s", table->getSchemaName(), table->getTableName());
 
1991
    sprintf(table_name,"%s.%s",db,table->table_name);
1784
1992
    table->lock_type= lock_type;
1785
1993
    /* open only one table from local list of command */
1786
1994
    {
1793
2001
      /*
1794
2002
        Time zone tables and SP tables can be add to lex->query_tables list,
1795
2003
        so it have to be prepared.
1796
 
        @todo Investigate if we can put extra tables into argument instead of using lex->query_tables
 
2004
        TODO: Investigate if we can put extra tables into argument instead of
 
2005
        using lex->query_tables
1797
2006
      */
1798
2007
      lex->query_tables= table;
1799
2008
      lex->query_tables_last= &table->next_global;
1827
2036
    {
1828
2037
      char buff[FN_REFLEN + DRIZZLE_ERRMSG_SIZE];
1829
2038
      uint32_t length;
1830
 
      session->getClient()->store(table_name);
1831
 
      session->getClient()->store(operator_name);
1832
 
      session->getClient()->store(STRING_WITH_LEN("error"));
 
2039
      session->client->store(table_name);
 
2040
      session->client->store(operator_name);
 
2041
      session->client->store(STRING_WITH_LEN("error"));
1833
2042
      length= snprintf(buff, sizeof(buff), ER(ER_OPEN_AS_READONLY),
1834
2043
                       table_name);
1835
 
      session->getClient()->store(buff, length);
1836
 
      transaction_services.autocommitOrRollback(*session, false);
 
2044
      session->client->store(buff, length);
 
2045
      ha_autocommit_or_rollback(session, 0);
1837
2046
      session->endTransaction(COMMIT);
1838
2047
      session->close_thread_tables();
1839
2048
      lex->reset_query_tables_list(false);
1840
2049
      table->table=0;                           // For query cache
1841
 
      if (session->getClient()->flush())
 
2050
      if (session->client->flush())
1842
2051
        goto err;
1843
2052
      continue;
1844
2053
    }
1845
2054
 
1846
2055
    /* Close all instances of the table to allow repair to rename files */
1847
 
    if (lock_type == TL_WRITE && table->table->getShare()->getVersion())
 
2056
    if (lock_type == TL_WRITE && table->table->s->version)
1848
2057
    {
1849
 
      table::Cache::singleton().mutex().lock(); /* Lock type is TL_WRITE and we lock to repair the table */
1850
 
      const char *old_message=session->enter_cond(COND_refresh, table::Cache::singleton().mutex(),
1851
 
                                                  "Waiting to get writelock");
1852
 
      session->abortLock(table->table);
1853
 
      identifier::Table identifier(table->table->getShare()->getSchemaName(), table->table->getShare()->getTableName());
1854
 
      table::Cache::singleton().removeTable(session, identifier, RTFC_WAIT_OTHER_THREAD_FLAG | RTFC_CHECK_KILLED_FLAG);
 
2058
      pthread_mutex_lock(&LOCK_open); /* Lock type is TL_WRITE and we lock to repair the table */
 
2059
      const char *old_message=session->enter_cond(&COND_refresh, &LOCK_open,
 
2060
                                              "Waiting to get writelock");
 
2061
      mysql_lock_abort(session,table->table);
 
2062
      remove_table_from_cache(session, table->table->s->db.str,
 
2063
                              table->table->s->table_name.str,
 
2064
                              RTFC_WAIT_OTHER_THREAD_FLAG |
 
2065
                              RTFC_CHECK_KILLED_FLAG);
1855
2066
      session->exit_cond(old_message);
1856
 
      if (session->getKilled())
 
2067
      if (session->killed)
1857
2068
        goto err;
1858
2069
      open_for_modify= 0;
1859
2070
    }
1869
2080
      DRIZZLE_ERROR *err;
1870
2081
      while ((err= it++))
1871
2082
      {
1872
 
        session->getClient()->store(table_name);
1873
 
        session->getClient()->store(operator_name);
1874
 
        session->getClient()->store(warning_level_names[err->level].str,
 
2083
        session->client->store(table_name);
 
2084
        session->client->store(operator_name);
 
2085
        session->client->store(warning_level_names[err->level].str,
1875
2086
                               warning_level_names[err->level].length);
1876
 
        session->getClient()->store(err->msg);
1877
 
        if (session->getClient()->flush())
 
2087
        session->client->store(err->msg);
 
2088
        if (session->client->flush())
1878
2089
          goto err;
1879
2090
      }
1880
2091
      drizzle_reset_errors(session, true);
1881
2092
    }
1882
 
    session->getClient()->store(table_name);
1883
 
    session->getClient()->store(operator_name);
 
2093
    session->client->store(table_name);
 
2094
    session->client->store(operator_name);
1884
2095
 
1885
2096
    switch (result_code) {
1886
2097
    case HA_ADMIN_NOT_IMPLEMENTED:
1888
2099
        char buf[ERRMSGSIZE+20];
1889
2100
        uint32_t length=snprintf(buf, ERRMSGSIZE,
1890
2101
                             ER(ER_CHECK_NOT_IMPLEMENTED), operator_name);
1891
 
        session->getClient()->store(STRING_WITH_LEN("note"));
1892
 
        session->getClient()->store(buf, length);
 
2102
        session->client->store(STRING_WITH_LEN("note"));
 
2103
        session->client->store(buf, length);
1893
2104
      }
1894
2105
      break;
1895
2106
 
1896
2107
    case HA_ADMIN_OK:
1897
 
      session->getClient()->store(STRING_WITH_LEN("status"));
1898
 
      session->getClient()->store(STRING_WITH_LEN("OK"));
 
2108
      session->client->store(STRING_WITH_LEN("status"));
 
2109
      session->client->store(STRING_WITH_LEN("OK"));
1899
2110
      break;
1900
2111
 
1901
2112
    case HA_ADMIN_FAILED:
1902
 
      session->getClient()->store(STRING_WITH_LEN("status"));
1903
 
      session->getClient()->store(STRING_WITH_LEN("Operation failed"));
 
2113
      session->client->store(STRING_WITH_LEN("status"));
 
2114
      session->client->store(STRING_WITH_LEN("Operation failed"));
1904
2115
      break;
1905
2116
 
1906
2117
    case HA_ADMIN_REJECT:
1907
 
      session->getClient()->store(STRING_WITH_LEN("status"));
1908
 
      session->getClient()->store(STRING_WITH_LEN("Operation need committed state"));
 
2118
      session->client->store(STRING_WITH_LEN("status"));
 
2119
      session->client->store(STRING_WITH_LEN("Operation need committed state"));
1909
2120
      open_for_modify= false;
1910
2121
      break;
1911
2122
 
1912
2123
    case HA_ADMIN_ALREADY_DONE:
1913
 
      session->getClient()->store(STRING_WITH_LEN("status"));
1914
 
      session->getClient()->store(STRING_WITH_LEN("Table is already up to date"));
 
2124
      session->client->store(STRING_WITH_LEN("status"));
 
2125
      session->client->store(STRING_WITH_LEN("Table is already up to date"));
1915
2126
      break;
1916
2127
 
1917
2128
    case HA_ADMIN_CORRUPT:
1918
 
      session->getClient()->store(STRING_WITH_LEN("error"));
1919
 
      session->getClient()->store(STRING_WITH_LEN("Corrupt"));
 
2129
      session->client->store(STRING_WITH_LEN("error"));
 
2130
      session->client->store(STRING_WITH_LEN("Corrupt"));
1920
2131
      fatal_error=1;
1921
2132
      break;
1922
2133
 
1923
2134
    case HA_ADMIN_INVALID:
1924
 
      session->getClient()->store(STRING_WITH_LEN("error"));
1925
 
      session->getClient()->store(STRING_WITH_LEN("Invalid argument"));
 
2135
      session->client->store(STRING_WITH_LEN("error"));
 
2136
      session->client->store(STRING_WITH_LEN("Invalid argument"));
1926
2137
      break;
1927
2138
 
1928
2139
    default:                            // Probably HA_ADMIN_INTERNAL_ERROR
1931
2142
        uint32_t length=snprintf(buf, ERRMSGSIZE,
1932
2143
                             _("Unknown - internal error %d during operation"),
1933
2144
                             result_code);
1934
 
        session->getClient()->store(STRING_WITH_LEN("error"));
1935
 
        session->getClient()->store(buf, length);
 
2145
        session->client->store(STRING_WITH_LEN("error"));
 
2146
        session->client->store(buf, length);
1936
2147
        fatal_error=1;
1937
2148
        break;
1938
2149
      }
1940
2151
    if (table->table)
1941
2152
    {
1942
2153
      if (fatal_error)
1943
 
      {
1944
 
        table->table->getMutableShare()->resetVersion();               // Force close of table
1945
 
      }
 
2154
        table->table->s->version=0;               // Force close of table
1946
2155
      else if (open_for_modify)
1947
2156
      {
1948
 
        if (table->table->getShare()->getType())
1949
 
        {
 
2157
        if (table->table->s->tmp_table)
1950
2158
          table->table->cursor->info(HA_STATUS_CONST);
1951
 
        }
1952
2159
        else
1953
2160
        {
1954
 
          boost::unique_lock<boost::mutex> lock(table::Cache::singleton().mutex());
1955
 
          identifier::Table identifier(table->table->getShare()->getSchemaName(), table->table->getShare()->getTableName());
1956
 
          table::Cache::singleton().removeTable(session, identifier, RTFC_NO_FLAG);
 
2161
          pthread_mutex_lock(&LOCK_open);
 
2162
          remove_table_from_cache(session, table->table->s->db.str,
 
2163
                                  table->table->s->table_name.str, RTFC_NO_FLAG);
 
2164
          pthread_mutex_unlock(&LOCK_open);
1957
2165
        }
1958
2166
      }
1959
2167
    }
1960
 
    transaction_services.autocommitOrRollback(*session, false);
 
2168
    ha_autocommit_or_rollback(session, 0);
1961
2169
    session->endTransaction(COMMIT);
1962
2170
    session->close_thread_tables();
1963
2171
    table->table=0;                             // For query cache
1964
 
    if (session->getClient()->flush())
 
2172
    if (session->client->flush())
1965
2173
      goto err;
1966
2174
  }
1967
2175
 
1969
2177
  return(false);
1970
2178
 
1971
2179
err:
1972
 
  transaction_services.autocommitOrRollback(*session, true);
 
2180
  ha_autocommit_or_rollback(session, 1);
1973
2181
  session->endTransaction(ROLLBACK);
1974
2182
  session->close_thread_tables();                       // Shouldn't be needed
1975
2183
  if (table)
1977
2185
  return(true);
1978
2186
}
1979
2187
 
 
2188
/*
 
2189
  Create a table identical to the specified table
 
2190
 
 
2191
  SYNOPSIS
 
2192
    mysql_create_like_table()
 
2193
    session             Thread object
 
2194
    table       Table list element for target table
 
2195
    src_table   Table list element for source table
 
2196
    create_info Create info
 
2197
 
 
2198
  RETURN VALUES
 
2199
    false OK
 
2200
    true  error
 
2201
*/
 
2202
 
 
2203
bool mysql_create_like_table(Session* session, TableList* table, TableList* src_table,
 
2204
                             drizzled::message::Table& create_table_proto,
 
2205
                             drizzled::plugin::StorageEngine *engine_arg,
 
2206
                             bool is_if_not_exists,
 
2207
                             bool is_engine_set)
 
2208
{
 
2209
  Table *name_lock= 0;
 
2210
  char src_path[FN_REFLEN];
 
2211
  char *db= table->db;
 
2212
  char *table_name= table->table_name;
 
2213
  int  err;
 
2214
  bool res= true;
 
2215
  uint32_t not_used;
 
2216
  message::Table src_proto;
 
2217
  bool lex_identified_temp_table=
 
2218
    (create_table_proto.type() == drizzled::message::Table::TEMPORARY);
 
2219
 
 
2220
  /*
 
2221
    By opening source table we guarantee that it exists and no concurrent
 
2222
    DDL operation will mess with it. Later we also take an exclusive
 
2223
    name-lock on target table name, which makes copying of .frm cursor,
 
2224
    call to plugin::StorageEngine::createTable() and binlogging atomic
 
2225
    against concurrent DML and DDL operations on target table.
 
2226
    Thus by holding both these "locks" we ensure that our statement is
 
2227
    properly isolated from all concurrent operations which matter.
 
2228
  */
 
2229
  if (session->open_tables_from_list(&src_table, &not_used))
 
2230
    return true;
 
2231
 
 
2232
  strncpy(src_path, src_table->table->s->path.str, sizeof(src_path));
 
2233
 
 
2234
 
 
2235
  TableIdentifier destination_identifier(db, table_name, lex_identified_temp_table ? TEMP_TABLE : NO_TMP_TABLE);
 
2236
 
 
2237
  /*
 
2238
    Check that destination tables does not exist. Note that its name
 
2239
    was already checked when it was added to the table list.
 
2240
  */
 
2241
  if (lex_identified_temp_table)
 
2242
  {
 
2243
    if (session->find_temporary_table(db, table_name))
 
2244
      goto table_exists;
 
2245
  }
 
2246
  else
 
2247
  {
 
2248
    if (session->lock_table_name_if_not_cached(db, table_name, &name_lock))
 
2249
      goto err;
 
2250
    if (! name_lock)
 
2251
      goto table_exists;
 
2252
 
 
2253
    if (plugin::StorageEngine::getTableDefinition(*session,
 
2254
                                                  destination_identifier) == EEXIST)
 
2255
      goto table_exists;
 
2256
  }
 
2257
 
1980
2258
  /*
1981
2259
    Create a new table by copying from source table
1982
2260
 
1983
2261
    Altough exclusive name-lock on target table protects us from concurrent
1984
2262
    DML and DDL operations on it we still want to wrap .FRM creation and call
1985
2263
    to plugin::StorageEngine::createTable() in critical section protected by
1986
 
    table::Cache::singleton().mutex() in order to provide minimal atomicity against operations which
 
2264
    LOCK_open in order to provide minimal atomicity against operations which
1987
2265
    disregard name-locks, like I_S implementation, for example. This is a
1988
2266
    temporary and should not be copied. Instead we should fix our code to
1989
2267
    always honor name-locks.
1990
2268
 
1991
 
    Also some engines (e.g. NDB cluster) require that table::Cache::singleton().mutex() should be held
 
2269
    Also some engines (e.g. NDB cluster) require that LOCK_open should be held
1992
2270
    during the call to plugin::StorageEngine::createTable().
1993
2271
    See bug #28614 for more info.
1994
2272
  */
1995
 
static bool create_table_wrapper(Session &session,
1996
 
                                 const message::Table& create_table_proto,
1997
 
                                 identifier::Table::const_reference destination_identifier,
1998
 
                                 identifier::Table::const_reference source_identifier,
1999
 
                                 bool is_engine_set)
2000
 
{
2001
 
  // We require an additional table message because during parsing we used
2002
 
  // a "new" message and it will not have all of the information that the
2003
 
  // source table message would have.
2004
 
  message::Table new_table_message;
2005
 
  drizzled::error_t error;
2006
 
 
2007
 
  message::table::shared_ptr source_table_message= plugin::StorageEngine::getTableMessage(session, source_identifier, error);
2008
 
 
2009
 
  if (not source_table_message)
2010
 
  {
2011
 
    my_error(ER_TABLE_UNKNOWN, source_identifier);
2012
 
    return false;
2013
 
  }
2014
 
 
2015
 
  new_table_message.CopyFrom(*source_table_message);
2016
 
 
2017
 
  if (destination_identifier.isTmp())
2018
 
  {
2019
 
    new_table_message.set_type(message::Table::TEMPORARY);
 
2273
  pthread_mutex_lock(&LOCK_open); /* We lock for CREATE TABLE LIKE to copy table definition */
 
2274
  {
 
2275
    int protoerr= EEXIST;
 
2276
 
 
2277
    /*
 
2278
     * If an engine was not specified and we are reading from an I_S table, then we need to toss an
 
2279
     * error. This should go away soon.
 
2280
     * @todo make this go away!
 
2281
     */
 
2282
    if (! is_engine_set)
 
2283
    {
 
2284
      string tab_name(src_path);
 
2285
      string i_s_prefix("./information_schema/");
 
2286
      if (tab_name.compare(0, i_s_prefix.length(), i_s_prefix) == 0)
 
2287
      {
 
2288
        pthread_mutex_unlock(&LOCK_open);
 
2289
        my_error(ER_ILLEGAL_HA_CREATE_OPTION,
 
2290
                 MYF(0),
 
2291
                 "INFORMATION_ENGINE",
 
2292
                 "TEMPORARY");
 
2293
        goto err;
 
2294
      }
 
2295
    }
 
2296
 
 
2297
    protoerr= plugin::StorageEngine::getTableDefinition(*session,
 
2298
                                                        src_path,
 
2299
                                                        db,
 
2300
                                                        table_name,
 
2301
                                                        false,
 
2302
                                                        &src_proto);
 
2303
 
 
2304
    message::Table new_proto(src_proto);
 
2305
 
 
2306
    if (lex_identified_temp_table)
 
2307
    {
 
2308
      new_proto.set_type(message::Table::TEMPORARY);
 
2309
    }
 
2310
    else
 
2311
    {
 
2312
      new_proto.set_type(message::Table::STANDARD);
 
2313
    }
 
2314
 
 
2315
    if (is_engine_set)
 
2316
    {
 
2317
      message::Table::StorageEngine *protoengine;
 
2318
 
 
2319
      protoengine= new_proto.mutable_engine();
 
2320
      protoengine->set_name(create_table_proto.engine().name());
 
2321
    }
 
2322
 
 
2323
    if (protoerr == EEXIST)
 
2324
    {
 
2325
      plugin::StorageEngine* engine= plugin::StorageEngine::findByName(*session,
 
2326
                                                                       new_proto.engine().name());
 
2327
 
 
2328
      if (engine->check_flag(HTON_BIT_HAS_DATA_DICTIONARY) == false)
 
2329
      {
 
2330
        string dst_proto_path(destination_identifier.getPath());
 
2331
        dst_proto_path.append(".dfe");
 
2332
 
 
2333
        protoerr= drizzle_write_proto_file(dst_proto_path.c_str(), &new_proto);
 
2334
      }
 
2335
      else
 
2336
      {
 
2337
        protoerr= 0;
 
2338
      }
 
2339
    }
 
2340
 
 
2341
    if (protoerr)
 
2342
    {
 
2343
      if (my_errno == ENOENT)
 
2344
        my_error(ER_BAD_DB_ERROR,MYF(0),db);
 
2345
      else
 
2346
        my_error(ER_CANT_CREATE_FILE, MYF(0), destination_identifier.getPath(), my_errno);
 
2347
      pthread_mutex_unlock(&LOCK_open);
 
2348
      goto err;
 
2349
    }
 
2350
 
 
2351
    /*
 
2352
      As mysql_truncate don't work on a new table at this stage of
 
2353
      creation, instead create the table directly (for both normal
 
2354
      and temporary tables).
 
2355
    */
 
2356
    err= plugin::StorageEngine::createTable(*session,
 
2357
                                            destination_identifier,
 
2358
                                            true, new_proto);
 
2359
  }
 
2360
  pthread_mutex_unlock(&LOCK_open);
 
2361
 
 
2362
  if (lex_identified_temp_table)
 
2363
  {
 
2364
    if (err || !session->open_temporary_table(destination_identifier))
 
2365
    {
 
2366
      (void) session->rm_temporary_table(engine_arg, destination_identifier);
 
2367
      goto err;
 
2368
    }
 
2369
  }
 
2370
  else if (err)
 
2371
  {
 
2372
    TableIdentifier identifier(db, table_name, NO_TMP_TABLE);
 
2373
    quick_rm_table(*session, identifier);
 
2374
 
 
2375
    goto err;
 
2376
  }
 
2377
 
 
2378
  /*
 
2379
    We have to write the query before we unlock the tables.
 
2380
  */
 
2381
  {
 
2382
    /*
 
2383
       Since temporary tables are not replicated under row-based
 
2384
       replication, CREATE TABLE ... LIKE ... needs special
 
2385
       treatement.  We have four cases to consider, according to the
 
2386
       following decision table:
 
2387
 
 
2388
           ==== ========= ========= ==============================
 
2389
           Case    Target    Source Write to binary log
 
2390
           ==== ========= ========= ==============================
 
2391
           1       normal    normal Original statement
 
2392
           2       normal temporary Generated statement
 
2393
           3    temporary    normal Nothing
 
2394
           4    temporary temporary Nothing
 
2395
           ==== ========= ========= ==============================
 
2396
    */
 
2397
    if (! lex_identified_temp_table)
 
2398
    {
 
2399
      if (src_table->table->s->tmp_table)               // Case 2
 
2400
      {
 
2401
        char buf[2048];
 
2402
        String query(buf, sizeof(buf), system_charset_info);
 
2403
        query.length(0);  // Have to zero it since constructor doesn't
 
2404
 
 
2405
 
 
2406
        /*
 
2407
          Here we open the destination table, on which we already have
 
2408
          name-lock. This is needed for store_create_info() to work.
 
2409
          The table will be closed by unlink_open_table() at the end
 
2410
          of this function.
 
2411
        */
 
2412
        table->table= name_lock;
 
2413
        pthread_mutex_lock(&LOCK_open); /* Open new table we have just acquired */
 
2414
        if (session->reopen_name_locked_table(table, false))
 
2415
        {
 
2416
          pthread_mutex_unlock(&LOCK_open);
 
2417
          goto err;
 
2418
        }
 
2419
        pthread_mutex_unlock(&LOCK_open);
 
2420
 
 
2421
        int result= store_create_info(table, &query, is_if_not_exists);
 
2422
 
 
2423
        assert(result == 0); // store_create_info() always return 0
 
2424
        write_bin_log(session, query.ptr(), query.length());
 
2425
      }
 
2426
      else                                      // Case 1
 
2427
        write_bin_log(session, session->query, session->query_length);
 
2428
    }
 
2429
  }
 
2430
 
 
2431
  res= false;
 
2432
  goto err;
 
2433
 
 
2434
table_exists:
 
2435
  if (is_if_not_exists)
 
2436
  {
 
2437
    char warn_buff[DRIZZLE_ERRMSG_SIZE];
 
2438
    snprintf(warn_buff, sizeof(warn_buff),
 
2439
             ER(ER_TABLE_EXISTS_ERROR), table_name);
 
2440
    push_warning(session, DRIZZLE_ERROR::WARN_LEVEL_NOTE,
 
2441
                 ER_TABLE_EXISTS_ERROR,warn_buff);
 
2442
    res= false;
2020
2443
  }
2021
2444
  else
2022
 
  {
2023
 
    new_table_message.set_type(message::Table::STANDARD);
2024
 
  }
2025
 
 
2026
 
  if (is_engine_set)
2027
 
  {
2028
 
    new_table_message.mutable_engine()->set_name(create_table_proto.engine().name());
2029
 
  }
2030
 
 
2031
 
  { // We now do a selective copy of elements on to the new table.
2032
 
    new_table_message.set_name(create_table_proto.name());
2033
 
    new_table_message.set_schema(create_table_proto.schema());
2034
 
    new_table_message.set_catalog(create_table_proto.catalog());
2035
 
  }
2036
 
 
2037
 
  /* Fix names of foreign keys being added */
2038
 
  for (int32_t j= 0; j < new_table_message.fk_constraint_size(); j++)
2039
 
  {
2040
 
    if (new_table_message.fk_constraint(j).has_name())
2041
 
    {
2042
 
      std::string name(new_table_message.name());
2043
 
      char number[20];
2044
 
 
2045
 
      name.append("_ibfk_");
2046
 
      snprintf(number, sizeof(number), "%d", j+1);
2047
 
      name.append(number);
2048
 
 
2049
 
      message::Table::ForeignKeyConstraint *pfkey= new_table_message.mutable_fk_constraint(j);
2050
 
      pfkey->set_name(name);
2051
 
    }
2052
 
  }
2053
 
 
2054
 
  /*
2055
 
    As mysql_truncate don't work on a new table at this stage of
2056
 
    creation, instead create the table directly (for both normal and temporary tables).
2057
 
  */
2058
 
  bool success= plugin::StorageEngine::createTable(session,
2059
 
                                                   destination_identifier,
2060
 
                                                   new_table_message);
2061
 
 
2062
 
  if (success && not destination_identifier.isTmp())
2063
 
  {
2064
 
    TransactionServices &transaction_services= TransactionServices::singleton();
2065
 
    transaction_services.createTable(session, new_table_message);
2066
 
  }
2067
 
 
2068
 
  return success;
2069
 
}
2070
 
 
2071
 
/*
2072
 
  Create a table identical to the specified table
2073
 
 
2074
 
  SYNOPSIS
2075
 
    create_like_table()
2076
 
    session             Thread object
2077
 
    table       Table list element for target table
2078
 
    src_table   Table list element for source table
2079
 
    create_info Create info
2080
 
 
2081
 
  RETURN VALUES
2082
 
    false OK
2083
 
    true  error
2084
 
*/
2085
 
 
2086
 
bool create_like_table(Session* session,
2087
 
                       identifier::Table::const_reference destination_identifier,
2088
 
                       identifier::Table::const_reference source_identifier,
2089
 
                       message::Table &create_table_proto,
2090
 
                       bool is_if_not_exists,
2091
 
                       bool is_engine_set)
2092
 
{
2093
 
  bool res= true;
2094
 
  bool table_exists= false;
2095
 
 
2096
 
  /*
2097
 
    Check that destination tables does not exist. Note that its name
2098
 
    was already checked when it was added to the table list.
2099
 
 
2100
 
    For temporary tables we don't aim to grab locks.
2101
 
  */
2102
 
  if (destination_identifier.isTmp())
2103
 
  {
2104
 
    if (session->find_temporary_table(destination_identifier))
2105
 
    {
2106
 
      table_exists= true;
2107
 
    }
2108
 
    else
2109
 
    {
2110
 
      bool was_created= create_table_wrapper(*session,
2111
 
                                             create_table_proto,
2112
 
                                             destination_identifier,
2113
 
                                             source_identifier,
2114
 
                                             is_engine_set);
2115
 
      if (not was_created) // This is pretty paranoid, but we assume something might not clean up after itself
2116
 
      {
2117
 
        (void) session->rm_temporary_table(destination_identifier, true);
2118
 
      }
2119
 
      else if (not session->open_temporary_table(destination_identifier))
2120
 
      {
2121
 
        // We created, but we can't open... also, a hack.
2122
 
        (void) session->rm_temporary_table(destination_identifier, true);
2123
 
      }
2124
 
      else
2125
 
      {
2126
 
        res= false;
2127
 
      }
2128
 
    }
2129
 
  }
2130
 
  else // Standard table which will require locks.
2131
 
  {
2132
 
    Table *name_lock= 0;
2133
 
 
2134
 
    if (session->lock_table_name_if_not_cached(destination_identifier, &name_lock))
2135
 
    {
2136
 
      if (name_lock)
2137
 
      {
2138
 
        boost_unique_lock_t lock(table::Cache::singleton().mutex()); /* unlink open tables for create table like*/
2139
 
        session->unlink_open_table(name_lock);
2140
 
      }
2141
 
 
2142
 
      return res;
2143
 
    }
2144
 
 
2145
 
    if (not name_lock)
2146
 
    {
2147
 
      table_exists= true;
2148
 
    }
2149
 
    else if (plugin::StorageEngine::doesTableExist(*session, destination_identifier))
2150
 
    {
2151
 
      table_exists= true;
2152
 
    }
2153
 
    else // Otherwise we create the table
2154
 
    {
2155
 
      bool was_created;
2156
 
      {
2157
 
        boost_unique_lock_t lock(table::Cache::singleton().mutex()); /* We lock for CREATE TABLE LIKE to copy table definition */
2158
 
        was_created= create_table_wrapper(*session, create_table_proto, destination_identifier,
2159
 
                                          source_identifier, is_engine_set);
2160
 
      }
2161
 
 
2162
 
      // So we blew the creation of the table, and we scramble to clean up
2163
 
      // anything that might have been created (read... it is a hack)
2164
 
      if (not was_created)
2165
 
      {
2166
 
        plugin::StorageEngine::dropTable(*session, destination_identifier);
2167
 
      } 
2168
 
      else
2169
 
      {
2170
 
        res= false;
2171
 
      }
2172
 
    }
2173
 
 
2174
 
    if (name_lock)
2175
 
    {
2176
 
      boost_unique_lock_t lock(table::Cache::singleton().mutex()); /* unlink open tables for create table like*/
2177
 
      session->unlink_open_table(name_lock);
2178
 
    }
2179
 
  }
2180
 
 
2181
 
  if (table_exists)
2182
 
  {
2183
 
    if (is_if_not_exists)
2184
 
    {
2185
 
      char warn_buff[DRIZZLE_ERRMSG_SIZE];
2186
 
      snprintf(warn_buff, sizeof(warn_buff),
2187
 
               ER(ER_TABLE_EXISTS_ERROR), destination_identifier.getTableName().c_str());
2188
 
      push_warning(session, DRIZZLE_ERROR::WARN_LEVEL_NOTE,
2189
 
                   ER_TABLE_EXISTS_ERROR, warn_buff);
2190
 
      return false;
2191
 
    }
2192
 
 
2193
 
    my_error(ER_TABLE_EXISTS_ERROR, destination_identifier);
2194
 
 
2195
 
    return true;
2196
 
  }
2197
 
 
2198
 
  return res;
2199
 
}
2200
 
 
2201
 
 
2202
 
bool analyze_table(Session* session, TableList* tables, HA_CHECK_OPT* check_opt)
 
2445
    my_error(ER_TABLE_EXISTS_ERROR, MYF(0), table_name);
 
2446
 
 
2447
err:
 
2448
  if (name_lock)
 
2449
  {
 
2450
    pthread_mutex_lock(&LOCK_open); /* unlink open tables for create table like*/
 
2451
    session->unlink_open_table(name_lock);
 
2452
    pthread_mutex_unlock(&LOCK_open);
 
2453
  }
 
2454
  return(res);
 
2455
}
 
2456
 
 
2457
 
 
2458
bool mysql_analyze_table(Session* session, TableList* tables, HA_CHECK_OPT* check_opt)
2203
2459
{
2204
2460
  thr_lock_type lock_type = TL_READ_NO_INSERT;
2205
2461
 
2206
 
  return(admin_table(session, tables, check_opt,
 
2462
  return(mysql_admin_table(session, tables, check_opt,
2207
2463
                                "analyze", lock_type, true,
2208
2464
                                &Cursor::ha_analyze));
2209
2465
}
2210
2466
 
2211
2467
 
2212
 
bool check_table(Session* session, TableList* tables,HA_CHECK_OPT* check_opt)
 
2468
bool mysql_check_table(Session* session, TableList* tables,HA_CHECK_OPT* check_opt)
2213
2469
{
2214
2470
  thr_lock_type lock_type = TL_READ_NO_INSERT;
2215
2471
 
2216
 
  return(admin_table(session, tables, check_opt,
 
2472
  return(mysql_admin_table(session, tables, check_opt,
2217
2473
                                "check", lock_type,
2218
2474
                                false,
2219
2475
                                &Cursor::ha_check));
2220
2476
}
2221
2477
 
2222
 
} /* namespace drizzled */
 
2478
 
 
2479
bool mysql_checksum_table(Session *session, TableList *tables,
 
2480
                          HA_CHECK_OPT *)
 
2481
{
 
2482
  TableList *table;
 
2483
  List<Item> field_list;
 
2484
  Item *item;
 
2485
 
 
2486
  field_list.push_back(item = new Item_empty_string("Table", NAME_LEN*2));
 
2487
  item->maybe_null= 1;
 
2488
  field_list.push_back(item= new Item_int("Checksum", (int64_t) 1,
 
2489
                                          MY_INT64_NUM_DECIMAL_DIGITS));
 
2490
  item->maybe_null= 1;
 
2491
  if (session->client->sendFields(&field_list))
 
2492
    return true;
 
2493
 
 
2494
  /* Open one table after the other to keep lock time as short as possible. */
 
2495
  for (table= tables; table; table= table->next_local)
 
2496
  {
 
2497
    char table_name[NAME_LEN*2+2];
 
2498
    Table *t;
 
2499
 
 
2500
    sprintf(table_name,"%s.%s",table->db,table->table_name);
 
2501
 
 
2502
    t= table->table= session->openTableLock(table, TL_READ);
 
2503
    session->clear_error();                     // these errors shouldn't get client
 
2504
 
 
2505
    session->client->store(table_name);
 
2506
 
 
2507
    if (!t)
 
2508
    {
 
2509
      /* Table didn't exist */
 
2510
      session->client->store();
 
2511
      session->clear_error();
 
2512
    }
 
2513
    else
 
2514
    {
 
2515
      /**
 
2516
        @note if the engine keeps a checksum then we return the checksum, otherwise we calculate
 
2517
      */
 
2518
      if (t->cursor->getEngine()->check_flag(HTON_BIT_HAS_CHECKSUM))
 
2519
      {
 
2520
        session->client->store((uint64_t)t->cursor->checksum());
 
2521
      }
 
2522
      else
 
2523
      {
 
2524
        /* calculating table's checksum */
 
2525
        ha_checksum crc= 0;
 
2526
        unsigned char null_mask=256 -  (1 << t->s->last_null_bit_pos);
 
2527
 
 
2528
        t->use_all_columns();
 
2529
 
 
2530
        if (t->cursor->ha_rnd_init(1))
 
2531
          session->client->store();
 
2532
        else
 
2533
        {
 
2534
          for (;;)
 
2535
          {
 
2536
            ha_checksum row_crc= 0;
 
2537
            int error= t->cursor->rnd_next(t->record[0]);
 
2538
            if (unlikely(error))
 
2539
            {
 
2540
              if (error == HA_ERR_RECORD_DELETED)
 
2541
                continue;
 
2542
              break;
 
2543
            }
 
2544
            if (t->s->null_bytes)
 
2545
            {
 
2546
              /* fix undefined null bits */
 
2547
              t->record[0][t->s->null_bytes-1] |= null_mask;
 
2548
              if (!(t->s->db_create_options & HA_OPTION_PACK_RECORD))
 
2549
                t->record[0][0] |= 1;
 
2550
 
 
2551
              row_crc= my_checksum(row_crc, t->record[0], t->s->null_bytes);
 
2552
            }
 
2553
 
 
2554
            for (uint32_t i= 0; i < t->s->fields; i++ )
 
2555
            {
 
2556
              Field *f= t->field[i];
 
2557
              if ((f->type() == DRIZZLE_TYPE_BLOB) ||
 
2558
                  (f->type() == DRIZZLE_TYPE_VARCHAR))
 
2559
              {
 
2560
                String tmp;
 
2561
                f->val_str(&tmp);
 
2562
                row_crc= my_checksum(row_crc, (unsigned char*) tmp.ptr(), tmp.length());
 
2563
              }
 
2564
              else
 
2565
                row_crc= my_checksum(row_crc, f->ptr,
 
2566
                                     f->pack_length());
 
2567
            }
 
2568
 
 
2569
            crc+= row_crc;
 
2570
          }
 
2571
          session->client->store((uint64_t)crc);
 
2572
          t->cursor->ha_rnd_end();
 
2573
        }
 
2574
      }
 
2575
      session->clear_error();
 
2576
      session->close_thread_tables();
 
2577
      table->table=0;                           // For query cache
 
2578
    }
 
2579
    if (session->client->flush())
 
2580
      goto err;
 
2581
  }
 
2582
 
 
2583
  session->my_eof();
 
2584
  return(false);
 
2585
 
 
2586
 err:
 
2587
  session->close_thread_tables();                       // Shouldn't be needed
 
2588
  if (table)
 
2589
    table->table=0;
 
2590
  return(true);
 
2591
}