~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to drizzled/handler.cc

• browse files at revision 593
• compare with another revision
• compare with revision 1089
• download diff
• download tarball
• view history from revision 593

Show diffs side-by-side

added

removed

drizzled/handler.cc

1368

1368

}

1369

1369

 

1370

1370

 

 

1371

struct handlerton_delete_table_args {

 

1372

  Session *session;

 

1373

  const char *path;

 

1374

  handler *file;

 

1375

  int error;

 

1376

};

 

1377

 

 

1378

static bool deletetable_handlerton(Session *unused1 __attribute__((unused)),

 

1379

                                   plugin_ref plugin,

 

1380

                                   void *args)

 

1381

{

 

1382

  struct handlerton_delete_table_args *dtargs= (struct handlerton_delete_table_args *) args;

 

1383

 

 

1384

  Session *session= dtargs->session;

 

1385

  const char *path= dtargs->path;

 

1386

 

 

1387

  handler *file;

 

1388

  char tmp_path[FN_REFLEN];

 

1389

 

 

1390

  if(dtargs->error!=ENOENT) /* already deleted table */

 

1391

    return false;

 

1392

 

 

1393

  handlerton *table_type= plugin_data(plugin, handlerton *);

 

1394

 

 

1395

  if(!table_type)

 

1396

    return false;

 

1397

 

 

1398

  if(!(table_type->state == SHOW_OPTION_YES && table_type->create))

 

1399

    return false;

 

1400

 

 

1401

  if ((file= table_type->create(table_type, NULL, session->mem_root)))

 

1402

    file->init();

 

1403

  else

 

1404

    return false;

 

1405

 

 

1406

  path= check_lowercase_names(file, path, tmp_path);

 

1407

  int error= file->ha_delete_table(path);

 

1408

 

 

1409

  if(error!=ENOENT)

 

1410

  {

 

1411

    dtargs->error= error;

 

1412

    if(dtargs->file)

 

1413

      delete dtargs->file;

 

1414

    dtargs->file= file;

 

1415

    return true;

 

1416

  }

 

1417

 

 

1418

  return false;

 

1419

}

 

1420

 

1371

1421

/**

1372

1422

  This should return ENOENT if the file doesn't exists.

1373

1423

  The .frm file will be deleted only if we return 0 or ENOENT

1374

1424

*/

1375

 

