← 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-11-29 07:05:33 UTC
  • mfrom: (1960.1.2 refactor)
  • Revision ID: brian@tangent.org-20101129070533-grqo3e8by2wqqpcd
Rollup of scoped lock.

Show diffs side-by-side

added added

removed removed

Lines of Context:
drizzled/db.cc
360
360
  int error= 0;
361
361
  bool foreign_key_error= false;
362
362
 
363
 
  table::Cache::singleton().mutex().lock(); /* Part 2 of rm a table */
364
 
 
365
 
  if (session->lock_table_names_exclusively(tables))
366
 
  {
367
 
    table::Cache::singleton().mutex().unlock();
368
 
    return 1;
369
 
  }
370
 
 
371
 
  /* Don't give warnings for not found errors, as we already generate notes */
372
 
  session->no_warnings_for_error= 1;
373
 
 
374
 
  for (table= tables; table; table= table->next_local)
375
 
  {
376
 
    const char *db=table->getSchemaName();
377
 
    TableIdentifier identifier(table->getSchemaName(), table->getTableName());
378
 
 
379
 
    plugin::StorageEngine *table_type;
380
 
 
381
 
    error= session->drop_temporary_table(identifier);
382
 
 
383
 
    switch (error) {
384
 
    case  0:
385
 
      // removed temporary table
386
 
      continue;
387
 
    case -1:
388
 
      error= 1;
389
 
      tables->unlock_table_names();
 
363
  {
 
364
    table::Cache::singleton().mutex().lock(); /* Part 2 of rm a table */
 
365
 
 
366
    if (session->lock_table_names_exclusively(tables))
 
367
    {
390
368
      table::Cache::singleton().mutex().unlock();
391
 
      session->no_warnings_for_error= 0;
392
 
 
393
 
      return(error);
394
 
    default:
395
 
      // temporary table not found
396
 
      error= 0;
 
369
      return 1;
397
370
    }
398
371
 
399
 
    table_type= table->getDbType();
 
372
    /* Don't give warnings for not found errors, as we already generate notes */
 
373
    session->no_warnings_for_error= 1;
400
374
 
 
375
    for (table= tables; table; table= table->next_local)
401
376
    {
402
 
      Table *locked_table;
403
 
      abort_locked_tables(session, identifier);
404
 
      table::Cache::singleton().removeTable(session, identifier,
405
 
                                            RTFC_WAIT_OTHER_THREAD_FLAG |
406
 
                                            RTFC_CHECK_KILLED_FLAG);
407
 
      /*
408
 
        If the table was used in lock tables, remember it so that
409
 
        unlock_table_names can free it
410
 
      */
411
 
      if ((locked_table= drop_locked_tables(session, identifier)))
412
 
        table->table= locked_table;
413
 
 
414
 
      if (session->getKilled())
415
 
      {
416
 
        error= -1;
 
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;
417
390
        tables->unlock_table_names();
418
391
        table::Cache::singleton().mutex().unlock();
419
392
        session->no_warnings_for_error= 0;
420
393
 
421
394
        return(error);
422
 
      }
423
 
    }
424
 
    identifier.getPath();
425
 
 
426
 
    if (table_type == NULL && not plugin::StorageEngine::doesTableExist(*session, identifier))
427
 
    {
428
 
      // Table was not found on disk and table can't be created from engine
429
 
      push_warning_printf(session, DRIZZLE_ERROR::WARN_LEVEL_NOTE,
430
 
                          ER_BAD_TABLE_ERROR, ER(ER_BAD_TABLE_ERROR),
431
 
                          table->getTableName());
432
 
    }
433
 
    else
434
 
    {
435
 
      error= plugin::StorageEngine::dropTable(*session, identifier);
436
 
 
437
 
      if ((error == ENOENT || error == HA_ERR_NO_SUCH_TABLE))
438
 
      {
439
 
        error= 0;
440
 
        session->clear_error();
441
 
      }
442
 
 
443
 
      if (error == HA_ERR_ROW_IS_REFERENCED)
444
 
      {
445
 
        /* the table is referenced by a foreign key constraint */
446
 
        foreign_key_error= true;
447
 
      }
448
 
    }
449
 
 
450
 
    if (error == 0 || (foreign_key_error == false))
451
 
    {
452
 
      transaction_services.dropTable(session, string(db), string(table->getTableName()), true);
453
 
    }
454
 
 
455
 
    if (error)
456
 
    {
457
 
      if (wrong_tables.length())
458
 
        wrong_tables.append(',');
459
 
      wrong_tables.append(String(table->getTableName(),system_charset_info));
460
 
    }
 
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();
461
468
  }
462
 
  /*
463
 
    It's safe to unlock table::Cache::singleton().mutex(): we have an exclusive lock
464
 
    on the table name.
465
 
  */
466
 
  table::Cache::singleton().mutex().unlock();
 
469
 
467
470
  error= 0;
468
471
  if (wrong_tables.length())
469
472
  {
477
480
    error= 1;
478
481
  }
479
482
 
480
 
  table::Cache::singleton().mutex().lock(); /* final bit in rm table lock */
481
 
  tables->unlock_table_names();
482
 
  table::Cache::singleton().mutex().unlock();
 
483
  {
 
484
    boost::mutex::scoped_lock scopedLock(table::Cache::singleton().mutex()); /* final bit in rm table lock */
 
485
    tables->unlock_table_names();
 
486
  }
483
487
  session->no_warnings_for_error= 0;
484
488
 
485
489
  return(error);