← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to drizzled/db.cc

  • Committer: Brian Aker
  • Date: 2010-07-30 20:31:19 UTC
  • mto: This revision was merged to the branch mainline in revision 1679.
  • Revision ID: brian@gaz-20100730203119-89g2ye4zwnvcacxg
First pass in encapsulating row

Show diffs side-by-side

added added

removed removed

Lines of Context:
drizzled/db.cc
11
11
 
12
12
   You should have received a copy of the GNU General Public License
13
13
   along with this program; if not, write to the Free Software
14
 
   Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA */
 
14
   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA */
15
15
 
16
16
 
17
17
/* create and drop of databases */
25
25
#include <string>
26
26
#include <fstream>
27
27
 
 
28
#include <drizzled/message/schema.pb.h>
28
29
#include "drizzled/error.h"
29
30
#include <drizzled/gettext.h>
30
31
#include <drizzled/my_hash.h>
43
44
#include "drizzled/pthread_globals.h"
44
45
#include "drizzled/charset.h"
45
46
 
46
 
#include <boost/thread/mutex.hpp>
47
 
 
48
47
#include "drizzled/internal/my_sys.h"
49
48
 
50
49
#define MAX_DROP_TABLE_Q_LEN      1024
54
53
namespace drizzled
55
54
{
56
55
 
57
 
static void change_db_impl(Session *session);
58
 
static void change_db_impl(Session *session, identifier::Schema &schema_identifier);
 
56
static long drop_tables_via_filenames(Session *session,
 
57
                                 SchemaIdentifier &schema_identifier,
 
58
                                 TableIdentifiers &dropped_tables);
 
59
static void mysql_change_db_impl(Session *session);
 
60
static void mysql_change_db_impl(Session *session, SchemaIdentifier &schema_identifier);
59
61
 
60
62
/*
61
63
  Create a database
62
64
 
63
65
  SYNOPSIS
64
 
  create_db()
 
66
  mysql_create_db()
65
67
  session               Thread handler
66
68
  db            Name of database to create
67
69
                Function assumes that this is already validated.
78
80
 
79
81
*/
80
82
 
81
 
bool create_db(Session *session, const message::Schema &schema_message, const bool is_if_not_exists)
 
83
bool mysql_create_db(Session *session, const message::Schema &schema_message, const bool is_if_not_exists)
82
84
{
83
85
  TransactionServices &transaction_services= TransactionServices::singleton();
84
86
  bool error= false;
85
87
 
86
88
  /*
87
89
    Do not create database if another thread is holding read lock.
88
 
    Wait for global read lock before acquiring session->catalog()->schemaLock().
 
90
    Wait for global read lock before acquiring LOCK_create_db.
89
91
    After wait_if_global_read_lock() we have protection against another
90
 
    global read lock. If we would acquire session->catalog()->schemaLock() first,
 
92
    global read lock. If we would acquire LOCK_create_db first,
91
93
    another thread could step in and get the global read lock before we
92
94
    reach wait_if_global_read_lock(). If this thread tries the same as we
93
 
    (admin a db), it would then go and wait on session->catalog()->schemaLock()...
 
95
    (admin a db), it would then go and wait on LOCK_create_db...
94
96
    Furthermore wait_if_global_read_lock() checks if the current thread
95
97
    has the global read lock and refuses the operation with
96
98
    ER_CANT_UPDATE_WITH_READLOCK if applicable.
97
99
  */
98
 
  if (session->wait_if_global_read_lock(false, true))
 
100
  if (wait_if_global_read_lock(session, 0, 1))
99
101
  {
100
102
    return false;
101
103
  }
104
106
  assert(schema_message.has_collation());
105
107
 
106
108
  // @todo push this lock down into the engine
 
109
  pthread_mutex_lock(&LOCK_create_db);
 
110
 
 
111
  // Check to see if it exists already.  
 
112
  SchemaIdentifier schema_identifier(schema_message.name());
 
113
  if (plugin::StorageEngine::doesSchemaExist(schema_identifier))
107
114
  {
108
 
    boost::mutex::scoped_lock scopedLock(session->catalog().schemaLock());
109
 
 
110
 
    // Check to see if it exists already.  
111
 
    identifier::Schema schema_identifier(schema_message.name());
112
 
    if (plugin::StorageEngine::doesSchemaExist(schema_identifier))
113
 
    {
114
 
      if (not is_if_not_exists)
115
 
      {
116
 
        my_error(ER_DB_CREATE_EXISTS, schema_identifier);
117
 
        error= true;
118
 
      }
119
 
      else
120
 
      {
121
 
        push_warning_printf(session, DRIZZLE_ERROR::WARN_LEVEL_NOTE,
122
 
                            ER_DB_CREATE_EXISTS, ER(ER_DB_CREATE_EXISTS),
123
 
                            schema_message.name().c_str());
124
 
        session->my_ok();
125
 
      }
126
 
    }
127
 
    else if (not plugin::StorageEngine::createSchema(schema_message)) // Try to create it 
128
 
    {
129
 
      my_error(ER_CANT_CREATE_DB, MYF(0), schema_message.name().c_str(), errno);
 
115
    if (not is_if_not_exists)
 
116
    {
 
117
      my_error(ER_DB_CREATE_EXISTS, MYF(0), schema_message.name().c_str());
130
118
      error= true;
131
119
    }
132
 
    else // Created !
 
120
    else
133
121
    {
134
 
      transaction_services.createSchema(*session, schema_message);
135
 
      session->my_ok(1);
 
122
      push_warning_printf(session, DRIZZLE_ERROR::WARN_LEVEL_NOTE,
 
123
                          ER_DB_CREATE_EXISTS, ER(ER_DB_CREATE_EXISTS),
 
124
                          schema_message.name().c_str());
 
125
      session->my_ok();
136
126
    }
137
127
  }
138
 
  session->startWaitingGlobalReadLock();
 
128
  else if (not plugin::StorageEngine::createSchema(schema_message)) // Try to create it 
 
129
  {
 
130
    my_error(ER_CANT_CREATE_DB, MYF(0), schema_message.name().c_str(), errno);
 
131
    error= true;
 
132
  }
 
133
  else // Created !
 
134
  {
 
135
    transaction_services.createSchema(session, schema_message);
 
136
    session->my_ok(1);
 
137
  }
 
138
 
 
139
  pthread_mutex_unlock(&LOCK_create_db);
 
140
  start_waiting_global_read_lock(session);
139
141
 
140
142
  return error;
141
143
}
143
145
 
144
146
/* db-name is already validated when we come here */
145
147
 
146
 
bool alter_db(Session *session,
147
 
              const message::Schema &schema_message,
148
 
              const message::schema::shared_ptr &original_schema)
 
148
bool mysql_alter_db(Session *session, const message::Schema &schema_message)
149
149
{
150
150
  TransactionServices &transaction_services= TransactionServices::singleton();
151
151
 
152
152
  /*
153
153
    Do not alter database if another thread is holding read lock.
154
 
    Wait for global read lock before acquiring session->catalog()->schemaLock().
 
154
    Wait for global read lock before acquiring LOCK_create_db.
155
155
    After wait_if_global_read_lock() we have protection against another
156
 
    global read lock. If we would acquire session->catalog()->schemaLock() first,
 
156
    global read lock. If we would acquire LOCK_create_db first,
157
157
    another thread could step in and get the global read lock before we
158
158
    reach wait_if_global_read_lock(). If this thread tries the same as we
159
 
    (admin a db), it would then go and wait on session->catalog()->schemaLock()...
 
159
    (admin a db), it would then go and wait on LOCK_create_db...
160
160
    Furthermore wait_if_global_read_lock() checks if the current thread
161
161
    has the global read lock and refuses the operation with
162
162
    ER_CANT_UPDATE_WITH_READLOCK if applicable.
163
163
  */
164
 
  if ((session->wait_if_global_read_lock(false, true)))
165
 
    return false;
166
 
 
167
 
  bool success;
168
 
  {
169
 
    boost::mutex::scoped_lock scopedLock(session->catalog().schemaLock());
170
 
 
171
 
    identifier::Schema schema_idenifier(schema_message.name());
172
 
    if (not plugin::StorageEngine::doesSchemaExist(schema_idenifier))
173
 
    {
174
 
      my_error(ER_SCHEMA_DOES_NOT_EXIST, schema_idenifier);
175
 
      return false;
176
 
    }
177
 
 
178
 
    /* Change options if current database is being altered. */
179
 
    success= plugin::StorageEngine::alterSchema(schema_message);
180
 
 
181
 
    if (success)
182
 
    {
183
 
      transaction_services.alterSchema(*session, original_schema, schema_message);
184
 
      session->my_ok(1);
185
 
    }
186
 
    else
187
 
    {
188
 
      my_error(ER_ALTER_SCHEMA, schema_idenifier);
189
 
    }
190
 
  }
191
 
  session->startWaitingGlobalReadLock();
 
164
  if ((wait_if_global_read_lock(session, 0, 1)))
 
165
    return false;
 
166
 
 
167
  pthread_mutex_lock(&LOCK_create_db);
 
168
 
 
169
  SchemaIdentifier schema_idenifier(schema_message.name());
 
170
  if (not plugin::StorageEngine::doesSchemaExist(schema_idenifier))
 
171
  {
 
172
    my_error(ER_SCHEMA_DOES_NOT_EXIST, MYF(0), schema_message.name().c_str());
 
173
    return false;
 
174
  }
 
175
 
 
176
  /* Change options if current database is being altered. */
 
177
  bool success= plugin::StorageEngine::alterSchema(schema_message);
 
178
 
 
179
  if (success)
 
180
  {
 
181
    transaction_services.rawStatement(session, session->getQueryString());
 
182
    session->my_ok(1);
 
183
  }
 
184
  else
 
185
  {
 
186
    my_error(ER_ALTER_SCHEMA, MYF(0), schema_message.name().c_str());
 
187
  }
 
188
 
 
189
  pthread_mutex_unlock(&LOCK_create_db);
 
190
  start_waiting_global_read_lock(session);
192
191
 
193
192
  return success;
194
193
}
198
197
  Drop all tables in a database and the database itself
199
198
 
200
199
  SYNOPSIS
201
 
    rm_db()
 
200
    mysql_rm_db()
202
201
    session                     Thread handle
203
202
    db                  Database name in the case given by user
204
203
                        It's already validated and set to lower case
211
210
    ERROR Error
212
211
*/
213
212
 
214
 
bool rm_db(Session *session, identifier::Schema &schema_identifier, const bool if_exists)
 
213
bool mysql_rm_db(Session *session, SchemaIdentifier &schema_identifier, const bool if_exists)
215
214
{
216
 
  bool error= false;
 
215
  long deleted=0;
 
216
  int error= false;
 
217
  TableIdentifiers dropped_tables;
 
218
  message::Schema schema_proto;
217
219
 
218
220
  /*
219
221
    Do not drop database if another thread is holding read lock.
220
 
    Wait for global read lock before acquiring session->catalog()->schemaLock().
 
222
    Wait for global read lock before acquiring LOCK_create_db.
221
223
    After wait_if_global_read_lock() we have protection against another
222
 
    global read lock. If we would acquire session->catalog()->schemaLock() first,
 
224
    global read lock. If we would acquire LOCK_create_db first,
223
225
    another thread could step in and get the global read lock before we
224
226
    reach wait_if_global_read_lock(). If this thread tries the same as we
225
 
    (admin a db), it would then go and wait on session->catalog()->schemaLock()...
 
227
    (admin a db), it would then go and wait on LOCK_create_db...
226
228
    Furthermore wait_if_global_read_lock() checks if the current thread
227
229
    has the global read lock and refuses the operation with
228
230
    ER_CANT_UPDATE_WITH_READLOCK if applicable.
229
231
  */
230
 
  if (session->wait_if_global_read_lock(false, true))
231
 
  {
232
 
    return true;
233
 
  }
234
 
 
235
 
  do
236
 
  {
237
 
    boost::mutex::scoped_lock scopedLock(session->catalog().schemaLock());
238
 
 
239
 
    /* See if the schema exists */
240
 
    if (not plugin::StorageEngine::doesSchemaExist(schema_identifier))
 
232
  if (wait_if_global_read_lock(session, 0, 1))
 
233
  {
 
234
    return -1;
 
235
  }
 
236
 
 
237
  // Lets delete the temporary tables first outside of locks.  
 
238
  set<string> set_of_names;
 
239
  session->doGetTableNames(schema_identifier, set_of_names);
 
240
 
 
241
  for (set<string>::iterator iter= set_of_names.begin(); iter != set_of_names.end(); iter++)
 
242
  {
 
243
    TableIdentifier identifier(schema_identifier, *iter, message::Table::TEMPORARY);
 
244
    Table *table= session->find_temporary_table(identifier);
 
245
    session->close_temporary_table(table);
 
246
  }
 
247
 
 
248
  pthread_mutex_lock(&LOCK_create_db);
 
249
 
 
250
 
 
251
  /* See if the schema exists */
 
252
  if (not plugin::StorageEngine::doesSchemaExist(schema_identifier))
 
253
  {
 
254
    if (if_exists)
241
255
    {
242
 
      if (if_exists)
243
 
      {
244
 
        std::string path;
245
 
        schema_identifier.getSQLPath(path);
246
 
 
247
 
        push_warning_printf(session, DRIZZLE_ERROR::WARN_LEVEL_NOTE,
248
 
                            ER_DB_DROP_EXISTS, ER(ER_DB_DROP_EXISTS),
249
 
                            path.c_str());
250
 
      }
251
 
      else
252
 
      {
253
 
        error= true;
254
 
        my_error(ER_DB_DROP_EXISTS, schema_identifier);
255
 
        break;
256
 
      }
 
256
      push_warning_printf(session, DRIZZLE_ERROR::WARN_LEVEL_NOTE,
 
257
                          ER_DB_DROP_EXISTS, ER(ER_DB_DROP_EXISTS),
 
258
                          schema_identifier.getSQLPath().c_str());
257
259
    }
258
260
    else
259
261
    {
260
 
      error= plugin::StorageEngine::dropSchema(*session, schema_identifier);
261
 
    }
262
 
 
263
 
  } while (0);
264
 
 
 
262
      error= -1;
 
263
      my_error(ER_DB_DROP_EXISTS, MYF(0), schema_identifier.getSQLPath().c_str());
 
264
      goto exit;
 
265
    }
 
266
  }
 
267
  else
 
268
  {
 
269
    pthread_mutex_lock(&LOCK_open); /* After deleting database, remove all cache entries related to schema */
 
270
    remove_db_from_cache(schema_identifier);
 
271
    pthread_mutex_unlock(&LOCK_open);
 
272
 
 
273
 
 
274
    error= -1;
 
275
    deleted= drop_tables_via_filenames(session, schema_identifier, dropped_tables);
 
276
    if (deleted >= 0)
 
277
    {
 
278
      error= 0;
 
279
    }
 
280
  }
 
281
  if (deleted >= 0)
 
282
  {
 
283
    assert(! session->query.empty());
 
284
 
 
285
    TransactionServices &transaction_services= TransactionServices::singleton();
 
286
    transaction_services.dropSchema(session, schema_identifier.getSchemaName());
 
287
    session->clear_error();
 
288
    session->server_status|= SERVER_STATUS_DB_DROPPED;
 
289
    session->my_ok((uint32_t) deleted);
 
290
    session->server_status&= ~SERVER_STATUS_DB_DROPPED;
 
291
  }
 
292
  else
 
293
  {
 
294
    char *query, *query_pos, *query_end, *query_data_start;
 
295
 
 
296
    if (!(query= (char*) session->alloc(MAX_DROP_TABLE_Q_LEN)))
 
297
      goto exit; /* not much else we can do */
 
298
    query_pos= query_data_start= strcpy(query,"drop table ")+11;
 
299
    query_end= query + MAX_DROP_TABLE_Q_LEN;
 
300
 
 
301
    TransactionServices &transaction_services= TransactionServices::singleton();
 
302
    for (TableIdentifiers::iterator it= dropped_tables.begin();
 
303
         it != dropped_tables.end();
 
304
         it++)
 
305
    {
 
306
      uint32_t tbl_name_len;
 
307
 
 
308
      /* 3 for the quotes and the comma*/
 
309
      tbl_name_len= (*it).getTableName().length() + 3;
 
310
      if (query_pos + tbl_name_len + 1 >= query_end)
 
311
      {
 
312
        /* These DDL methods and logging protected with LOCK_create_db */
 
313
        transaction_services.rawStatement(session, query);
 
314
        query_pos= query_data_start;
 
315
      }
 
316
 
 
317
      *query_pos++ = '`';
 
318
      query_pos= strcpy(query_pos, (*it).getTableName().c_str()) + (tbl_name_len-3);
 
319
      *query_pos++ = '`';
 
320
      *query_pos++ = ',';
 
321
    }
 
322
 
 
323
    if (query_pos != query_data_start)
 
324
    {
 
325
      /* These DDL methods and logging protected with LOCK_create_db */
 
326
      transaction_services.rawStatement(session, query);
 
327
    }
 
328
  }
 
329
 
 
330
exit:
265
331
  /*
266
332
    If this database was the client's selected database, we silently
267
333
    change the client's selected database to nothing (to have an empty
268
334
    SELECT DATABASE() in the future). For this we free() session->db and set
269
335
    it to 0.
270
336
  */
271
 
  if (not error and schema_identifier.compare(*session->schema()))
272
 
    change_db_impl(session);
273
 
 
274
 
  session->startWaitingGlobalReadLock();
 
337
  if (schema_identifier.compare(session->db))
 
338
    mysql_change_db_impl(session);
 
339
  pthread_mutex_unlock(&LOCK_create_db);
 
340
  start_waiting_global_read_lock(session);
275
341
 
276
342
  return error;
277
343
}
278
344
 
 
345
 
 
346
static int rm_table_part2(Session *session, TableList *tables)
 
347
{
 
348
  TableList *table;
 
349
  String wrong_tables;
 
350
  int error= 0;
 
351
  bool foreign_key_error= false;
 
352
 
 
353
  pthread_mutex_lock(&LOCK_open); /* Part 2 of rm a table */
 
354
 
 
355
  /*
 
356
    If we have the table in the definition cache, we don't have to check the
 
357
    .frm cursor to find if the table is a normal table (not view) and what
 
358
    engine to use.
 
359
  */
 
360
 
 
361
  for (table= tables; table; table= table->next_local)
 
362
  {
 
363
    TableIdentifier identifier(table->db, table->table_name);
 
364
    TableShare *share;
 
365
    table->setDbType(NULL);
 
366
    if ((share= TableShare::getShare(identifier)))
 
367
    {
 
368
      table->setDbType(share->db_type());
 
369
    }
 
370
  }
 
371
 
 
372
  if (lock_table_names_exclusively(session, tables))
 
373
  {
 
374
    pthread_mutex_unlock(&LOCK_open);
 
375
    return 1;
 
376
  }
 
377
 
 
378
  /* Don't give warnings for not found errors, as we already generate notes */
 
379
  session->no_warnings_for_error= 1;
 
380
 
 
381
  for (table= tables; table; table= table->next_local)
 
382
  {
 
383
    char *db=table->db;
 
384
    plugin::StorageEngine *table_type;
 
385
 
 
386
    error= session->drop_temporary_table(table);
 
387
 
 
388
    switch (error) {
 
389
    case  0:
 
390
      // removed temporary table
 
391
      continue;
 
392
    case -1:
 
393
      error= 1;
 
394
      goto err_with_placeholders;
 
395
    default:
 
396
      // temporary table not found
 
397
      error= 0;
 
398
    }
 
399
 
 
400
    table_type= table->getDbType();
 
401
 
 
402
    TableIdentifier identifier(db, table->table_name);
 
403
 
 
404
    {
 
405
      Table *locked_table;
 
406
      abort_locked_tables(session, identifier);
 
407
      remove_table_from_cache(session, identifier,
 
408
                              RTFC_WAIT_OTHER_THREAD_FLAG |
 
409
                              RTFC_CHECK_KILLED_FLAG);
 
410
      /*
 
411
        If the table was used in lock tables, remember it so that
 
412
        unlock_table_names can free it
 
413
      */
 
414
      if ((locked_table= drop_locked_tables(session, identifier)))
 
415
        table->table= locked_table;
 
416
 
 
417
      if (session->killed)
 
418
      {
 
419
        error= -1;
 
420
        goto err_with_placeholders;
 
421
      }
 
422
    }
 
423
    identifier.getPath();
 
424
 
 
425
    if (table_type == NULL && not plugin::StorageEngine::doesTableExist(*session, identifier))
 
426
    {
 
427
      // Table was not found on disk and table can't be created from engine
 
428
      push_warning_printf(session, DRIZZLE_ERROR::WARN_LEVEL_NOTE,
 
429
                          ER_BAD_TABLE_ERROR, ER(ER_BAD_TABLE_ERROR),
 
430
                          table->table_name);
 
431
    }
 
432
    else
 
433
    {
 
434
      error= plugin::StorageEngine::dropTable(*session, identifier);
 
435
 
 
436
      if ((error == ENOENT || error == HA_ERR_NO_SUCH_TABLE))
 
437
      {
 
438
        error= 0;
 
439
        session->clear_error();
 
440
      }
 
441
 
 
442
      if (error == HA_ERR_ROW_IS_REFERENCED)
 
443
      {
 
444
        /* the table is referenced by a foreign key constraint */
 
445
        foreign_key_error= true;
 
446
      }
 
447
    }
 
448
 
 
449
    if (error == 0 || (foreign_key_error == false))
 
450
        write_bin_log_drop_table(session, true, db, table->table_name);
 
451
 
 
452
    if (error)
 
453
    {
 
454
      if (wrong_tables.length())
 
455
        wrong_tables.append(',');
 
456
      wrong_tables.append(String(table->table_name,system_charset_info));
 
457
    }
 
458
  }
 
459
  /*
 
460
    It's safe to unlock LOCK_open: we have an exclusive lock
 
461
    on the table name.
 
462
  */
 
463
  pthread_mutex_unlock(&LOCK_open);
 
464
  error= 0;
 
465
  if (wrong_tables.length())
 
466
  {
 
467
    if (not foreign_key_error)
 
468
      my_printf_error(ER_BAD_TABLE_ERROR, ER(ER_BAD_TABLE_ERROR), MYF(0),
 
469
                      wrong_tables.c_ptr());
 
470
    else
 
471
    {
 
472
      my_message(ER_ROW_IS_REFERENCED, ER(ER_ROW_IS_REFERENCED), MYF(0));
 
473
    }
 
474
    error= 1;
 
475
  }
 
476
 
 
477
  pthread_mutex_lock(&LOCK_open); /* final bit in rm table lock */
 
478
err_with_placeholders:
 
479
  unlock_table_names(tables, NULL);
 
480
  pthread_mutex_unlock(&LOCK_open);
 
481
  session->no_warnings_for_error= 0;
 
482
 
 
483
  return(error);
 
484
}
 
485
 
 
486
/*
 
487
  Removes files with known extensions plus.
 
488
  session MUST be set when calling this function!
 
489
*/
 
490
 
 
491
static long drop_tables_via_filenames(Session *session,
 
492
                                      SchemaIdentifier &schema_identifier,
 
493
                                      TableIdentifiers &dropped_tables)
 
494
{
 
495
  long deleted= 0;
 
496
  TableList *tot_list= NULL, **tot_list_next;
 
497
 
 
498
  tot_list_next= &tot_list;
 
499
 
 
500
  plugin::StorageEngine::getIdentifiers(*session, schema_identifier, dropped_tables);
 
501
 
 
502
  for (TableIdentifiers::iterator it= dropped_tables.begin();
 
503
       it != dropped_tables.end();
 
504
       it++)
 
505
  {
 
506
    size_t db_len= schema_identifier.getSchemaName().size();
 
507
 
 
508
    /* Drop the table nicely */
 
509
    TableList *table_list=(TableList*)
 
510
      session->calloc(sizeof(*table_list) +
 
511
                      db_len + 1 +
 
512
                      (*it).getTableName().length() + 1);
 
513
 
 
514
    if (not table_list)
 
515
      return -1;
 
516
 
 
517
    table_list->db= (char*) (table_list+1);
 
518
    table_list->table_name= strcpy(table_list->db, schema_identifier.getSchemaName().c_str()) + db_len + 1;
 
519
    TableIdentifier::filename_to_tablename((*it).getTableName().c_str(), table_list->table_name, (*it).getTableName().size() + 1);
 
520
    table_list->alias= table_list->table_name;  // If lower_case_table_names=2
 
521
    table_list->setInternalTmpTable((strncmp((*it).getTableName().c_str(),
 
522
                                             TMP_FILE_PREFIX,
 
523
                                             strlen(TMP_FILE_PREFIX)) == 0));
 
524
    /* Link into list */
 
525
    (*tot_list_next)= table_list;
 
526
    tot_list_next= &table_list->next_local;
 
527
    deleted++;
 
528
  }
 
529
  if (session->killed)
 
530
    return -1;
 
531
 
 
532
  if (tot_list)
 
533
  {
 
534
    if (rm_table_part2(session, tot_list))
 
535
      return -1;
 
536
  }
 
537
 
 
538
 
 
539
  if (not plugin::StorageEngine::dropSchema(schema_identifier))
 
540
  {
 
541
    my_error(ER_DROP_SCHEMA, MYF(0), schema_identifier.getSQLPath().c_str());
 
542
    return -1;
 
543
  }
 
544
 
 
545
  return deleted;
 
546
}
 
547
 
279
548
/**
280
549
  @brief Change the current database and its attributes unconditionally.
281
550
 
338
607
    @retval true  Error
339
608
*/
340
609
 
341
 
bool change_db(Session *session, identifier::Schema &schema_identifier)
 
610
bool mysql_change_db(Session *session, SchemaIdentifier &schema_identifier)
342
611
{
343
612
 
344
 
  if (not plugin::Authorization::isAuthorized(session->user(), schema_identifier))
 
613
  if (not plugin::Authorization::isAuthorized(session->getSecurityContext(), schema_identifier))
345
614
  {
346
615
    /* Error message is set in isAuthorized */
347
616
    return true;
349
618
 
350
619
  if (not check_db_name(session, schema_identifier))
351
620
  {
352
 
    my_error(ER_WRONG_DB_NAME, schema_identifier);
 
621
    my_error(ER_WRONG_DB_NAME, MYF(0), schema_identifier.getSQLPath().c_str());
353
622
 
354
623
    return true;
355
624
  }
356
625
 
357
626
  if (not plugin::StorageEngine::doesSchemaExist(schema_identifier))
358
627
  {
359
 
    my_error(ER_BAD_DB_ERROR, schema_identifier);
 
628
    /* Report an error and free new_db_file_name. */
 
629
 
 
630
    my_error(ER_BAD_DB_ERROR, MYF(0), schema_identifier.getSQLPath().c_str());
360
631
 
361
632
    /* The operation failed. */
362
633
 
363
634
    return true;
364
635
  }
365
636
 
366
 
  change_db_impl(session, schema_identifier);
 
637
  mysql_change_db_impl(session, schema_identifier);
367
638
 
368
639
  return false;
369
640
}
379
650
  @param new_db_charset Character set of the new database.
380
651
*/
381
652
 
382
 
static void change_db_impl(Session *session, identifier::Schema &schema_identifier)
 
653
static void mysql_change_db_impl(Session *session, SchemaIdentifier &schema_identifier)
383
654
{
384
655
  /* 1. Change current database in Session. */
385
656
 
402
673
      the previous database name, we should do it explicitly.
403
674
    */
404
675
 
405
 
    session->set_db(schema_identifier.getSchemaName());
 
676
    session->set_db(schema_identifier.getLower());
406
677
  }
407
678
}
408
679
 
409
 
static void change_db_impl(Session *session)
 
680
static void mysql_change_db_impl(Session *session)
410
681
{
411
682
  session->set_db(string());
412
683
}