← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to drizzled/plugin/storage_engine.cc

  • Committer: Jay Pipes
  • Date: 2010-04-23 17:43:11 UTC
  • mto: This revision was merged to the branch mainline in revision 1524.
  • Revision ID: jpipes@serialcoder-20100423174311-ze5sq5nrbb7km2po
ha_rnd_init -> startTableScan, rnd_init -> doStartTableScan, ha_rnd_end -> endTableScan, rnd_end -> doEndTableScan

Show diffs side-by-side

added added

removed removed

Lines of Context:
drizzled/plugin/storage_engine.cc
32
32
#include <google/protobuf/io/zero_copy_stream.h>
33
33
#include <google/protobuf/io/zero_copy_stream_impl.h>
34
34
 
 
35
#include "drizzled/my_hash.h"
35
36
#include "drizzled/cached_directory.h"
36
37
 
37
38
#include <drizzled/definitions.h>
52
53
#include "drizzled/db.h"
53
54
 
54
55
#include <drizzled/table_proto.h>
55
 
#include <drizzled/plugin/event_observer.h>
56
 
 
57
 
#include <drizzled/table/shell.h>
58
 
 
59
 
#include "drizzled/message/cache.h"
60
 
 
61
 
#include <boost/algorithm/string/compare.hpp>
62
56
 
63
57
static bool shutdown_has_begun= false; // Once we put in the container for the vector/etc for engines this will go away.
64
58
 
 
59
using namespace std;
 
60
 
65
61
namespace drizzled
66
62
{
67
63
 
71
67
static EngineVector vector_of_engines;
72
68
static EngineVector vector_of_schema_engines;
73
69
 
74
 
const std::string DEFAULT_STRING("default");
75
70
const std::string UNKNOWN_STRING("UNKNOWN");
76
71
const std::string DEFAULT_DEFINITION_FILE_EXT(".dfe");
77
72
 
82
77
  return vector_of_schema_engines;
83
78
}
84
79
 
85
 
StorageEngine::StorageEngine(const std::string name_arg,
86
 
                             const std::bitset<HTON_BIT_SIZE> &flags_arg) :
 
80
StorageEngine::StorageEngine(const string name_arg,
 
81
                             const bitset<HTON_BIT_SIZE> &flags_arg) :
87
82
  Plugin(name_arg, "StorageEngine"),
88
83
  MonitoredInTransaction(), /* This gives the storage engine a "slot" or ID */
89
84
  flags(flags_arg)
101
96
}
102
97
 
103
98
 
104
 
int StorageEngine::renameTable(Session &session, const TableIdentifier &from, const TableIdentifier &to)
 
99
int StorageEngine::renameTable(Session &session, TableIdentifier &from, TableIdentifier &to)
105
100
{
106
 
  int error;
107
101
  setTransactionReadWrite(session);
108
102
 
109
 
  if (unlikely(plugin::EventObserver::beforeRenameTable(session, from, to)))
110
 
  {
111
 
    error= ER_EVENT_OBSERVER_PLUGIN;
112
 
  }
113
 
  else
114
 
  {
115
 
    error =  doRenameTable(session, from, to);
116
 
    if (unlikely(plugin::EventObserver::afterRenameTable(session, from, to, error)))
117
 
    {
118
 
      error= ER_EVENT_OBSERVER_PLUGIN;
119
 
    }
120
 
  }
121
 
  
122
 
  return error;
 
103
  return doRenameTable(session, from, to);
123
104
}
124
105
 
125
106
/**
137
118
  @retval
138
119
    !0  Error
139
120
*/
140
 
int StorageEngine::doDropTable(Session&, const TableIdentifier &identifier)
 
121
int StorageEngine::doDropTable(Session&, TableIdentifier &identifier)
141
122
                               
142
123
{
143
124
  int error= 0;
192
173
}
193
174
 
194
175
class FindEngineByName
195
 
  : public std::unary_function<StorageEngine *, bool>
 
176
  : public unary_function<StorageEngine *, bool>
196
177
{
197
 
  const std::string &predicate;
 
178
  const string &target;
198
179
 
199
180
public:
200
 
  explicit FindEngineByName(const std::string &target_arg) :
201
 
    predicate(target_arg)
 
181
  explicit FindEngineByName(const string &target_arg) :
 
182
    target(target_arg)
202
183
  {
203
184
  }
204
 
 
205
185
  result_type operator() (argument_type engine)
206
186
  {
207
 
    return boost::iequals(engine->getName(), predicate);
 
187
    string engine_name(engine->getName());
 
188
 
 
189
    transform(engine_name.begin(), engine_name.end(),
 
190
              engine_name.begin(), ::tolower);
 
191
    return engine_name == target;
208
192
  }
209
193
};
210
194
 
