← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to drizzled/db.cc

  • Committer: Andrew Hutchings
  • Date: 2010-09-20 09:18:16 UTC
  • mto: (1782.1.1 build)
  • mto: This revision was merged to the branch mainline in revision 1783.
  • Revision ID: andrew@linuxjedi.co.uk-20100920091816-agms391fhq6rgran
Fix pandora linking requirements for boost filesystem and make it required.

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 */
59
59
 
60
60
static long drop_tables_via_filenames(Session *session,
61
61
                                 SchemaIdentifier &schema_identifier,
62
 
                                 TableIdentifier::vector &dropped_tables);
 
62
                                 TableIdentifiers &dropped_tables);
63
63
static void mysql_change_db_impl(Session *session);
64
64
static void mysql_change_db_impl(Session *session, SchemaIdentifier &schema_identifier);
65
65
 
101
101
    has the global read lock and refuses the operation with
102
102
    ER_CANT_UPDATE_WITH_READLOCK if applicable.
103
103
  */
104
 
  if (session->wait_if_global_read_lock(false, true))
 
104
  if (wait_if_global_read_lock(session, 0, 1))
105
105
  {
106
106
    return false;
107
107
  }
141
141
      session->my_ok(1);
142
142
    }
143
143
  }
144
 
  session->startWaitingGlobalReadLock();
 
144
  start_waiting_global_read_lock(session);
145
145
 
146
146
  return error;
147
147
}
165
165
    has the global read lock and refuses the operation with
166
166
    ER_CANT_UPDATE_WITH_READLOCK if applicable.
167
167
  */
168
 
  if ((session->wait_if_global_read_lock(false, true)))
 
168
  if ((wait_if_global_read_lock(session, 0, 1)))
169
169
    return false;
170
170
 
171
171
  bool success;
184
184
 
185
185
    if (success)
186
186
    {
187
 
      transaction_services.rawStatement(session, *session->getQueryString());
 
187
      transaction_services.rawStatement(session, session->getQueryString());
188
188
      session->my_ok(1);
189
189
    }
190
190
    else
192
192
      my_error(ER_ALTER_SCHEMA, MYF(0), schema_message.name().c_str());
193
193
    }
194
194
  }
195
 
  session->startWaitingGlobalReadLock();
 
195
  start_waiting_global_read_lock(session);
196
196
 
197
197
  return success;
198
198
}
219
219
{
220
220
  long deleted=0;
221
221
  int error= false;
222
 
  TableIdentifier::vector dropped_tables;
 
222
  TableIdentifiers dropped_tables;
223
223
  message::Schema schema_proto;
224
224
 
225
225
  /*
234
234
    has the global read lock and refuses the operation with
235
235
    ER_CANT_UPDATE_WITH_READLOCK if applicable.
236
236
  */
237
 
  if (session->wait_if_global_read_lock(false, true))
 
237
  if (wait_if_global_read_lock(session, 0, 1))
238
238
  {
239
239
    return -1;
240
240
  }
256
256
    /* See if the schema exists */
257
257
    if (not plugin::StorageEngine::doesSchemaExist(schema_identifier))
258
258
    {
259
 
      std::string path;
260
 
      schema_identifier.getSQLPath(path);
261
 
 
262
259
      if (if_exists)
263
260
      {
264
261
        push_warning_printf(session, DRIZZLE_ERROR::WARN_LEVEL_NOTE,
265
262
                            ER_DB_DROP_EXISTS, ER(ER_DB_DROP_EXISTS),
266
 
                            path.c_str());
 
263
                            schema_identifier.getSQLPath().c_str());
267
264
      }
268
265
      else
269
266
      {
270
267
        error= -1;
271
 
        my_error(ER_DB_DROP_EXISTS, MYF(0), path.c_str());
 
268
        my_error(ER_DB_DROP_EXISTS, MYF(0), schema_identifier.getSQLPath().c_str());
272
269
        goto exit;
273
270
      }
274
271
    }
275
272
    else
276
273
    {
277
 
      /* After deleting database, remove all cache entries related to schema */
278
 
      table::Cache::singleton().removeSchema(schema_identifier);
 
274
      LOCK_open.lock(); /* After deleting database, remove all cache entries related to schema */
 
275
      remove_db_from_cache(schema_identifier);
 
276
      LOCK_open.unlock();
279
277
 
280
278
 
281
279
      error= -1;
287
285
    }
288
286
    if (deleted >= 0)
