← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to drizzled/plugin/storage_engine.cc

  • Committer: Marisa Plumb
  • Date: 2010-12-04 02:38:29 UTC
  • mto: This revision was merged to the branch mainline in revision 1984.
  • Revision ID: marisa.plumb@gmail.com-20101204023829-2khzxh30wxi256db
updates to a few sql docs 

Show diffs side-by-side

added added

removed removed

Lines of Context:
drizzled/plugin/storage_engine.cc
1
1
/* -*- mode: c++; c-basic-offset: 2; indent-tabs-mode: nil; -*-
2
2
 *  vim:expandtab:shiftwidth=2:tabstop=2:smarttab:
3
3
 *
4
 
 *  Copyright (C) 2008 Sun Microsystems, Inc.
 
4
 *  Copyright (C) 2008 Sun Microsystems
5
5
 *
6
6
 *  This program is free software; you can redistribute it and/or modify
7
7
 *  it under the terms of the GNU General Public License as published by
17
17
 *  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
18
18
 */
19
19
 
20
 
#include <config.h>
 
20
#include "config.h"
21
21
 
22
22
#include <fcntl.h>
23
23
#include <unistd.h>
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/cached_directory.h>
 
35
#include "drizzled/cached_directory.h"
36
36
 
37
37
#include <drizzled/definitions.h>
38
38
#include <drizzled/base.h>
43
43
#include <drizzled/gettext.h>
44
44
#include <drizzled/unireg.h>
45
45
#include <drizzled/data_home.h>
46
 
#include <drizzled/errmsg_print.h>
47
 
#include <drizzled/xid.h>
48
 
#include <drizzled/sql_table.h>
49
 
#include <drizzled/global_charset_info.h>
50
 
#include <drizzled/charset.h>
51
 
#include <drizzled/internal/my_sys.h>
 
46
#include "drizzled/errmsg_print.h"
 
47
#include "drizzled/xid.h"
 
48
#include "drizzled/sql_table.h"
 
49
#include "drizzled/global_charset_info.h"
 
50
#include "drizzled/charset.h"
 
51
#include "drizzled/internal/my_sys.h"
 
52
#include "drizzled/db.h"
52
53
 
53
54
#include <drizzled/table_proto.h>
54
55
#include <drizzled/plugin/event_observer.h>
55
 
#include <drizzled/internal_error_handler.h>
56
56
 
57
57
#include <drizzled/table/shell.h>
58
58
 
59
 
#include <drizzled/message/cache.h>
 
59
#include "drizzled/message/cache.h"
60
60
 
61
61
#include <boost/algorithm/string/compare.hpp>
62
62
 
63
63
static bool shutdown_has_begun= false; // Once we put in the container for the vector/etc for engines this will go away.
64
64
 
 
65
using namespace std;
 
66
 
65
67
namespace drizzled
66
68
{
67
69
 
82
84
  return vector_of_schema_engines;
83
85
}
84
86
 
85
 
StorageEngine::StorageEngine(const std::string name_arg,
86
 
                             const std::bitset<HTON_BIT_SIZE> &flags_arg) :
 
87
StorageEngine::StorageEngine(const string name_arg,
 
88
                             const bitset<HTON_BIT_SIZE> &flags_arg) :
87
89
  Plugin(name_arg, "StorageEngine"),
88
90
  MonitoredInTransaction(), /* This gives the storage engine a "slot" or ID */
89
91
  flags(flags_arg)
101
103
}
102
104
 
103
105
 
104
 
int StorageEngine::renameTable(Session &session, const identifier::Table &from, const identifier::Table &to)
 
106
int StorageEngine::renameTable(Session &session, const TableIdentifier &from, const TableIdentifier &to)
105
107
{
106
108
  int error;
107
109
  setTransactionReadWrite(session);
137
139
  @retval
138
140
    !0  Error
139
141
*/
140
 
int StorageEngine::doDropTable(Session&, const identifier::Table &identifier)
 
142
int StorageEngine::doDropTable(Session&, const TableIdentifier &identifier)
141
143
                               
142
144
{
143
145
  int error= 0;
192
194
}
193
195
 
194
196
class FindEngineByName
195
 
  : public std::unary_function<StorageEngine *, bool>
 
197
  : public unary_function<StorageEngine *, bool>
196
198
{
197
 
  const std::string &predicate;
 
199
  const string &predicate;
198
200
 
199
201
public:
200
 
  explicit FindEngineByName(const std::string &target_arg) :
 
202
  explicit FindEngineByName(const string &target_arg) :
201
203
    predicate(target_arg)
202
204
  {
203
205
  }
208
210
  }
209
211
};
210
212
 
211
 
StorageEngine *StorageEngine::findByName(const std::string &predicate)
 