211
 
StorageEngine *StorageEngine::findByName(const std::string &predicate)
 
195
StorageEngine *StorageEngine::findByName(const string &find_str)
212
196
{
213
 
  EngineVector::iterator iter= std::find_if(vector_of_engines.begin(),
214
 
                                            vector_of_engines.end(),
215
 
                                            FindEngineByName(predicate));
 
197
  string search_string(find_str);
 
198
  transform(search_string.begin(), search_string.end(),
 
199
            search_string.begin(), ::tolower);
 
200
 
 
201
  
 
202
  EngineVector::iterator iter= find_if(vector_of_engines.begin(),
 
203
                                       vector_of_engines.end(),
 
204
                                       FindEngineByName(search_string));
216
205
  if (iter != vector_of_engines.end())
217
206
  {
218
207
    StorageEngine *engine= *iter;
223
212
  return NULL;
224
213
}
225
214
 
226
 
StorageEngine *StorageEngine::findByName(Session& session, const std::string &predicate)
 
215
StorageEngine *StorageEngine::findByName(Session& session, const string &find_str)
227
216
{
228
 
  if (boost::iequals(predicate, DEFAULT_STRING))
 
217
  string search_string(find_str);
 
218
  transform(search_string.begin(), search_string.end(),
 
219
            search_string.begin(), ::tolower);
 
220
 
 
221
  if (search_string.compare("default") == 0)
229
222
    return session.getDefaultStorageEngine();
230
223
 
231
 
  EngineVector::iterator iter= std::find_if(vector_of_engines.begin(),
232
 
                                            vector_of_engines.end(),
233
 
                                            FindEngineByName(predicate));
 
224
  EngineVector::iterator iter= find_if(vector_of_engines.begin(),
 
225
                                       vector_of_engines.end(),
 
226
                                       FindEngineByName(search_string));
234
227
  if (iter != vector_of_engines.end())
235
228
  {
236
229
    StorageEngine *engine= *iter;
241
234
  return NULL;
242
235
}
243
236
 
244
 
class StorageEngineCloseConnection : public std::unary_function<StorageEngine *, void>
 
237
class StorageEngineCloseConnection : public unary_function<StorageEngine *, void>
245
238
{
246
239
  Session *session;
247
240
public:
263
256
*/
264
257
void StorageEngine::closeConnection(Session* session)
265
258
{
266
 
  std::for_each(vector_of_engines.begin(), vector_of_engines.end(),
267
 
                StorageEngineCloseConnection(session));
 
259
  for_each(vector_of_engines.begin(), vector_of_engines.end(),
 
260
           StorageEngineCloseConnection(session));
268
261
}
269
262
 
270
263
bool StorageEngine::flushLogs(StorageEngine *engine)
271
264
{
272
265
  if (engine == NULL)
273
266
  {
274
 
    if (std::find_if(vector_of_engines.begin(), vector_of_engines.end(),
275
 
                     std::mem_fun(&StorageEngine::flush_logs))
 
267
    if (find_if(vector_of_engines.begin(), vector_of_engines.end(),
 
268
                mem_fun(&StorageEngine::flush_logs))
276
269
        != vector_of_engines.begin())
277
270
      return true;
278
271
  }
284
277
  return false;
285
278
}
286
279
 
287
 
class StorageEngineGetTableDefinition: public std::unary_function<StorageEngine *,bool>
 
280
class StorageEngineGetTableDefinition: public unary_function<StorageEngine *,bool>
288
281
{
289
282
  Session& session;
290
 
  const TableIdentifier &identifier;
 
283
  TableIdentifier &identifier;
291
284
  message::Table &table_message;
292
285
  int &err;
293
286
 
294
287
public:
295
288
  StorageEngineGetTableDefinition(Session& session_arg,
296
 
                                  const TableIdentifier &identifier_arg,
 
289
                                  TableIdentifier &identifier_arg,
297
290
                                  message::Table &table_message_arg,
298
291
                                  int &err_arg) :
299
292
    session(session_arg), 
312
305
  }
313
306
};
314
307
 
315
 
class StorageEngineDoesTableExist: public std::unary_function<StorageEngine *, bool>
 
308
class StorageEngineDoesTableExist: public unary_function<StorageEngine *, bool>
316
309
{
317
310
  Session& session;
318
 
  const TableIdentifier &identifier;
 
311
  TableIdentifier &identifier;
319
312
 
320
313
public:
321
 
  StorageEngineDoesTableExist(Session& session_arg, const TableIdentifier &identifier_arg) :
 
314
  StorageEngineDoesTableExist(Session& session_arg, TableIdentifier &identifier_arg) :
322
315
    session(session_arg), 
323
316
    identifier(identifier_arg) 
324
317
  { }
333
326
  Utility method which hides some of the details of getTableDefinition()
334
327
*/
335
328
bool plugin::StorageEngine::doesTableExist(Session &session,
336
 
                                           const TableIdentifier &identifier,
 
329
                                           TableIdentifier &identifier,
337
330
                                           bool include_temporary_tables)
338
331
{
339
332
  if (include_temporary_tables)
343
336
  }
344
337
 
345
338
  EngineVector::iterator iter=
346
 
    std::find_if(vector_of_engines.begin(), vector_of_engines.end(),
347
 
                 StorageEngineDoesTableExist(session, identifier));
 
339
    find_if(vector_of_engines.begin(), vector_of_engines.end(),
 
340
            StorageEngineDoesTableExist(session, identifier));
348
341
 
349
342
  if (iter == vector_of_engines.end())
350
343
  {
354
347
  return true;
355
348
}
356
349
 
357
 
bool plugin::StorageEngine::doDoesTableExist(Session&, const drizzled::TableIdentifier&)
 
350
bool plugin::StorageEngine::doDoesTableExist(Session&, TableIdentifier&)
358
351
{
359
 
  std::cerr << " Engine was called for doDoesTableExist() and does not implement it: " << this->getName() << "\n";
 
352
  cerr << " Engine was called for doDoesTableExist() and does not implement it: " << this->getName() << "\n";
360
353
  assert(0);
361
354
  return false;
362
355
}
367
360
  or any dropped tables that need to be removed from disk
368
361
*/
369
362
int StorageEngine::getTableDefinition(Session& session,
370
 
                                      const TableIdentifier &identifier,
371
 
                                      message::table::shared_ptr &table_message,
 
363
                                      TableIdentifier &identifier,
 
364
                                      message::Table &table_message,
372
365
                                      bool include_temporary_tables)
373
366
{
374
367
  int err= ENOENT;
375
368
 
376
369
  if (include_temporary_tables)
377
370
  {
378
 
    Table *table= session.find_temporary_table(identifier);
379
 
    if (table)
380
 
    {
381
 
      table_message.reset(new message::Table(*table->getShare()->getTableProto()));
 
371
    if (session.doGetTableDefinition(identifier, table_message) == EEXIST)
382
372
      return EEXIST;
383
 
    }
384
 
  }
385
 
 
386
 
  drizzled::message::table::shared_ptr table_ptr;
387
 
  if ((table_ptr= drizzled::message::Cache::singleton().find(identifier)))
388
 
  {
389
 
    table_message= table_ptr;
390
 
  }
391
 
 
392
 
  message::Table message;
 
373
  }
 
374
 
393
375
  EngineVector::iterator iter=
394
 
    std::find_if(vector_of_engines.begin(), vector_of_engines.end(),
395
 
                 StorageEngineGetTableDefinition(session, identifier, message, err));
 
376
    find_if(vector_of_engines.begin(), vector_of_engines.end(),
 
377
            StorageEngineGetTableDefinition(session, identifier, table_message, err));
396
378
 
397
379
  if (iter == vector_of_engines.end())
398
380
  {
399
381
    return ENOENT;
400
382
  }
401
 
  table_message.reset(new message::Table(message));
402
 
 
403
 
 drizzled::message::Cache::singleton().insert(identifier, table_message);
404
383
 
405
384
  return err;
406
385
}
439
418
   returns ENOENT if the file doesn't exists.
440
419
*/
441
420
int StorageEngine::dropTable(Session& session,
442
 
                             const TableIdentifier &identifier)
 
421
                             TableIdentifier &identifier)
443
422
{
444
423
  int error= 0;
445
424
  int error_proto;
446
 
  message::table::shared_ptr src_proto;
 
425
  message::Table src_proto;
447
426
  StorageEngine *engine;
448
427
 
449
428
  error_proto= StorageEngine::getTableDefinition(session, identifier, src_proto);
450
429
 
451
430
  if (error_proto == ER_CORRUPT_TABLE_DEFINITION)
452
431
  {
453
 
    std::string error_message;
454
 
    identifier.getSQLPath(error_message);
 
432
    string error_message;
455
433
 
 
434
    error_message.append(identifier.getSQLPath());
456
435
    error_message.append(" : ");
457
 
    error_message.append(src_proto->InitializationErrorString());
 
436
    error_message.append(src_proto.InitializationErrorString());
458
437
 
459
438
    my_error(ER_CORRUPT_TABLE_DEFINITION, MYF(0), error_message.c_str());
460
439
 
461
440
    return ER_CORRUPT_TABLE_DEFINITION;
462
441
  }
463
442
 
464
 
  if (src_proto)
465
 
    engine= StorageEngine::findByName(session, src_proto->engine().name());
466
 
  else
467
 
    engine= StorageEngine::findByName(session, "");
 
443
  engine= StorageEngine::findByName(session, src_proto.engine().name());
468
444
 
469
445
  if (not engine)
470
446
  {
471
 
    std::string error_message;
472
 
    identifier.getSQLPath(error_message);
473
 
    my_error(ER_CORRUPT_TABLE_DEFINITION, MYF(0), error_message.c_str());
 
447
    my_error(ER_CORRUPT_TABLE_DEFINITION, MYF(0), identifier.getSQLPath().c_str());
474
448
 
475
449
    return ER_CORRUPT_TABLE_DEFINITION;
476
450
  }
485
459
 
486
460
int StorageEngine::dropTable(Session& session,
487
461
                             StorageEngine &engine,
488
 
                             const TableIdentifier &identifier)
 
462
                             TableIdentifier &identifier)
489
463
{
490
464
  int error;
491
465
 
492
466
  engine.setTransactionReadWrite(session);
493
 
  
494
 
  if (unlikely(plugin::EventObserver::beforeDropTable(session, identifier)))
495
 
  {
496
 
    error= ER_EVENT_OBSERVER_PLUGIN;
497
 
  }
498
 
  else
499
 
  {
500
 
    error= engine.doDropTable(session, identifier);
501
 
    if (unlikely(plugin::EventObserver::afterDropTable(session, identifier, error)))
502
 
    {
503
 
      error= ER_EVENT_OBSERVER_PLUGIN;
504
 
    }
505
 
  }
506
 
 
507
 
  drizzled::message::Cache::singleton().erase(identifier);
 
467
  error= engine.doDropTable(session, identifier);
508
468
 
509
469
  return error;
510
470
}
519
479
   1  error
520
480
*/
521
481
int StorageEngine::createTable(Session &session,
522
 
                               const TableIdentifier &identifier,
 
482
                               TableIdentifier &identifier,
 
483
                               bool update_create_info,
523
484
                               message::Table& table_message)
524
485
{
525
486
  int error= 1;
526
 
  TableShare share(identifier);
527
 
  table::Shell table(share);
 
487
  Table table;
 
488
  TableShare share(identifier.getSchemaName().c_str(), 0, identifier.getTableName().c_str(), identifier.getPath().c_str());
528
489
  message::Table tmp_proto;
529
490
 
530
 
  if (share.parse_table_proto(session, table_message) || share.open_table_from_share(&session, identifier, "", 0, 0, table))
 
491
  if (parse_table_proto(session, table_message, &share) || open_table_from_share(&session, &share, "", 0, 0, &table))
531
492
  { 
532
493
    // @note Error occured, we should probably do a little more here.
533
494
  }
534
495
  else
535
496
  {
 
497
    if (update_create_info)
 
498
      table.updateCreateInfo(&table_message);
 
499
 
536
500
    /* Check for legal operations against the Engine using the proto (if used) */
537
501
    if (table_message.type() == message::Table::TEMPORARY &&
538
502
        share.storage_engine->check_flag(HTON_BIT_TEMPORARY_NOT_SUPPORTED) == true)
556
520
 
557
521
    if (error)
558
522
    {
559
 
      std::string path;
560
 
      identifier.getSQLPath(path);
561
 
      my_error(ER_CANT_CREATE_TABLE, MYF(ME_BELL+ME_WAITTANG), path.c_str(), error);
 
523
      my_error(ER_CANT_CREATE_TABLE, MYF(ME_BELL+ME_WAITTANG), identifier.getSQLPath().c_str(), error);
562
524
    }
563
525
 
564
 
    table.delete_table();
 
526
    table.closefrm(false);
565
527
  }
566
528
 
 
529
  share.free_table_share();
567
530
  return(error != 0);
568
531
}
569
532
 
570
 
Cursor *StorageEngine::getCursor(Table &arg)
 
533
Cursor *StorageEngine::getCursor(TableShare &share, memory::Root *alloc)
571
534
{
572
 
  return create(arg);
 
535
  return create(share, alloc);
573
536
}
574
537
 
 
538
class AddTableName : 
 
539
  public unary_function<StorageEngine *, void>
 
540
{
 
541
  CachedDirectory &directory;
 
542
  SchemaIdentifier &identifier;
 
543
  TableNameList &set_of_names;
 
544
 
 
545
public:
 
546
 
 
547
  AddTableName(CachedDirectory &directory_arg, SchemaIdentifier &identifier_arg, set<string>& of_names) :
 
548
    directory(directory_arg),
 
549
    identifier(identifier_arg),
 
550
    set_of_names(of_names)
 
551
  {
 
552
  }
 
553
 
 
554
  result_type operator() (argument_type engine)
 
555
  {
 
556
    engine->doGetTableNames(directory, identifier, set_of_names);
 
557
  }
 
558
};
 
559
 
575
560
class AddTableIdentifier : 
576
 
  public std::unary_function<StorageEngine *, void>
 
561
  public unary_function<StorageEngine *, void>
577
562
{
578
563
  CachedDirectory &directory;
579
 
  const SchemaIdentifier &identifier;
580
 
  TableIdentifier::vector &set_of_identifiers;
 
564
  SchemaIdentifier &identifier;
 
565
  TableIdentifiers &set_of_identifiers;
581
566
 
582
567
public:
583
568
 
584
 
  AddTableIdentifier(CachedDirectory &directory_arg, const SchemaIdentifier &identifier_arg, TableIdentifier::vector &of_names) :
 
569
  AddTableIdentifier(CachedDirectory &directory_arg, SchemaIdentifier &identifier_arg, TableIdentifiers &of_names) :
585
570
    directory(directory_arg),
586
571
    identifier(identifier_arg),
587
572
    set_of_identifiers(of_names)
595
580
};
596
581
 
597
582
 
598
 
void StorageEngine::getIdentifiers(Session &session, const SchemaIdentifier &schema_identifier, TableIdentifier::vector &set_of_identifiers)
599
 
{
600
 
  static SchemaIdentifier INFORMATION_SCHEMA_IDENTIFIER("information_schema");
601
 
  static SchemaIdentifier DATA_DICTIONARY_IDENTIFIER("data_dictionary");
602
 
 
603
 
  CachedDirectory directory(schema_identifier.getPath(), set_of_table_definition_ext);
604
 
 
605
 
  if (schema_identifier == INFORMATION_SCHEMA_IDENTIFIER)
606
 
  { }
607
 
  else if (schema_identifier == DATA_DICTIONARY_IDENTIFIER)
608
 
  { }
609
 
  else
610
 
  {
611
 
    if (directory.fail())
612
 
    {
613
 
      errno= directory.getError();
614
 
      if (errno == ENOENT)
615
 
      {
616
 
        std::string path;
617
 
        schema_identifier.getSQLPath(path);
618
 
        my_error(ER_BAD_DB_ERROR, MYF(ME_BELL+ME_WAITTANG), path.c_str());
619
 
      }
620
 
      else
621
 
      {
622
 
        my_error(ER_CANT_READ_DIR, MYF(ME_BELL+ME_WAITTANG), directory.getPath(), errno);
623
 
      }
624
 
 
625
 
      return;
626
 
    }
627
 
  }
628
 
 
629
 
  std::for_each(vector_of_engines.begin(), vector_of_engines.end(),
630
 
                AddTableIdentifier(directory, schema_identifier, set_of_identifiers));
 
583
static SchemaIdentifier INFORMATION_SCHEMA_IDENTIFIER("information_schema");
 
584
static SchemaIdentifier DATA_DICTIONARY_IDENTIFIER("data_dictionary");
 
585
 
 
586
void StorageEngine::getTableNames(Session &session, SchemaIdentifier &schema_identifier, TableNameList &set_of_names)
 
587
{
 
588
  CachedDirectory directory(schema_identifier.getPath(), set_of_table_definition_ext);
 
589
 
 
590
  if (schema_identifier == INFORMATION_SCHEMA_IDENTIFIER)
 
591
  { }
 
592
  else if (schema_identifier == DATA_DICTIONARY_IDENTIFIER)
 
593
  { }
 
594
  else
 
595
  {
 
596
    if (directory.fail())
 
597
    {
 
598
      errno= directory.getError();
 
599
      if (errno == ENOENT)
 
600
        my_error(ER_BAD_DB_ERROR, MYF(ME_BELL+ME_WAITTANG), schema_identifier.getSQLPath().c_str());
 
601
      else
 
602
        my_error(ER_CANT_READ_DIR, MYF(ME_BELL+ME_WAITTANG), directory.getPath(), errno);
 
603
      return;
 
604
    }
 
605
  }
 
606
 
 
607
  for_each(vector_of_engines.begin(), vector_of_engines.end(),
 
608
           AddTableName(directory, schema_identifier, set_of_names));
 
609
 
 
610
  session.doGetTableNames(directory, schema_identifier, set_of_names);
 
611
}
 
612
 
 
613
void StorageEngine::getTableIdentifiers(Session &session, SchemaIdentifier &schema_identifier, TableIdentifiers &set_of_identifiers)
 
614
{
 
615
  CachedDirectory directory(schema_identifier.getPath(), set_of_table_definition_ext);
 
616
 
 
617
  if (schema_identifier == INFORMATION_SCHEMA_IDENTIFIER)
 
618
  { }
 
619
  else if (schema_identifier == DATA_DICTIONARY_IDENTIFIER)
 
620
  { }
 
621
  else
 
622
  {
 
623
    if (directory.fail())
 
624
    {
 
625
      errno= directory.getError();
 
626
      if (errno == ENOENT)
 
627
        my_error(ER_BAD_DB_ERROR, MYF(ME_BELL+ME_WAITTANG), schema_identifier.getSQLPath().c_str());
 
628
      else
 
629
        my_error(ER_CANT_READ_DIR, MYF(ME_BELL+ME_WAITTANG), directory.getPath(), errno);
 
630
      return;
 
631
    }
 
632
  }
 
633
 
 
634
  for_each(vector_of_engines.begin(), vector_of_engines.end(),
 
635
           AddTableIdentifier(directory, schema_identifier, set_of_identifiers));
631
636
 
632
637
  session.doGetTableIdentifiers(directory, schema_identifier, set_of_identifiers);
633
638
}
634
639
 
635
 
class DropTable: public std::unary_function<TableIdentifier&, bool>
636
 
{
637
 
  Session &session;
638
 
  StorageEngine *engine;
639
 
 
640
 
public:
641
 
 
642
 
  DropTable(Session &session_arg, StorageEngine *engine_arg) :
643
 
    session(session_arg),
644
 
    engine(engine_arg)
645
 
  { }
646
 
 
647
 
  result_type operator() (argument_type identifier)
648
 
  {
649
 
    return engine->doDropTable(session, identifier) == 0;
650
 
  } 
651
 
};
652
 
 
653
640
/* This will later be converted to TableIdentifiers */
654
 
class DropTables: public std::unary_function<StorageEngine *, void>
 
641
class DropTables: public unary_function<StorageEngine *, void>
655
642
{
656
643
  Session &session;
657
 
  TableIdentifier::vector &table_identifiers;
 
644
  TableIdentifierList &table_identifiers;
658
645
 
659
646
public:
660
647
 
661
 
  DropTables(Session &session_arg, TableIdentifier::vector &table_identifiers_arg) :
 
648
  DropTables(Session &session_arg, TableIdentifierList &table_identifiers_arg) :
662
649
    session(session_arg),
663
650
    table_identifiers(table_identifiers_arg)
664
651
  { }
665
652
 
666
653
  result_type operator() (argument_type engine)
667
654
  {
668
 
    // True returning from DropTable means the table has been successfully
669
 
    // deleted, so it should be removed from the list of tables to drop
670
 
    table_identifiers.erase(std::remove_if(table_identifiers.begin(),
671
 
                                           table_identifiers.end(),
672
 
                                           DropTable(session, engine)),
673
 
                            table_identifiers.end());
 
655
    for (TableIdentifierList::iterator iter= table_identifiers.begin();
 
656
         iter != table_identifiers.end();
 
657
         iter++)
 
658
    {
 
659
      int error= engine->doDropTable(session, const_cast<TableIdentifier&>(*iter));
 
660
 
 
661
      // On a return of zero we know we found and deleted the table. So we
 
662
      // remove it from our search.
 
663
      if (not error)
 
664
        table_identifiers.erase(iter);
 
665
    }
674
666
  }
675
667
};
676
668
 
682
674
void StorageEngine::removeLostTemporaryTables(Session &session, const char *directory)
683
675
{
684
676
  CachedDirectory dir(directory, set_of_table_definition_ext);
685
 
  TableIdentifier::vector table_identifiers;
 
677
  TableIdentifierList table_identifiers;
686
678
 
687
679
  if (dir.fail())
688
680
  {
698
690
       fileIter != files.end(); fileIter++)
699
691
  {
700
692
    size_t length;
701
 
    std::string path;
 
693
    string path;
702
694
    CachedDirectory::Entry *entry= *fileIter;
703
695
 
704
696
    /* We remove the file extension. */
716
708
    }
717
709
  }
718
710
 
719
 
  std::for_each(vector_of_engines.begin(), vector_of_engines.end(),
720
 
                DropTables(session, table_identifiers));
721
 
 
 
711
  for_each(vector_of_engines.begin(), vector_of_engines.end(),
 
712
           DropTables(session, table_identifiers));
 
713
  
722
714
  /*
723
715
    Now we just clean up anything that might left over.
724
716
 
725
717
    We rescan because some of what might have been there should
726
718
    now be all nice and cleaned up.
727
719
  */
728
 
  std::set<std::string> all_exts= set_of_table_definition_ext;
 
720
  set<string> all_exts= set_of_table_definition_ext;
729
721
 
730
722
  for (EngineVector::iterator iter= vector_of_engines.begin();
731
723
       iter != vector_of_engines.end() ; iter++)
740
732
  for (CachedDirectory::Entries::iterator fileIter= files.begin();
741
733
       fileIter != files.end(); fileIter++)
742
734
  {
743
 
    std::string path;
 
735
    string path;
744
736
    CachedDirectory::Entry *entry= *fileIter;
745
737
 
746
738
    path+= directory;
758
750
  @note
759
751
    In case of delete table it's only safe to use the following parts of
760
752
    the 'table' structure:
761
 
    - table->getShare()->path
 
753
    - table->s->path
762
754
    - table->alias
763
755
*/
764
756
void StorageEngine::print_error(int error, myf errflag, Table &table)
795
787
    {
796
788
      const char *err_msg= ER(ER_DUP_ENTRY_WITH_KEY_NAME);
797
789
 
 
790
      if (key_nr == 0 &&
 
791
          (table->key_info[0].key_part[0].field->flags &
 
792
           AUTO_INCREMENT_FLAG)
 
793
          && (current_session)->lex->sql_command == SQLCOM_ALTER_TABLE)
 
794
      {
 
795
        err_msg= ER(ER_DUP_ENTRY_AUTOINCREMENT_CASE);
 
796
      }
 
797
 
798
798
      print_keydup_error(key_nr, err_msg, *table);
799
 
 
800
799
      return;
801
800
    }
802
801
    textno=ER_DUP_KEY;
823
822
        str.length(max_length-4);
824
823
        str.append(STRING_WITH_LEN("..."));
825
824
      }
826
 
      my_error(ER_FOREIGN_DUPLICATE_KEY, MYF(0), table->getShare()->getTableName(),
 
825
      my_error(ER_FOREIGN_DUPLICATE_KEY, MYF(0), table->s->table_name.str,
827
826
        str.c_ptr(), key_nr+1);
828
827
      return;
829
828
    }
901
900
    break;
902
901
  case HA_ERR_NO_SUCH_TABLE:
903
902
    assert(table);
904
 
    my_error(ER_NO_SUCH_TABLE, MYF(0), table->getShare()->getSchemaName(),
905
 
             table->getShare()->getTableName());
 
903
    my_error(ER_NO_SUCH_TABLE, MYF(0), table->s->getSchemaName(),
 
904
             table->s->table_name.str);
906
905
    return;
907
906
  case HA_ERR_RBR_LOGGING_FAILED:
908
907
    textno= ER_BINLOG_ROW_LOGGING_FAILED;
958
957
      return;
959
958
    }
960
959
  }
961
 
  my_error(textno, errflag, table->getShare()->getTableName(), error);
 
960
  my_error(textno, errflag, table->s->table_name.str, error);
962
961
}
963
962
 