289
287
    {
290
 
      assert(not session->getQueryString()->empty());
 
288
      assert(! session->query.empty());
291
289
 
292
290
      TransactionServices &transaction_services= TransactionServices::singleton();
293
291
      transaction_services.dropSchema(session, schema_identifier.getSchemaName());
306
304
      query_end= query + MAX_DROP_TABLE_Q_LEN;
307
305
 
308
306
      TransactionServices &transaction_services= TransactionServices::singleton();
309
 
      for (TableIdentifier::vector::iterator it= dropped_tables.begin();
 
307
      for (TableIdentifiers::iterator it= dropped_tables.begin();
310
308
           it != dropped_tables.end();
311
309
           it++)
312
310
      {
341
339
      SELECT DATABASE() in the future). For this we free() session->db and set
342
340
      it to 0.
343
341
    */
344
 
    if (schema_identifier.compare(*session->schema()))
 
342
    if (schema_identifier.compare(session->db))
345
343
      mysql_change_db_impl(session);
346
344
  }
347
345
 
348
 
  session->startWaitingGlobalReadLock();
 
346
  start_waiting_global_read_lock(session);
349
347
 
350
348
  return error;
351
349
}
360
358
  int error= 0;
361
359
  bool foreign_key_error= false;
362
360
 
363
 
  {
364
 
    table::Cache::singleton().mutex().lock(); /* Part 2 of rm a table */
365
 
 
366
 
    if (session->lock_table_names_exclusively(tables))
367
 
    {
368
 
      table::Cache::singleton().mutex().unlock();
369
 
      return 1;
370
 
    }
371
 
 
372
 
    /* Don't give warnings for not found errors, as we already generate notes */
373
 
    session->no_warnings_for_error= 1;
374
 
 
375
 
    for (table= tables; table; table= table->next_local)
376
 
    {
377
 
      const char *db=table->getSchemaName();
378
 
      TableIdentifier identifier(table->getSchemaName(), table->getTableName());
379
 
 
380
 
      plugin::StorageEngine *table_type;
381
 
 
382
 
      error= session->drop_temporary_table(identifier);
383
 
 
384
 
      switch (error) {
385
 
      case  0:
386
 
        // removed temporary table
387
 
        continue;
388
 
      case -1:
389
 
        error= 1;
390
 
        tables->unlock_table_names();
391
 
        table::Cache::singleton().mutex().unlock();
 
361
  LOCK_open.lock(); /* Part 2 of rm a table */
 
362
 
 
363
  /*
 
364
    If we have the table in the definition cache, we don't have to check the
 
365
    .frm cursor to find if the table is a normal table (not view) and what
 
366
    engine to use.
 
367
  */
 
368
 
 
369
  for (table= tables; table; table= table->next_local)
 
370
  {
 
371
    TableIdentifier identifier(table->db, table->table_name);
 
372
    TableShare *share;
 
373
    table->setDbType(NULL);
 
374
    if ((share= TableShare::getShare(identifier)))
 
375
    {
 
376
      table->setDbType(share->db_type());
 
377
    }
 
378
  }
 
379
 
 
380
  if (lock_table_names_exclusively(session, tables))
 
381
  {
 
382
    LOCK_open.unlock();
 
383
    return 1;
 
384
  }
 
385
 
 
386
  /* Don't give warnings for not found errors, as we already generate notes */
 
387
  session->no_warnings_for_error= 1;
 
388
 
 
389
  for (table= tables; table; table= table->next_local)
 
390
  {
 
391
    char *db=table->db;
 
392
    plugin::StorageEngine *table_type;
 
393
 
 
394
    error= session->drop_temporary_table(table);
 
395
 
 
396
    switch (error) {
 
397
    case  0:
 
398
      // removed temporary table
 
399
      continue;
 
400
    case -1:
 
401
      error= 1;
 
402
      unlock_table_names(tables, NULL);
 
403
      LOCK_open.unlock();
 
404
      session->no_warnings_for_error= 0;
 
405
 
 
406
      return(error);
 
407
    default:
 
408
      // temporary table not found
 
409
      error= 0;
 
410
    }
 
411
 
 
412
    table_type= table->getDbType();
 
413
 
 
414
    TableIdentifier identifier(db, table->table_name);
 
415
 
 
416
    {
 
417
      Table *locked_table;
 
418
      abort_locked_tables(session, identifier);
 
419
      remove_table_from_cache(session, identifier,
 
420
                              RTFC_WAIT_OTHER_THREAD_FLAG |
 
421
                              RTFC_CHECK_KILLED_FLAG);
 
422
      /*
 
423
        If the table was used in lock tables, remember it so that
 
424
        unlock_table_names can free it
 
425
      */
 
426
      if ((locked_table= drop_locked_tables(session, identifier)))
 
427
        table->table= locked_table;
 
428
 
 
429
      if (session->killed)
 
430
      {
 
431
        error= -1;
 
432
        unlock_table_names(tables, NULL);
 
433
        LOCK_open.unlock();
392
434
        session->no_warnings_for_error= 0;
393
435
 
394
436
        return(error);
395
 
      default:
396
 
        // temporary table not found
397
 
        error= 0;
398
 
      }
399
 
 
400
 
      table_type= table->getDbType();
401
 
 
402
 
      {
403
 
        Table *locked_table;
404
 
        abort_locked_tables(session, identifier);
405
 
        table::Cache::singleton().removeTable(session, identifier,
406
 
                                              RTFC_WAIT_OTHER_THREAD_FLAG |
407
 
                                              RTFC_CHECK_KILLED_FLAG);
408
 
        /*
409
 
          If the table was used in lock tables, remember it so that
410
 
          unlock_table_names can free it
411
 
        */
412
 
        if ((locked_table= drop_locked_tables(session, identifier)))
413
 
          table->table= locked_table;
414
 
 
415
 
        if (session->getKilled())
416
 
        {
417
 
          error= -1;
418
 
          tables->unlock_table_names();
419
 
          table::Cache::singleton().mutex().unlock();
420
 
          session->no_warnings_for_error= 0;
421
 
 
422
 
          return(error);
423
 
        }
424
 
      }
425
 
      identifier.getPath();
426
 
 
427
 
      if (table_type == NULL && not plugin::StorageEngine::doesTableExist(*session, identifier))
428
 
      {
429
 
        // Table was not found on disk and table can't be created from engine
430
 
        push_warning_printf(session, DRIZZLE_ERROR::WARN_LEVEL_NOTE,
431
 
                            ER_BAD_TABLE_ERROR, ER(ER_BAD_TABLE_ERROR),
432
 
                            table->getTableName());
433
 
      }
434
 
      else
435
 
      {
436
 
        error= plugin::StorageEngine::dropTable(*session, identifier);
437
 
 
438
 
        if ((error == ENOENT || error == HA_ERR_NO_SUCH_TABLE))
439
 
        {
440
 
          error= 0;
441
 
          session->clear_error();
442
 
        }
443
 
 
444
 
        if (error == HA_ERR_ROW_IS_REFERENCED)
445
 
        {
446
 
          /* the table is referenced by a foreign key constraint */
447
 
          foreign_key_error= true;
448
 
        }
449
 
      }
450
 
 
451
 
      if (error == 0 || (foreign_key_error == false))
452
 
      {
453
 
        transaction_services.dropTable(session, string(db), string(table->getTableName()), true);
454
 
      }
455
 
 
456
 
      if (error)
457
 
      {
458
 
        if (wrong_tables.length())
459
 
          wrong_tables.append(',');
460
 
        wrong_tables.append(String(table->getTableName(),system_charset_info));
461
 
      }
462
 
    }
463
 
    /*
464
 
      It's safe to unlock table::Cache::singleton().mutex(): we have an exclusive lock
465
 
      on the table name.
466
 
    */
467
 
    table::Cache::singleton().mutex().unlock();
 
437
      }
 
438
    }
 
439
    identifier.getPath();
 
440
 
 
441
    if (table_type == NULL && not plugin::StorageEngine::doesTableExist(*session, identifier))
 
442
    {
 
443
      // Table was not found on disk and table can't be created from engine
 
444
      push_warning_printf(session, DRIZZLE_ERROR::WARN_LEVEL_NOTE,
 
445
                          ER_BAD_TABLE_ERROR, ER(ER_BAD_TABLE_ERROR),
 
446
                          table->table_name);
 
447
    }
 
448
    else
 
449
    {
 
450
      error= plugin::StorageEngine::dropTable(*session, identifier);
 
451
 
 
452
      if ((error == ENOENT || error == HA_ERR_NO_SUCH_TABLE))
 
453
      {
 
454
        error= 0;
 
455
        session->clear_error();
 
456
      }
 
457
 
 
458
      if (error == HA_ERR_ROW_IS_REFERENCED)
 
459
      {
 
460
        /* the table is referenced by a foreign key constraint */
 
461
        foreign_key_error= true;
 
462
      }
 
463
    }
 
464
 
 
465
    if (error == 0 || (foreign_key_error == false))
 
466
    {
 
467
      transaction_services.dropTable(session, string(db), string(table->table_name), true);
 
468
    }
 
469
 
 
470
    if (error)
 
471
    {
 
472
      if (wrong_tables.length())
 
473
        wrong_tables.append(',');
 
474
      wrong_tables.append(String(table->table_name,system_charset_info));
 
475
    }
468
476
  }
469
 
 
 
477
  /*
 
478
    It's safe to unlock LOCK_open: we have an exclusive lock
 
479
    on the table name.
 
480
  */
 
481
  LOCK_open.unlock();
470
482
  error= 0;
471
483
  if (wrong_tables.length())
472
484
  {
480
492
    error= 1;
481
493
  }
482
494
 
483
 
  {
484
 
    boost::mutex::scoped_lock scopedLock(table::Cache::singleton().mutex()); /* final bit in rm table lock */
485
 
    tables->unlock_table_names();
486
 
  }
 
495
  LOCK_open.lock(); /* final bit in rm table lock */
 
496
  unlock_table_names(tables, NULL);
 
497
  LOCK_open.unlock();
487
498
  session->no_warnings_for_error= 0;
488
499
 
489
500
  return(error);
496
507
 
497
508
static long drop_tables_via_filenames(Session *session,
498
509
                                      SchemaIdentifier &schema_identifier,
499
 
                                      TableIdentifier::vector &dropped_tables)
 
510
                                      TableIdentifiers &dropped_tables)