213
StorageEngine *StorageEngine::findByName(const string &predicate)
212
214
{
213
 
  EngineVector::iterator iter= std::find_if(vector_of_engines.begin(),
214
 
                                            vector_of_engines.end(),
215
 
                                            FindEngineByName(predicate));
 
215
  EngineVector::iterator iter= find_if(vector_of_engines.begin(),
 
216
                                       vector_of_engines.end(),
 
217
                                       FindEngineByName(predicate));
216
218
  if (iter != vector_of_engines.end())
217
219
  {
218
220
    StorageEngine *engine= *iter;
223
225
  return NULL;
224
226
}
225
227
 
226
 
StorageEngine *StorageEngine::findByName(Session& session, const std::string &predicate)
 
228
StorageEngine *StorageEngine::findByName(Session& session, const string &predicate)
227
229
{
228
230
  if (boost::iequals(predicate, DEFAULT_STRING))
229
231
    return session.getDefaultStorageEngine();
230
232
 
231
 
  EngineVector::iterator iter= std::find_if(vector_of_engines.begin(),
232
 
                                            vector_of_engines.end(),
233
 
                                            FindEngineByName(predicate));
 
233
  EngineVector::iterator iter= find_if(vector_of_engines.begin(),
 
234
                                       vector_of_engines.end(),
 
235
                                       FindEngineByName(predicate));
234
236
  if (iter != vector_of_engines.end())
235
237
  {
236
238
    StorageEngine *engine= *iter;
241
243
  return NULL;
242
244
}
243
245
 
244
 
class StorageEngineCloseConnection : public std::unary_function<StorageEngine *, void>
 
246
class StorageEngineCloseConnection : public unary_function<StorageEngine *, void>
245
247
{
246
248
  Session *session;
247
249
public:
263
265
*/
264
266
void StorageEngine::closeConnection(Session* session)
265
267
{
266
 
  std::for_each(vector_of_engines.begin(), vector_of_engines.end(),
267
 
                StorageEngineCloseConnection(session));
 
268
  for_each(vector_of_engines.begin(), vector_of_engines.end(),
 
269
           StorageEngineCloseConnection(session));
268
270
}
269
271
 
270
272
bool StorageEngine::flushLogs(StorageEngine *engine)
271
273
{
272
274
  if (engine == NULL)
273
275
  {
274
 
    if (std::find_if(vector_of_engines.begin(), vector_of_engines.end(),
275
 
                     std::mem_fun(&StorageEngine::flush_logs))
 
276
    if (find_if(vector_of_engines.begin(), vector_of_engines.end(),
 
277
                mem_fun(&StorageEngine::flush_logs))
276
278
        != vector_of_engines.begin())
277
279
      return true;
278
280
  }
284
286
  return false;
285
287
}
286
288
 
287
 
class StorageEngineGetTableDefinition: public std::unary_function<StorageEngine *,bool>
 
289
class StorageEngineGetTableDefinition: public unary_function<StorageEngine *,bool>
288
290
{
289
291
  Session& session;
290
 
  const identifier::Table &identifier;
 
292
  const TableIdentifier &identifier;
291
293
  message::Table &table_message;
292
 
  drizzled::error_t &err;
 
294
  int &err;
293
295
 
294
296
public:
295
297
  StorageEngineGetTableDefinition(Session& session_arg,
296
 
                                  const identifier::Table &identifier_arg,
 
298
                                  const TableIdentifier &identifier_arg,
297
299
                                  message::Table &table_message_arg,
298
 
                                  drizzled::error_t &err_arg) :
 
300
                                  int &err_arg) :
299
301
    session(session_arg), 
300
302
    identifier(identifier_arg),
301
303
    table_message(table_message_arg), 
306
308
    int ret= engine->doGetTableDefinition(session, identifier, table_message);
307
309
 
308
310
    if (ret != ENOENT)
309
 
      err= static_cast<drizzled::error_t>(ret);
 
311
      err= ret;
310
312
 
311
 
    return err == static_cast<drizzled::error_t>(EEXIST) or err != static_cast<drizzled::error_t>(ENOENT);
 
313
    return err == EEXIST || err != ENOENT;
312
314
  }
313
315
};
314
316
 
315
 
class StorageEngineDoesTableExist: public std::unary_function<StorageEngine *, bool>
 
317
class StorageEngineDoesTableExist: public unary_function<StorageEngine *, bool>
316
318
{
317
319
  Session& session;
318
 
  const identifier::Table &identifier;
 
320
  const TableIdentifier &identifier;
319
321
 
320
322
public:
321
 
  StorageEngineDoesTableExist(Session& session_arg, const identifier::Table &identifier_arg) :
 
323
  StorageEngineDoesTableExist(Session& session_arg, const TableIdentifier &identifier_arg) :
322
324
    session(session_arg), 
323
325
    identifier(identifier_arg) 
324
326
  { }
333
335
  Utility method which hides some of the details of getTableDefinition()
334
336
*/
335
337
bool plugin::StorageEngine::doesTableExist(Session &session,
336
 
                                           const identifier::Table &identifier,
 
338
                                           const TableIdentifier &identifier,
337
339
                                           bool include_temporary_tables)
338
340
{
339
341
  if (include_temporary_tables)
343
345
  }
344
346
 
345
347
  EngineVector::iterator iter=
346
 
    std::find_if(vector_of_engines.begin(), vector_of_engines.end(),
347
 
                 StorageEngineDoesTableExist(session, identifier));
 
348
    find_if(vector_of_engines.begin(), vector_of_engines.end(),
 
349
            StorageEngineDoesTableExist(session, identifier));
348
350
 
349
351
  if (iter == vector_of_engines.end())
350
352
  {
354
356
  return true;
355
357
}
356
358
 
357
 
bool plugin::StorageEngine::doDoesTableExist(Session&, const drizzled::identifier::Table&)
 
359
bool plugin::StorageEngine::doDoesTableExist(Session&, const drizzled::TableIdentifier&)
358
360
{
359
 
  std::cerr << " Engine was called for doDoesTableExist() and does not implement it: " << this->getName() << "\n";
 
361
  cerr << " Engine was called for doDoesTableExist() and does not implement it: " << this->getName() << "\n";
360
362
  assert(0);
361
363
  return false;
362
364
}
363
365
 
364
 
message::table::shared_ptr StorageEngine::getTableMessage(Session& session,
365
 
                                                          identifier::Table::const_reference identifier,
366
 
                                                          bool include_temporary_tables)
 
366
/**
 
367
  Call this function in order to give the Cursor the possiblity
 
368
  to ask engine if there are any new tables that should be written to disk
 
369
  or any dropped tables that need to be removed from disk
 
370
*/
 
371
int StorageEngine::getTableDefinition(Session& session,
 
372
                                      const TableIdentifier &identifier,
 
373
                                      message::table::shared_ptr &table_message,
 
374
                                      bool include_temporary_tables)
367
375
{
368
 
  drizzled::error_t error;
369
 
  error= static_cast<drizzled::error_t>(ENOENT);
 
376
  int err= ENOENT;
370
377
 
371
378
  if (include_temporary_tables)
372
379
  {
373
380
    Table *table= session.find_temporary_table(identifier);
374
381
    if (table)
375
382
    {
376
 
      return message::table::shared_ptr(new message::Table(*table->getShare()->getTableMessage()));
 
383
      table_message.reset(new message::Table(*table->getShare()->getTableProto()));
 
384
      return EEXIST;
377
385
    }
378
386
  }
379
387
 
380
388
  drizzled::message::table::shared_ptr table_ptr;
381
389
  if ((table_ptr= drizzled::message::Cache::singleton().find(identifier)))
382
390
  {
383
 
    (void)table_ptr;
 
391
    table_message= table_ptr;
384
392
  }
385
393
 
386
394
  message::Table message;
387
395
  EngineVector::iterator iter=
388
 
    std::find_if(vector_of_engines.begin(), vector_of_engines.end(),
389
 
                 StorageEngineGetTableDefinition(session, identifier, message, error));
 
396
    find_if(vector_of_engines.begin(), vector_of_engines.end(),
 
397
            StorageEngineGetTableDefinition(session, identifier, message, err));
390
398
 
391
399
  if (iter == vector_of_engines.end())
392
400
  {
393
 
    return message::table::shared_ptr();
 
401
    return ENOENT;
394
402
  }
395
 
  message::table::shared_ptr table_message(new message::Table(message));
396
 
 
397
 
  drizzled::message::Cache::singleton().insert(identifier, table_message);
398
 
 
399
 
  return table_message;
 
403
  table_message.reset(new message::Table(message));
 
404
 
 
405
 drizzled::message::Cache::singleton().insert(identifier, table_message);
 
406
 
 
407
  return err;
400
408
}
401
409
 
402
410
/**
409
417
{
410
418
public:
411
419
  Ha_delete_table_error_handler() : Internal_error_handler() {}
412
 
  virtual bool handle_error(drizzled::error_t sql_errno,
 
420
  virtual bool handle_error(uint32_t sql_errno,
413
421
                            const char *message,
414
422
                            DRIZZLE_ERROR::enum_warning_level level,
415
423
                            Session *session);
419
427
 
420
428
bool
421
429
Ha_delete_table_error_handler::
422
 
handle_error(drizzled::error_t ,
 
430
handle_error(uint32_t ,
423
431
             const char *message,
424
432
             DRIZZLE_ERROR::enum_warning_level ,
425
433
             Session *)
429
437
  return true;
430
438
}
431
439
 
432
 
class DropTableByIdentifier: public std::unary_function<EngineVector::value_type, bool>
433
 
{
434
 
  Session::reference session;
435
 
  identifier::Table::const_reference identifier;
436
 
  drizzled::error_t &error;
437
 
 
438
 
public:
439
 
 
440
 
  DropTableByIdentifier(Session::reference session_arg,
441
 
                        identifier::Table::const_reference identifier_arg,
442
 
                        drizzled::error_t &error_arg) :
443
 
    session(session_arg),
444
 
    identifier(identifier_arg),
445
 
    error(error_arg)
446
 
  { }
447
 
 
448
 
  result_type operator() (argument_type engine)
449
 
  {
450
 
    if (not engine->doDoesTableExist(session, identifier))
451
 
      return false;
452
 
 
453
 
    int local_error= engine->doDropTable(session, identifier);
454
 
 
455
 
 
456
 
    if (not local_error)
457
 
      return true;
458
 
 
459
 
    switch (local_error)
460
 
    {
461
 
    case HA_ERR_NO_SUCH_TABLE:
462
 
    case ENOENT:
463
 
      error= static_cast<drizzled::error_t>(HA_ERR_NO_SUCH_TABLE);
464
 
      return false;
465
 
 
466
 
    default:
467
 
      error= static_cast<drizzled::error_t>(local_error);
468
 
      return true;
469
 
    }
470
 
  } 
471
 
};
472
 
 
473
 
 
474
 
bool StorageEngine::dropTable(Session::reference session,
475
 
                              identifier::Table::const_reference identifier,
476
 
                              drizzled::error_t &error)
477
 
{
478
 
  error= EE_OK;
479
 
 
480
 
  EngineVector::const_iterator iter= std::find_if(vector_of_engines.begin(), vector_of_engines.end(),
481
 
                                                  DropTableByIdentifier(session, identifier, error));
482
 
 
483
 
  if (error)
484
 
  {
485
 
    return false;
486
 
  }
487
 
  else if (iter == vector_of_engines.end())
488
 
  {
489
 
    error= ER_BAD_TABLE_ERROR;
490
 
    return false;
491
 
  }
492
 
 
493
 
  drizzled::message::Cache::singleton().erase(identifier);
494
 
 
495
 
  return true;
496
 
}
497
 
 
498
 
bool StorageEngine::dropTable(Session& session,
499
 
                              const identifier::Table &identifier)
500
 
{
501
 
  drizzled::error_t error;
502
 
 
503
 
  if (not dropTable(session, identifier, error))
504
 
  {
505
 
    return false;
506
 
  }
507
 
 
508
 
  return true;
509
 
}
510
 
 
511
 
bool StorageEngine::dropTable(Session::reference session,
512
 
                              StorageEngine &engine,
513
 
                              identifier::Table::const_reference identifier,
514
 
                              drizzled::error_t &error)
515
 
{
516
 
  error= EE_OK;
 
440
/**
 
441
   returns ENOENT if the file doesn't exists.
 
442
*/
 
443
int StorageEngine::dropTable(Session& session,
 
444
                             const TableIdentifier &identifier)
 
445
{
 
446
  int error= 0;
 
447
  int error_proto;
 
448
  message::table::shared_ptr src_proto;
 
449
  StorageEngine *engine;
 
450
 
 
451
  error_proto= StorageEngine::getTableDefinition(session, identifier, src_proto);
 
452
 
 
453
  if (error_proto == ER_CORRUPT_TABLE_DEFINITION)
 
454
  {
 
455
    string error_message;
 
456
 
 
457
    error_message.append(const_cast<TableIdentifier &>(identifier).getSQLPath());
 
458
    error_message.append(" : ");
 
459
    error_message.append(src_proto->InitializationErrorString());
 
460
 
 
461
    my_error(ER_CORRUPT_TABLE_DEFINITION, MYF(0), error_message.c_str());
 
462
 
 
463
    return ER_CORRUPT_TABLE_DEFINITION;
 
464
  }
 
465
 
 
466
  if (src_proto)
 
467
    engine= StorageEngine::findByName(session, src_proto->engine().name());
 
468
  else
 
469
    engine= StorageEngine::findByName(session, "");
 
470
 
 
471
  if (not engine)
 
472
  {
 
473
    my_error(ER_CORRUPT_TABLE_DEFINITION, MYF(0), const_cast<TableIdentifier &>(identifier).getSQLPath().c_str());
 
474
 
 
475
    return ER_CORRUPT_TABLE_DEFINITION;
 
476
  }
 
477
 
 
478
  error= StorageEngine::dropTable(session, *engine, identifier);
 
479
 
 
480
  if (error_proto && error == 0)
 
481
    return 0;
 
482
 
 
483
  return error;
 
484
}
 
485
 
 
486
int StorageEngine::dropTable(Session& session,
 
487
                             StorageEngine &engine,
 
488
                             const TableIdentifier &identifier)
 
489
{
 
490
  int error;
 
491
 
517
492
  engine.setTransactionReadWrite(session);
518
 
 
519
 
  assert(identifier.isTmp());
520
493
  
521
494
  if (unlikely(plugin::EventObserver::beforeDropTable(session, identifier)))
522
495
  {
524
497
  }
525
498
  else
526
499
  {
527
 
    error= static_cast<drizzled::error_t>(engine.doDropTable(session, identifier));
528
 
 
 
500
    error= engine.doDropTable(session, identifier);
529
501
    if (unlikely(plugin::EventObserver::afterDropTable(session, identifier, error)))
530
502
    {
531
503
      error= ER_EVENT_OBSERVER_PLUGIN;
534
506
 
535
507
  drizzled::message::Cache::singleton().erase(identifier);
536
508
 
537
 
  if (error)
538
 
  {
539
 
    return false;
540
 
  }
541
 
 
542
 
  return true;
 
509
  return error;
543
510
}
544
511
 
545
512
 
551
518
  @retval
552
519
   1  error
553
520
*/
554
 
bool StorageEngine::createTable(Session &session,
555
 
                                const identifier::Table &identifier,
556
 
                                message::Table& table_message)
 
521
int StorageEngine::createTable(Session &session,
 
522
                               const TableIdentifier &identifier,
 
523
                               message::Table& table_message)
557
524
{
558
 
  drizzled::error_t error= EE_OK;
559
 
 
 
525
  int error= 1;
560
526
  TableShare share(identifier);
561
527
  table::Shell table(share);
562
528
  message::Table tmp_proto;
564
530
  if (share.parse_table_proto(session, table_message) || share.open_table_from_share(&session, identifier, "", 0, 0, table))
565
531
  { 
566
532
    // @note Error occured, we should probably do a little more here.
567
 
    // ER_CORRUPT_TABLE_DEFINITION,ER_CORRUPT_TABLE_DEFINITION_ENUM 
568
 
    
569
 
    my_error(ER_CORRUPT_TABLE_DEFINITION_UNKNOWN, identifier);
570
 
 
571
 
    return false;
572
533
  }
573
534
  else
574
535
  {
587
548
    {
588
549
      share.storage_engine->setTransactionReadWrite(session);
589
550
 
590
 
      error= static_cast<drizzled::error_t>(share.storage_engine->doCreateTable(session,
591
 
                                                                                table,
592
 
                                                                                identifier,
593
 
                                                                                table_message));
 
551
      error= share.storage_engine->doCreateTable(session,
 
552
                                                 table,
 
553
                                                 identifier,
 
554
                                                 table_message);
594
555
    }
595
556
 
596
 
    if (error == ER_TABLE_PERMISSION_DENIED)
597
 
    {
598
 
      my_error(ER_TABLE_PERMISSION_DENIED, identifier);
599
 
    }
600
 
    else if (error)
601
 
    {
602
 
      std::string path;
603
 
      identifier.getSQLPath(path);
604
 
      my_error(ER_CANT_CREATE_TABLE, MYF(ME_BELL+ME_WAITTANG), path.c_str(), error);
 
557
    if (error)
 
558
    {
 
559
      my_error(ER_CANT_CREATE_TABLE, MYF(ME_BELL+ME_WAITTANG), const_cast<TableIdentifier &>(identifier).getSQLPath().c_str(), error);
605
560
    }
606
561
 
607
562
    table.delete_table();
608
563
  }
609
564
 
610
 
  return(error == EE_OK);
 
565
  return(error != 0);
611
566
}
612
567
 
613
568
Cursor *StorageEngine::getCursor(Table &arg)
616
571
}
617
572
 
618
573
class AddTableIdentifier : 
619
 
  public std::unary_function<StorageEngine *, void>
 
574
  public unary_function<StorageEngine *, void>
620
575
{
621
576
  CachedDirectory &directory;
622
 
  const identifier::Schema &identifier;
623
 
  identifier::Table::vector &set_of_identifiers;
 
577
  const SchemaIdentifier &identifier;
 
578
  TableIdentifiers &set_of_identifiers;
624
579
 
625
580
public:
626
581
 
627
 
  AddTableIdentifier(CachedDirectory &directory_arg, const identifier::Schema &identifier_arg, identifier::Table::vector &of_names) :
 
582
  AddTableIdentifier(CachedDirectory &directory_arg, const SchemaIdentifier &identifier_arg, TableIdentifiers &of_names) :
628
583
    directory(directory_arg),
629
584
    identifier(identifier_arg),
630
585
    set_of_identifiers(of_names)
638
593
};
639
594
 
640
595
 
641
 
void StorageEngine::getIdentifiers(Session &session, const identifier::Schema &schema_identifier, identifier::Table::vector &set_of_identifiers)
 
596
void StorageEngine::getIdentifiers(Session &session, const SchemaIdentifier &schema_identifier, TableIdentifiers &set_of_identifiers)
642
597
{
 
598
  static SchemaIdentifier INFORMATION_SCHEMA_IDENTIFIER("information_schema");
 
599
  static SchemaIdentifier DATA_DICTIONARY_IDENTIFIER("data_dictionary");
 
600
 
643
601
  CachedDirectory directory(schema_identifier.getPath(), set_of_table_definition_ext);
644
602
 
645
603
  if (schema_identifier == INFORMATION_SCHEMA_IDENTIFIER)
652
610
    {
653
611
      errno= directory.getError();
654
612
      if (errno == ENOENT)
655
 
      {
656
 
        std::string path;
657
 
        schema_identifier.getSQLPath(path);
658
 
        my_error(ER_BAD_DB_ERROR, MYF(ME_BELL+ME_WAITTANG), path.c_str());
659
 
      }
 
613
        my_error(ER_BAD_DB_ERROR, MYF(ME_BELL+ME_WAITTANG), const_cast<SchemaIdentifier &>(schema_identifier).getSQLPath().c_str());
660
614
      else
661
 
      {
662
615
        my_error(ER_CANT_READ_DIR, MYF(ME_BELL+ME_WAITTANG), directory.getPath(), errno);
663
 
      }
664
 
 
665
616
      return;
666
617
    }
667
618
  }
668
619
 
669
 
  std::for_each(vector_of_engines.begin(), vector_of_engines.end(),
670
 
                AddTableIdentifier(directory, schema_identifier, set_of_identifiers));
 
620
  for_each(vector_of_engines.begin(), vector_of_engines.end(),
 
621
           AddTableIdentifier(directory, schema_identifier, set_of_identifiers));
671
622
 
672
623
  session.doGetTableIdentifiers(directory, schema_identifier, set_of_identifiers);
673
624
}
674
625
 
675
 
class DropTable: public std::unary_function<identifier::Table&, bool>
 
626
class DropTable: public unary_function<TableIdentifier&, bool>
676
627
{
677
628
  Session &session;
678
629
  StorageEngine *engine;
690
641
  } 
691
642
};
692
643
 
693
 
/* This will later be converted to identifier::Tables */
694
 
class DropTables: public std::unary_function<StorageEngine *, void>
 
644
/* This will later be converted to TableIdentifiers */
 
645
class DropTables: public unary_function<StorageEngine *, void>
695
646
{
696
647
  Session &session;
697
 
  identifier::Table::vector &table_identifiers;
 
648
  TableIdentifiers &table_identifiers;
698
649
 
699
650
public:
700
651
 
701
 
  DropTables(Session &session_arg, identifier::Table::vector &table_identifiers_arg) :
 
652
  DropTables(Session &session_arg, TableIdentifiers &table_identifiers_arg) :
702
653
    session(session_arg),
703
654
    table_identifiers(table_identifiers_arg)
704
655
  { }
707
658
  {
708
659
    // True returning from DropTable means the table has been successfully
709
660
    // deleted, so it should be removed from the list of tables to drop
710
 
    table_identifiers.erase(std::remove_if(table_identifiers.begin(),
711
 
                                           table_identifiers.end(),
712
 
                                           DropTable(session, engine)),
 
661
    table_identifiers.erase(remove_if(table_identifiers.begin(),
 
662
                                      table_identifiers.end(),
 
663
                                      DropTable(session, engine)),
713
664
                            table_identifiers.end());
714
665
  }
715
666
};
722
673
void StorageEngine::removeLostTemporaryTables(Session &session, const char *directory)
723
674
{
724
675
  CachedDirectory dir(directory, set_of_table_definition_ext);
725
 
  identifier::Table::vector table_identifiers;
 
676
  TableIdentifiers table_identifiers;
726
677
 
727
678
  if (dir.fail())
728
679
  {
738
689
       fileIter != files.end(); fileIter++)
739
690
  {
740
691
    size_t length;
741
 
    std::string path;
 
692
    string path;
742
693
    CachedDirectory::Entry *entry= *fileIter;
743
694
 
744
695
    /* We remove the file extension. */
751
702
    message::Table definition;
752
703
    if (StorageEngine::readTableFile(path, definition))
753
704
    {
754
 
      identifier::Table identifier(definition.schema(), definition.name(), path);
 
705
      TableIdentifier identifier(definition.schema(), definition.name(), path);
755
706
      table_identifiers.push_back(identifier);
756
707
    }
757
708
  }
758
709
 
759
 
  std::for_each(vector_of_engines.begin(), vector_of_engines.end(),
760
 
                DropTables(session, table_identifiers));
761
 
 
 
710
  for_each(vector_of_engines.begin(), vector_of_engines.end(),
 
711
           DropTables(session, table_identifiers));
 
712
  
762
713
  /*
763
714
    Now we just clean up anything that might left over.
764
715
 
765
716
    We rescan because some of what might have been there should
766
717
    now be all nice and cleaned up.
767
718
  */
768
 
  std::set<std::string> all_exts= set_of_table_definition_ext;
 
719
  set<string> all_exts= set_of_table_definition_ext;
769
720
 
770
721
  for (EngineVector::iterator iter= vector_of_engines.begin();
771
722
       iter != vector_of_engines.end() ; iter++)
780
731
  for (CachedDirectory::Entries::iterator fileIter= files.begin();
781
732
       fileIter != files.end(); fileIter++)
782
733
  {
783
 
    std::string path;
 
734
    string path;
784
735
    CachedDirectory::Entry *entry= *fileIter;
785
736
 
786
737
    path+= directory;
801
752
    - table->getShare()->path
802
753
    - table->alias
803
754
*/
804
 
void StorageEngine::print_error(int error, myf errflag, const Table &table) const
805
 
{
806
 
  drizzled::error_t textno= ER_GET_ERRNO;
 
755
void StorageEngine::print_error(int error, myf errflag, Table &table)
 
756
{
 
757
  print_error(error, errflag, &table);
 
758
}
 
759
 
 
760
void StorageEngine::print_error(int error, myf errflag, Table *table)
 
761
{
 
762
  int textno= ER_GET_ERRNO;
807
763
  switch (error) {
808
764
  case EACCES:
809
765
    textno=ER_OPEN_AS_READONLY;
824
780
    break;
825
781
  case HA_ERR_FOUND_DUPP_KEY:
826
782
  {
827
 
    uint32_t key_nr= table.get_dup_key(error);
 
783
    assert(table);
 
784
    uint32_t key_nr= table->get_dup_key(error);
828
785
    if ((int) key_nr >= 0)
829
786
    {
830
787
      const char *err_msg= ER(ER_DUP_ENTRY_WITH_KEY_NAME);
831
788
 
832
 
      print_keydup_error(key_nr, err_msg, table);
 
789
      print_keydup_error(key_nr, err_msg, *table);
833
790
 
834
791
      return;
835
792
    }
838
795
  }
839
796
  case HA_ERR_FOREIGN_DUPLICATE_KEY:
840
797
  {
841
 
    uint32_t key_nr= table.get_dup_key(error);
 
798
    assert(table);
 
799
    uint32_t key_nr= table->get_dup_key(error);
842
800
    if ((int) key_nr >= 0)
843
801
    {
844
802
      uint32_t max_length;
848
806
      String str(key,sizeof(key),system_charset_info);
849
807
 
850
808
      /* Table is opened and defined at this point */
851
 
      key_unpack(&str, &table,(uint32_t) key_nr);
 
809
      key_unpack(&str,table,(uint32_t) key_nr);
852
810
      max_length= (DRIZZLE_ERRMSG_SIZE-
853
811
                   (uint32_t) strlen(ER(ER_FOREIGN_DUPLICATE_KEY)));
854
812
      if (str.length() >= max_length)
856
814
        str.length(max_length-4);
857
815
        str.append(STRING_WITH_LEN("..."));
858
816
      }
859
 
      my_error(ER_FOREIGN_DUPLICATE_KEY, MYF(0), table.getShare()->getTableName(),
 
817
      my_error(ER_FOREIGN_DUPLICATE_KEY, MYF(0), table->getShare()->getTableName(),
860
818
        str.c_ptr(), key_nr+1);
861
819
      return;
862
820
    }
879
837
    textno=ER_CRASHED_ON_USAGE;
880
838
    break;
881
839
  case HA_ERR_NOT_A_TABLE:
882
 
    textno= static_cast<drizzled::error_t>(error);
 
840
    textno= error;
883
841
    break;
884
842
  case HA_ERR_CRASHED_ON_REPAIR:
885
843
    textno=ER_CRASHED_ON_REPAIR;
933
891
    textno=ER_TABLE_DEF_CHANGED;
934
892
    break;
935
893
  case HA_ERR_NO_SUCH_TABLE:
936
 
    {
937
 
      identifier::Table identifier(table.getShare()->getSchemaName(), table.getShare()->getTableName());
938
 
      my_error(ER_TABLE_UNKNOWN, identifier);
939
 
      return;
940
 
    }
 
894
    assert(table);
 
895
    my_error(ER_NO_SUCH_TABLE, MYF(0), table->getShare()->getSchemaName(),
 
896
             table->getShare()->getTableName());
 
897
    return;
941
898
  case HA_ERR_RBR_LOGGING_FAILED:
942
899
    textno= ER_BINLOG_ROW_LOGGING_FAILED;
943
900
    break;
944
901
  case HA_ERR_DROP_INDEX_FK:
945
902
  {
 
903
    assert(table);
946
904
    const char *ptr= "???";
947
 
    uint32_t key_nr= table.get_dup_key(error);
 
905
    uint32_t key_nr= table->get_dup_key(error);
948
906
    if ((int) key_nr >= 0)
949
 
      ptr= table.key_info[key_nr].name;
 
907
      ptr= table->key_info[key_nr].name;
950
908
    my_error(ER_DROP_INDEX_FK, MYF(0), ptr);
951
909
    return;
952
910
  }
991
949
      return;
992
950
    }
993
951
  }
994
 
 
995
 
  my_error(textno, errflag, table.getShare()->getTableName(), error);
 
952
  my_error(textno, errflag, table->getShare()->getTableName(), error);
996
953
}
997
954
 
998
955
 
1005
962
  @return
1006
963
    Returns true if this is a temporary error
1007
964
*/
1008
 
bool StorageEngine::get_error_message(int , String* ) const
 
965
bool StorageEngine::get_error_message(int , String* )
1009
966
{
1010
967
  return false;
1011
968
}
1012
969
 
1013
970
 
1014
 
void StorageEngine::print_keydup_error(uint32_t key_nr, const char *msg, const Table &table) const
 
971
void StorageEngine::print_keydup_error(uint32_t key_nr, const char *msg, Table &table)
1015
972
{
1016
973
  /* Write the duplicated key in the error message */
1017
974
  char key[MAX_KEY_LENGTH];
1039
996
}
1040
997
 
1041
998
 
1042
 
int StorageEngine::deleteDefinitionFromPath(const identifier::Table &identifier)
 
999
int StorageEngine::deleteDefinitionFromPath(const TableIdentifier &identifier)
1043
1000
{
1044
 
  std::string path(identifier.getPath());
 
1001
  string path(identifier.getPath());
1045
1002
 
1046
1003
  path.append(DEFAULT_DEFINITION_FILE_EXT);
1047
1004
 
1048
1005
  return internal::my_delete(path.c_str(), MYF(0));
1049
1006
}
1050
1007
 
1051
 
int StorageEngine::renameDefinitionFromPath(const identifier::Table &dest, const identifier::Table &src)
 
1008
int StorageEngine::renameDefinitionFromPath(const TableIdentifier &dest, const TableIdentifier &src)
1052
1009
{
1053
1010
  message::Table table_message;
1054
 
  std::string src_path(src.getPath());
1055
 
  std::string dest_path(dest.getPath());
 
1011
  string src_path(src.getPath());
 
1012
  string dest_path(dest.getPath());
1056
1013
 
1057
1014
  src_path.append(DEFAULT_DEFINITION_FILE_EXT);
1058
1015
  dest_path.append(DEFAULT_DEFINITION_FILE_EXT);
1077
1034
  return error;
1078
1035
}
1079
1036
 
1080
 
int StorageEngine::writeDefinitionFromPath(const identifier::Table &identifier, message::Table &table_message)
 
1037
int StorageEngine::writeDefinitionFromPath(const TableIdentifier &identifier, message::Table &table_message)
1081
1038
{
1082
1039
  char definition_file_tmp[FN_REFLEN];
1083
 
  std::string file_name(identifier.getPath());
 
1040
  string file_name(identifier.getPath());
1084
1041
 
1085
1042
  file_name.append(DEFAULT_DEFINITION_FILE_EXT);
1086
1043
 
1099
1056
 
1100
1057
  bool success;
1101
1058
 
1102
 
  try
1103
 
  {
 
1059
  try {
1104
1060
    success= table_message.SerializeToZeroCopyStream(output);
1105
1061
  }
1106
1062
  catch (...)
1110
1066
 
1111
1067
  if (not success)
1112
1068
  {
1113
 
    std::string error_message;
1114
 
    identifier.getSQLPath(error_message);
1115
 
 
1116
1069
    my_error(ER_CORRUPT_TABLE_DEFINITION, MYF(0),
1117
 
             error_message.c_str(),
1118
1070
             table_message.InitializationErrorString().c_str());
1119
1071
    delete output;
1120
1072
 
1154
1106
  return 0;
1155
1107
}
1156
1108
 
1157
 
class CanCreateTable: public std::unary_function<StorageEngine *, bool>
 
1109
class CanCreateTable: public unary_function<StorageEngine *, bool>
1158
1110
{
1159
 
  const identifier::Table &identifier;
 
1111
  const TableIdentifier &identifier;
1160
1112
 
1161
1113
public:
1162
 
  CanCreateTable(const identifier::Table &identifier_arg) :
 
1114
  CanCreateTable(const TableIdentifier &identifier_arg) :
1163
1115
    identifier(identifier_arg)
1164
1116
  { }
1165
1117
 
1173
1125
/**
1174
1126
  @note on success table can be created.
1175
1127
*/
1176
 
bool StorageEngine::canCreateTable(const identifier::Table &identifier)
 
1128
bool StorageEngine::canCreateTable(const TableIdentifier &identifier)
1177
1129
{
1178
1130
  EngineVector::iterator iter=
1179
 
    std::find_if(vector_of_engines.begin(), vector_of_engines.end(),
1180
 
                 CanCreateTable(identifier));
 
1131
    find_if(vector_of_engines.begin(), vector_of_engines.end(),
 
1132
            CanCreateTable(identifier));
1181
1133
 
1182
1134
  if (iter == vector_of_engines.end())
1183
1135
  {
1189
1141
 
1190
1142
bool StorageEngine::readTableFile(const std::string &path, message::Table &table_message)
1191
1143
{
1192
 
  std::fstream input(path.c_str(), std::ios::in | std::ios::binary);
 
1144
  fstream input(path.c_str(), ios::in | ios::binary);
1193
1145
 
1194
1146
  if (input.good())
1195
1147
  {
1202
1154
    catch (...)
1203
1155
    {
1204
1156
      my_error(ER_CORRUPT_TABLE_DEFINITION, MYF(0),
1205
 
               table_message.name().empty() ? path.c_str() : table_message.name().c_str(),
1206
1157
               table_message.InitializationErrorString().empty() ? "": table_message.InitializationErrorString().c_str());
1207
1158
    }
1208
1159
  }
1214
1165
  return false;
1215
1166
}
1216
1167
 
1217
 
std::ostream& operator<<(std::ostream& output, const StorageEngine &engine)
1218
 
{
1219
 
  output << "StorageEngine:(";
1220
 
  output <<  engine.getName();
1221
 
  output << ")";
1222
1168
 
1223
 
  return output;
1224
 
}
1225
1169
 
1226
1170
} /* namespace plugin */
1227
1171
} /* namespace drizzled */