964
963
 
1005
1004
}
1006
1005
 
1007
1006
 
1008
 
int StorageEngine::deleteDefinitionFromPath(const TableIdentifier &identifier)
 
1007
int StorageEngine::deleteDefinitionFromPath(TableIdentifier &identifier)
1009
1008
{
1010
 
  std::string path(identifier.getPath());
 
1009
  string path(identifier.getPath());
1011
1010
 
1012
1011
  path.append(DEFAULT_DEFINITION_FILE_EXT);
1013
1012
 
1014
1013
  return internal::my_delete(path.c_str(), MYF(0));
1015
1014
}
1016
1015
 
1017
 
int StorageEngine::renameDefinitionFromPath(const TableIdentifier &dest, const TableIdentifier &src)
 
1016
int StorageEngine::renameDefinitionFromPath(TableIdentifier &dest, TableIdentifier &src)
1018
1017
{
1019
1018
  message::Table table_message;
1020
 
  std::string src_path(src.getPath());
1021
 
  std::string dest_path(dest.getPath());
 
1019
  string src_path(src.getPath());
 
1020
  string dest_path(dest.getPath());
1022
1021
 
1023
1022
  src_path.append(DEFAULT_DEFINITION_FILE_EXT);
1024
1023
  dest_path.append(DEFAULT_DEFINITION_FILE_EXT);
1043
1042
  return error;
1044
1043
}
1045
1044
 