500
511
{
501
512
  long deleted= 0;
502
513
  TableList *tot_list= NULL, **tot_list_next;
505
516
 
506
517
  plugin::StorageEngine::getIdentifiers(*session, schema_identifier, dropped_tables);
507
518
 
508
 
  for (TableIdentifier::vector::iterator it= dropped_tables.begin();
 
519
  for (TableIdentifiers::iterator it= dropped_tables.begin();
509
520
       it != dropped_tables.end();
510
521
       it++)
511
522
  {
520
531
    if (not table_list)
521
532
      return -1;
522
533
 
523
 
    table_list->setSchemaName((char*) (table_list+1));
524
 
    table_list->setTableName(strcpy((char*) (table_list+1), schema_identifier.getSchemaName().c_str()) + db_len + 1);
525
 
    TableIdentifier::filename_to_tablename((*it).getTableName().c_str(), const_cast<char *>(table_list->getTableName()), (*it).getTableName().size() + 1);
526
 
    table_list->alias= table_list->getTableName();  // If lower_case_table_names=2
 
534
    table_list->db= (char*) (table_list+1);
 
535
    table_list->table_name= strcpy(table_list->db, schema_identifier.getSchemaName().c_str()) + db_len + 1;
 
536
    TableIdentifier::filename_to_tablename((*it).getTableName().c_str(), table_list->table_name, (*it).getTableName().size() + 1);
 
537
    table_list->alias= table_list->table_name;  // If lower_case_table_names=2
527
538
    table_list->setInternalTmpTable((strncmp((*it).getTableName().c_str(),
528
539
                                             TMP_FILE_PREFIX,
529
540
                                             strlen(TMP_FILE_PREFIX)) == 0));
532
543
    tot_list_next= &table_list->next_local;
533
544
    deleted++;
534
545
  }
535
 
  if (session->getKilled())
 
546
  if (session->killed)
536
547
    return -1;
537
548
 
538
549
  if (tot_list)
544
555
 
545
556
  if (not plugin::StorageEngine::dropSchema(schema_identifier))
546
557
  {
547
 
    std::string path;
548
 
    schema_identifier.getSQLPath(path);
549
 
    my_error(ER_DROP_SCHEMA, MYF(0), path.c_str());
550
 
 
 
558
    my_error(ER_DROP_SCHEMA, MYF(0), schema_identifier.getSQLPath().c_str());
551
559
    return -1;
552
560
  }
553
561
 
627
635
 
628
636
  if (not check_db_name(session, schema_identifier))
629
637
  {
630
 
    std::string path;
631
 
    schema_identifier.getSQLPath(path);
632
 
    my_error(ER_WRONG_DB_NAME, MYF(0), path.c_str());
 
638
    my_error(ER_WRONG_DB_NAME, MYF(0), schema_identifier.getSQLPath().c_str());
633
639
 
634
640
    return true;
635
641
  }
637
643
  if (not plugin::StorageEngine::doesSchemaExist(schema_identifier))
638
644
  {
639
645
    /* Report an error and free new_db_file_name. */
640
 
    std::string path;
641
 
    schema_identifier.getSQLPath(path);
642
646
 
643
 
    my_error(ER_BAD_DB_ERROR, MYF(0), path.c_str());
 
647
    my_error(ER_BAD_DB_ERROR, MYF(0), schema_identifier.getSQLPath().c_str());
644
648
 
645
649
    /* The operation failed. */
646
650