int ha_delete_table(Session *session, handlerton *table_type, const char *path,

 

1425

int ha_delete_table(Session *session, const char *path,

1376

1426

                    const char *db, const char *alias, bool generate_warning)

1377

1427

{

1378

 

  handler *file;

1379

 

  char tmp_path[FN_REFLEN];

1380

 

  int error;

 

1428

  TABLE_SHARE dummy_share;

1381

1429

  Table dummy_table;

1382

 

  TABLE_SHARE dummy_share;

 

1430

 

 

1431

  struct handlerton_delete_table_args dtargs;

 

1432

  dtargs.error= ENOENT;

 

1433

  dtargs.session= session;

 

1434

  dtargs.path= path;

 

1435

  dtargs.file= NULL;

 

1436

 

 

1437

  plugin_foreach(NULL, deletetable_handlerton, DRIZZLE_STORAGE_ENGINE_PLUGIN,

 

1438

                 &dtargs);

1383

1439

 

1384

1440

  memset(&dummy_table, 0, sizeof(dummy_table));

1385

1441

  memset(&dummy_share, 0, sizeof(dummy_share));

1386

1442

  dummy_table.s= &dummy_share;

1387

1443

 

1388

 

  /* DB_TYPE_UNKNOWN is used in ALTER Table when renaming only .frm files */

1389

 

  if (table_type == NULL ||

1390

 

      ! (file=get_new_handler((TABLE_SHARE*)0, session->mem_root, table_type)))

1391

 

    return(ENOENT);

1392

 

 

1393

 

  path= check_lowercase_names(file, path, tmp_path);

1394

 

  if ((error= file->ha_delete_table(path)) && generate_warning)

 

1444

  if (dtargs.error && generate_warning)

1395

1445

  {

1396

1446

    /*

1397

1447

      Because file->print_error() use my_error() to generate the error message

1410

1460

    dummy_share.table_name.length= strlen(alias);

1411

1461

    dummy_table.alias= alias;

1412

1462

 

 

1463

    handler *file= dtargs.file;

1413

1464

    file->change_table_ptr(&dummy_table, &dummy_share);

1414

1465

 

1415

1466

    session->push_internal_handler(&ha_delete_table_error_handler);

1416

 

    file->print_error(error, 0);

 

1467

    file->print_error(dtargs.error, 0);

1417

1468

 

1418

1469

    session->pop_internal_handler();

1419

1470

 

1421

1472

      XXX: should we convert *all* errors to warnings here?

1422

1473

      What if the error is fatal?

1423

1474

    */

1424

 

    push_warning(session, DRIZZLE_ERROR::WARN_LEVEL_ERROR, error,

 

1475

    push_warning(session, DRIZZLE_ERROR::WARN_LEVEL_ERROR, dtargs.error,

1425

1476

                ha_delete_table_error_handler.buff);

1426

1477

  }

1427

 

  delete file;

1428

 

  return(error);

 

1478

 

 

1479

  if(dtargs.file)

 

1480

    delete dtargs.file;

 

1481

 

 

1482

  return dtargs.error;

1429

1483

}

1430

1484

 

1431

1485

/****************************************************************************

2317

2371

  return 0;

2318

2372

}

2319

2373

 

2320

 

 

2321

 

static bool update_frm_version(Table *table)

2322

 

{

2323

 

  char path[FN_REFLEN];

2324

 

  File file;

2325

 

  bool result= true;

2326

 

 

2327

 

  /*

2328

 

    No need to update frm version in case table was created or checked

2329

 

    by server with the same version. This also ensures that we do not

2330

 

    update frm version for temporary tables as this code doesn't support

2331

 

    temporary tables.

2332

 

  */

2333

 

  if (table->s->mysql_version == DRIZZLE_VERSION_ID)

2334

 

    return(0);

2335

 

 

2336

 

  strxmov(path, table->s->normalized_path.str, reg_ext, NULL);

2337

 

 

2338

 

  if ((file= my_open(path, O_RDWR, MYF(MY_WME))) >= 0)

2339

 

  {

2340

 

    unsigned char version[4];

2341

 

    char *key= table->s->table_cache_key.str;

2342

 

    uint32_t key_length= table->s->table_cache_key.length;

2343

 

    Table *entry;

2344

 

    HASH_SEARCH_STATE state;

2345

 

 

2346

 

    int4store(version, DRIZZLE_VERSION_ID);

2347

 

 

2348

 

    if (pwrite(file, (unsigned char*)version, 4, 51L) == 0)

2349

 

    {

2350

 

      result= false;

2351

 

      goto err;

2352

 

    }

2353

 

 

2354

 

    for (entry=(Table*) hash_first(&open_cache,(unsigned char*) key,key_length, &state);

2355

 

         entry;

2356

 

         entry= (Table*) hash_next(&open_cache,(unsigned char*) key,key_length, &state))

2357

 

      entry->s->mysql_version= DRIZZLE_VERSION_ID;

2358

 

  }

2359

 

err:

2360

 

  if (file >= 0)

2361

 

    my_close(file,MYF(MY_WME));

2362

 

  return(result);

2363

 

}

2364

 

 

2365

 

 

2366

 

 

2367

2374

/**

2368

2375

  @return

2369

2376

    key if error because of duplicated keys

2474

2481

  }

2475

2482

  if ((error= check(session, check_opt)))

2476

2483

    return error;

2477

 

  return update_frm_version(table);

 

2484

  return HA_ADMIN_OK;

2478

2485

}

2479

2486

 

2480

2487

/**

2522

2529

 

2523

2530

  if ((result= repair(session, check_opt)))

2524

2531

    return result;

2525

 

  return update_frm_version(table);

 

2532

  return HA_ADMIN_OK;

2526

2533

}

2527

2534

 

2528

2535

 

• Older »

Loggerhead is a web-based interface for Breezy
Version: 2.0.1