1046
 
int StorageEngine::writeDefinitionFromPath(const TableIdentifier &identifier, message::Table &table_message)
 
1045
int StorageEngine::writeDefinitionFromPath(TableIdentifier &identifier, message::Table &table_message)
1047
1046
{
1048
1047
  char definition_file_tmp[FN_REFLEN];
1049
 
  std::string file_name(identifier.getPath());
 
1048
  string file_name(identifier.getPath());
1050
1049
 
1051
1050
  file_name.append(DEFAULT_DEFINITION_FILE_EXT);
1052
1051
 
1063
1062
  google::protobuf::io::ZeroCopyOutputStream* output=
1064
1063
    new google::protobuf::io::FileOutputStream(fd);
1065
1064
 
1066
 
  bool success;
1067
 
 
1068
 
  try
1069
 
  {
1070
 
    success= table_message.SerializeToZeroCopyStream(output);
1071
 
  }
1072
 
  catch (...)
1073
 
  {
1074
 
    success= false;
1075
 
  }
1076
 
 
1077
 
  if (not success)
 
1065
  if (not table_message.SerializeToZeroCopyStream(output))
1078
1066
  {
1079
1067
    my_error(ER_CORRUPT_TABLE_DEFINITION, MYF(0),
1080
1068
             table_message.InitializationErrorString().c_str());
1116
1104
  return 0;
1117
1105
}
1118
1106
 
1119
 
class CanCreateTable: public std::unary_function<StorageEngine *, bool>
 
1107
class CanCreateTable: public unary_function<StorageEngine *, bool>
1120
1108
{
1121
 
  const TableIdentifier &identifier;
 
1109
  TableIdentifier &identifier;
1122
1110
 
1123
1111
public:
1124
 
  CanCreateTable(const TableIdentifier &identifier_arg) :
 
1112
  CanCreateTable(TableIdentifier &identifier_arg) :
1125
1113
    identifier(identifier_arg)
1126
1114
  { }
1127
1115
 
1135
1123
/**
1136
1124
  @note on success table can be created.
1137
1125
*/
1138
 
bool StorageEngine::canCreateTable(const TableIdentifier &identifier)
 
1126
bool StorageEngine::canCreateTable(drizzled::TableIdentifier &identifier)
1139
1127
{
1140
1128
  EngineVector::iterator iter=
1141
 
    std::find_if(vector_of_engines.begin(), vector_of_engines.end(),
1142
 
                 CanCreateTable(identifier));
 
1129
    find_if(vector_of_engines.begin(), vector_of_engines.end(),
 
1130
            CanCreateTable(identifier));
1143
1131
 
1144
1132
  if (iter == vector_of_engines.end())
1145
1133
  {
1151
1139
 
1152
1140
bool StorageEngine::readTableFile(const std::string &path, message::Table &table_message)
1153
1141
{
1154
 
  std::fstream input(path.c_str(), std::ios::in | std::ios::binary);
 
1142
  fstream input(path.c_str(), ios::in | ios::binary);
1155
1143
 
1156
1144
  if (input.good())
1157
1145
  {
1158
 
    try {
1159
 
      if (table_message.ParseFromIstream(&input))
1160
 
      {
1161
 
        return true;
1162
 
      }
1163
 
    }
1164
 
    catch (...)
 
1146
    if (table_message.ParseFromIstream(&input))
1165
1147
    {
1166
 
      my_error(ER_CORRUPT_TABLE_DEFINITION, MYF(0),
1167
 
               table_message.InitializationErrorString().empty() ? "": table_message.InitializationErrorString().c_str());
 
1148
      return true;
1168
1149
    }
 
1150
 
 
1151
    my_error(ER_CORRUPT_TABLE_DEFINITION, MYF(0),
 
1152
             table_message.InitializationErrorString().c_str());
1169
1153
  }
1170
1154
  else
1171
1155
  {