← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to drizzled/plugin/storage_engine.cc

pandora-build v0.72 - Moved remaining hard-coded tests into pandora-build
macros.
Add PANDORA_DRIZZLE_BUILD to run the extra checks that drizzle needs that 
plugins would also need to run so we can just use that macro in generated
external plugin builds.
Added support to register_plugins for external plugin building.
Renamed register_plugins.py to pandora-plugin.

Show diffs side-by-side

added added

removed removed

Lines of Context:
drizzled/plugin/storage_engine.cc
 
1
/* -*- mode: c++; c-basic-offset: 2; indent-tabs-mode: nil; -*-
 
2
 *  vim:expandtab:shiftwidth=2:tabstop=2:smarttab:
 
3
 *
 
4
 *  Copyright (C) 2008 Sun Microsystems
 
5
 *
 
6
 *  This program is free software; you can redistribute it and/or modify
 
7
 *  it under the terms of the GNU General Public License as published by
 
8
 *  the Free Software Foundation; version 2 of the License.
 
9
 *
 
10
 *  This program is distributed in the hope that it will be useful,
 
11
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 
12
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 
13
 *  GNU General Public License for more details.
 
14
 *
 
15
 *  You should have received a copy of the GNU General Public License
 
16
 *  along with this program; if not, write to the Free Software
 
17
 *  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
 
18
 */
 
19
 
 
20
#include <drizzled/server_includes.h>
 
21
 
 
22
#include CSTDINT_H
 
23
#include <string>
 
24
#include <vector>
 
25
#include <set>
 
26
#include <algorithm>
 
27
#include <functional>
 
28
 
 
29
#include <google/protobuf/io/zero_copy_stream.h>
 
30
#include <google/protobuf/io/zero_copy_stream_impl.h>
 
31
 
 
32
#include "mysys/my_dir.h"
 
33
#include "mysys/hash.h"
 
34
#include "mysys/cached_directory.h"
 
35
 
 
36
#include <drizzled/definitions.h>
 
37
#include <drizzled/base.h>
 
38
#include <drizzled/cursor.h>
 
39
#include <drizzled/plugin/storage_engine.h>
 
40
#include <drizzled/session.h>
 
41
#include <drizzled/error.h>
 
42
#include <drizzled/gettext.h>
 
43
#include <drizzled/name_map.h>
 
44
#include <drizzled/unireg.h>
 
45
#include <drizzled/data_home.h>
 
46
#include "drizzled/errmsg_print.h"
 
47
#include "drizzled/name_map.h"
 
48
#include "drizzled/xid.h"
 
49
 
 
50
#include <drizzled/table_proto.h>
 
51
 
 
52
using namespace std;
 
53
 
 
54
namespace drizzled
 
55
{
 
56
 
 
57
NameMap<plugin::StorageEngine *> all_engines;
 
58
static std::vector<plugin::StorageEngine *> vector_of_engines;
 
59
static std::vector<plugin::StorageEngine *> vector_of_transactional_engines;
 
60
static std::set<std::string> set_of_table_definition_ext;
 
61
 
 
62
plugin::StorageEngine::StorageEngine(const string name_arg,
 
63
                                     const bitset<HTON_BIT_SIZE> &flags_arg,
 
64
                                     size_t savepoint_offset_arg,
 
65
                                     bool support_2pc)
 
66
    : Plugin(name_arg, "StorageEngine"),
 
67
      two_phase_commit(support_2pc),
 
68
      enabled(true),
 
69
      flags(flags_arg),
 
70
      savepoint_offset(savepoint_alloc_size),
 
71
      orig_savepoint_offset(savepoint_offset_arg),
 
72
      slot(0)
 
73
{
 
74
  if (enabled)
 
75
  {
 
76
    savepoint_alloc_size+= orig_savepoint_offset;
 
77
    slot= total_ha++;
 
78
    if (two_phase_commit)
 
79
        total_ha_2pc++;
 
80
  }
 
81
  pthread_mutex_init(&proto_cache_mutex, NULL);
 
82
}
 
83
 
 
84
 
 
85
plugin::StorageEngine::~StorageEngine()
 
86
{
 
87
  savepoint_alloc_size-= orig_savepoint_offset;
 
88
  pthread_mutex_destroy(&proto_cache_mutex);
 
89
}
 
90
 
 
91
void plugin::StorageEngine::setTransactionReadWrite(Session& session)
 
92
{
 
93
  Ha_trx_info *ha_info= &session.ha_data[getSlot()].ha_info[0];
 
94
  /*
 
95
    When a storage engine method is called, the transaction must
 
96
    have been started, unless it's a DDL call, for which the
 
97
    storage engine starts the transaction internally, and commits
 
98
    it internally, without registering in the ha_list.
 
99
    Unfortunately here we can't know know for sure if the engine
 
100
    has registered the transaction or not, so we must check.
 
101
  */
 
102
  if (ha_info->is_started())
 
103
  {
 
104
    /*
 
105
     * table_share can be NULL in plugin::StorageEngine::dropTable().
 
106
     */
 
107
    ha_info->set_trx_read_write();
 
108
  }
 
109
}
 
110
 
 
111
 
 
112
 
 
113
int plugin::StorageEngine::doRenameTable(Session *,
 
114
                                         const char *from,
 
115
                                         const char *to)
 
116
{
 
117
  int error= 0;
 
118
  for (const char **ext= bas_ext(); *ext ; ext++)
 
119
  {
 
120
    if (rename_file_ext(from, to, *ext))
 
121
    {
 
122
      if ((error=my_errno) != ENOENT)
 
123
        break;
 
124
      error= 0;
 
125
    }
 
126
  }
 
127
  return error;
 
128
}
 
129
 
 
130
 
 
131
/**
 
132
  Delete all files with extension from bas_ext().
 
133
 
 
134
  @param name           Base name of table
 
135
 
 
136
  @note
 
137
    We assume that the Cursor may return more extensions than
 
138
    was actually used for the file.
 
139
 
 
140
  @retval
 
141
    0   If we successfully deleted at least one file from base_ext and
 
142
    didn't get any other errors than ENOENT
 
143
  @retval
 
144
    !0  Error
 
145
*/
 
146
int plugin::StorageEngine::doDropTable(Session&,
 
147
                                       const string table_path)
 
148
{
 
149
  int error= 0;
 
150
  int enoent_or_zero= ENOENT;                   // Error if no file was deleted
 
151
  char buff[FN_REFLEN];
 
152
 
 
153
  for (const char **ext= bas_ext(); *ext ; ext++)
 
154
  {
 
155
    fn_format(buff, table_path.c_str(), "", *ext,
 
156
              MY_UNPACK_FILENAME|MY_APPEND_EXT);
 
157
    if (my_delete_with_symlink(buff, MYF(0)))
 
158
    {
 
159
      if ((error= my_errno) != ENOENT)
 
160
        break;
 
161
    }
 
162
    else
 
163
      enoent_or_zero= 0;                        // No error for ENOENT
 
164
    error= enoent_or_zero;
 
165
  }
 
166
  return error;
 
167
}
 
168
 
 
169
const char *plugin::StorageEngine::checkLowercaseNames(const char *path,
 
170
                                                       char *tmp_path)
 
171
{
 
172
  if (flags.test(HTON_BIT_FILE_BASED))
 
173
    return path;
 
174
 
 
175
  /* Ensure that table Cursor get path in lower case */
 
176
  if (tmp_path != path)
 
177
    strcpy(tmp_path, path);
 
178
 
 
179
  /*
 
180
    we only should turn into lowercase database/table part
 
181
    so start the process after homedirectory
 
182
  */
 
183
  if (strstr(tmp_path, drizzle_tmpdir) == tmp_path)
 
184
    my_casedn_str(files_charset_info, tmp_path + strlen(drizzle_tmpdir));
 
185
  else
 
186
    my_casedn_str(files_charset_info, tmp_path + drizzle_data_home_len);
 
187
 
 
188
  return tmp_path;
 
189
}
 
190
 
 
191
 
 
192
bool plugin::StorageEngine::addPlugin(plugin::StorageEngine *engine)
 
193
{
 
194
  if (all_engines.add(engine))
 
195
  {
 
196
    errmsg_printf(ERRMSG_LVL_ERROR,
 
197
                  _("Couldn't add StorageEngine"));
 
198
    return true;
 
199
  }
 
200
 
 
201
  vector_of_engines.push_back(engine);
 
202
 
 
203
  if (engine->check_flag(HTON_BIT_DOES_TRANSACTIONS))
 
204
    vector_of_transactional_engines.push_back(engine);
 
205
 
 
206
  if (engine->getTableDefinitionFileExtension().length())
 
207
  {
 
208
    assert(engine->getTableDefinitionFileExtension().length() == DEFAULT_DEFINITION_FILE_EXT.length());
 
209
    set_of_table_definition_ext.insert(engine->getTableDefinitionFileExtension());
 
210
  }
 
211
 
 
212
  return false;
 
213
}
 
214
 
 
215
void plugin::StorageEngine::removePlugin(plugin::StorageEngine *engine)
 
216
{
 
217
  all_engines.remove(engine);
 
218
  vector_of_engines.clear();
 
219
  vector_of_transactional_engines.clear();
 
220
}
 
221
 
 
222
plugin::StorageEngine *plugin::StorageEngine::findByName(string find_str)
 
223
{
 
224
  transform(find_str.begin(), find_str.end(),
 
225
            find_str.begin(), ::tolower);
 
226
 
 
227
  plugin::StorageEngine *engine= all_engines.find(find_str);
 
228
 
 
229
  if (engine && engine->is_user_selectable())
 
230
    return engine;
 
231
 
 
232
  return NULL;
 
233
}
 
234
 
 
235
plugin::StorageEngine *plugin::StorageEngine::findByName(Session& session,
 
236
                                                         string find_str)
 
237
{
 
238
  
 
239
  transform(find_str.begin(), find_str.end(),
 
240
            find_str.begin(), ::tolower);
 
241
 
 
242
  if (find_str.compare("default") == 0)
 
243
    return session.getDefaultStorageEngine();
 
244
 
 
245
  plugin::StorageEngine *engine= all_engines.find(find_str);
 
246
 
 
247
  if (engine && engine->is_user_selectable())
 
248
    return engine;
 
249
 
 
250
  return NULL;
 
251
}
 
252
 
 
253
class StorageEngineCloseConnection
 
254
  : public unary_function<plugin::StorageEngine *, void>
 
255
{
 
256
  Session *session;
 
257
public:
 
258
  StorageEngineCloseConnection(Session *session_arg) : session(session_arg) {}
 
259
  /*
 
260
    there's no need to rollback here as all transactions must
 
261
    be rolled back already
 
262
  */
 
263
  inline result_type operator() (argument_type engine)
 
264
  {
 
265
    if (engine->is_enabled() && 
 
266
      session_get_ha_data(session, engine))
 
267
    engine->close_connection(session);
 
268
  }
 
269
};
 
270
 
 
271
/**
 
272
  @note
 
273
    don't bother to rollback here, it's done already
 
274
*/
 
275
void plugin::StorageEngine::closeConnection(Session* session)
 
276
{
 
277
  for_each(vector_of_engines.begin(), vector_of_engines.end(),
 
278
           StorageEngineCloseConnection(session));
 
279
}
 
280
 
 
281
void plugin::StorageEngine::dropDatabase(char* path)
 
282
{
 
283
  for_each(vector_of_engines.begin(), vector_of_engines.end(),
 
284
           bind2nd(mem_fun(&plugin::StorageEngine::drop_database),path));
 
285
}
 
286
 
 
287
int plugin::StorageEngine::commitOrRollbackByXID(XID *xid, bool commit)
 
288
{
 
289
  vector<int> results;
 
290
  
 
291
  if (commit)
 
292
    transform(all_engines.begin(), all_engines.end(), results.begin(),
 
293
              bind2nd(mem_fun(&plugin::StorageEngine::commit_by_xid),xid));
 
294
  else
 
295
    transform(all_engines.begin(), all_engines.end(), results.begin(),
 
296
              bind2nd(mem_fun(&plugin::StorageEngine::rollback_by_xid),xid));
 
297
 
 
298
  if (find_if(results.begin(), results.end(), bind2nd(equal_to<int>(),0))
 
299
         == results.end())
 
300
    return 1;
 
301
  return 0;
 
302
}
 
303
 
 
304
/**
 
305
  @details
 
306
  This function should be called when MySQL sends rows of a SELECT result set
 
307
  or the EOF mark to the client. It releases a possible adaptive hash index
 
308
  S-latch held by session in InnoDB and also releases a possible InnoDB query
 
309
  FIFO ticket to enter InnoDB. To save CPU time, InnoDB allows a session to
 
310
  keep them over several calls of the InnoDB Cursor interface when a join
 
311
  is executed. But when we let the control to pass to the client they have
 
312
  to be released because if the application program uses mysql_use_result(),
 
313
  it may deadlock on the S-latch if the application on another connection
 
314
  performs another SQL query. In MySQL-4.1 this is even more important because
 
315
  there a connection can have several SELECT queries open at the same time.
 
316
 
 
317
  @param session           the thread handle of the current connection
 
318
 
 
319
  @return
 
320
    always 0
 
321
*/
 
322
int plugin::StorageEngine::releaseTemporaryLatches(Session *session)
 
323
{
 
324
  for_each(vector_of_transactional_engines.begin(), vector_of_transactional_engines.end(),
 
325
           bind2nd(mem_fun(&plugin::StorageEngine::release_temporary_latches),session));
 
326
  return 0;
 
327
}
 
328
 
 
329
bool plugin::StorageEngine::flushLogs(plugin::StorageEngine *engine)
 
330
{
 
331
  if (engine == NULL)
 
332
  {
 
333
    if (find_if(all_engines.begin(), all_engines.end(),
 
334
            mem_fun(&plugin::StorageEngine::flush_logs))
 
335
          != all_engines.begin())
 
336
      return true;
 
337
  }
 
338
  else
 
339
  {
 
340
    if ((!engine->is_enabled()) ||
 
341
        (engine->flush_logs()))
 
342
      return true;
 
343
  }
 
344
  return false;
 
345
}
 
346
 
 
347
/**
 
348
  recover() step of xa.
 
349
 
 
350
  @note
 
351
    there are three modes of operation:
 
352
    - automatic recover after a crash
 
353
    in this case commit_list != 0, tc_heuristic_recover==0
 
354
    all xids from commit_list are committed, others are rolled back
 
355
    - manual (heuristic) recover
 
356
    in this case commit_list==0, tc_heuristic_recover != 0
 
357
    DBA has explicitly specified that all prepared transactions should
 
358
    be committed (or rolled back).
 
359
    - no recovery (MySQL did not detect a crash)
 
360
    in this case commit_list==0, tc_heuristic_recover == 0
 
361
    there should be no prepared transactions in this case.
 
362
*/
 
363
class XARecover : unary_function<plugin::StorageEngine *, void>
 
364
{
 
365
  int trans_len, found_foreign_xids, found_my_xids;
 
366
  bool result;
 
367
  XID *trans_list;
 
368
  HASH *commit_list;
 
369
  bool dry_run;
 
370
public:
 
371
  XARecover(XID *trans_list_arg, int trans_len_arg,
 
372
            HASH *commit_list_arg, bool dry_run_arg) 
 
373
    : trans_len(trans_len_arg), found_foreign_xids(0), found_my_xids(0),
 
374
      result(false),
 
375
      trans_list(trans_list_arg), commit_list(commit_list_arg),
 
376
      dry_run(dry_run_arg)
 
377
  {}
 
378
  
 
379
  int getForeignXIDs()
 
380
  {
 
381
    return found_foreign_xids; 
 
382
  }
 
383
 
 
384
  int getMyXIDs()
 
385
  {
 
386
    return found_my_xids; 
 
387
  }
 
388
 
 
389
  result_type operator() (argument_type engine)
 
390
  {
 
391
  
 
392
    int got;
 
393
  
 
394
    if (engine->is_enabled())
 
395
    {
 
396
      while ((got= engine->recover(trans_list, trans_len)) > 0 )
 
397
      {
 
398
        errmsg_printf(ERRMSG_LVL_INFO,
 
399
                      _("Found %d prepared transaction(s) in %s"),
 
400
                      got, engine->getName().c_str());
 
401
        for (int i=0; i < got; i ++)
 
402
        {
 
403
          my_xid x=trans_list[i].get_my_xid();
 
404
          if (!x) // not "mine" - that is generated by external TM
 
405
          {
 
406
            xid_cache_insert(trans_list+i, XA_PREPARED);
 
407
            found_foreign_xids++;
 
408
            continue;
 
409
          }
 
410
          if (dry_run)
 
411
          {
 
412
            found_my_xids++;
 
413
            continue;
 
414
          }
 
415
          // recovery mode
 
416
          if (commit_list ?
 
417
              hash_search(commit_list, (unsigned char *)&x, sizeof(x)) != 0 :
 
418
              tc_heuristic_recover == TC_HEURISTIC_RECOVER_COMMIT)
 
419
          {
 
420
            engine->commit_by_xid(trans_list+i);
 
421
          }
 
422
          else
 
423
          {
 
424
            engine->rollback_by_xid(trans_list+i);
 
425
          }
 
426
        }
 
427
        if (got < trans_len)
 
428
          break;
 
429
      }
 
430
    }
 
431
  }
 
432
};
 
433
 
 
434
int plugin::StorageEngine::recover(HASH *commit_list)
 
435
{
 
436
  XID *trans_list= NULL;
 
437
  int trans_len= 0;
 
438
 
 
439
  bool dry_run= (commit_list==0 && tc_heuristic_recover==0);
 
440
 
 
441
  /* commit_list and tc_heuristic_recover cannot be set both */
 
442
  assert(commit_list==0 || tc_heuristic_recover==0);
 
443
 
 
444
  /* if either is set, total_ha_2pc must be set too */
 
445
  if (total_ha_2pc <= 1)
 
446
    return 0;
 
447
 
 
448
 
 
449
#ifndef WILL_BE_DELETED_LATER
 
450
 
 
451
  /*
 
452
    for now, only InnoDB supports 2pc. It means we can always safely
 
453
    rollback all pending transactions, without risking inconsistent data
 
454
  */
 
455
 
 
456
  assert(total_ha_2pc == 2); // only InnoDB and binlog
 
457
  tc_heuristic_recover= TC_HEURISTIC_RECOVER_ROLLBACK; // forcing ROLLBACK
 
458
  dry_run=false;
 
459
#endif
 
460
  for (trans_len= MAX_XID_LIST_SIZE ;
 
461
       trans_list==0 && trans_len > MIN_XID_LIST_SIZE; trans_len/=2)
 
462
  {
 
463
    trans_list=(XID *)malloc(trans_len*sizeof(XID));
 
464
  }
 
465
  if (!trans_list)
 
466
  {
 
467
    errmsg_printf(ERRMSG_LVL_ERROR, ER(ER_OUTOFMEMORY), trans_len*sizeof(XID));
 
468
    return(1);
 
469
  }
 
470
 
 
471
  if (commit_list)
 
472
    errmsg_printf(ERRMSG_LVL_INFO, _("Starting crash recovery..."));
 
473
 
 
474
 
 
475
  XARecover recover_func(trans_list, trans_len, commit_list, dry_run);
 
476
  for_each(vector_of_transactional_engines.begin(), vector_of_transactional_engines.end(),
 
477
           recover_func);
 
478
  free(trans_list);
 
479
 
 
480
  if (recover_func.getForeignXIDs())
 
481
    errmsg_printf(ERRMSG_LVL_WARN,
 
482
                  _("Found %d prepared XA transactions"),
 
483
                  recover_func.getForeignXIDs());
 
484
  if (dry_run && recover_func.getMyXIDs())
 
485
  {
 
486
    errmsg_printf(ERRMSG_LVL_ERROR,
 
487
                  _("Found %d prepared transactions! It means that drizzled "
 
488
                    "was not shut down properly last time and critical "
 
489
                    "recovery information (last binlog or %s file) was "
 
490
                    "manually deleted after a crash. You have to start "
 
491
                    "drizzled with the --tc-heuristic-recover switch to "
 
492
                    "commit or rollback pending transactions."),
 
493
                    recover_func.getMyXIDs(), opt_tc_log_file);
 
494
    return(1);
 
495
  }
 
496
  if (commit_list)
 
497
    errmsg_printf(ERRMSG_LVL_INFO, _("Crash recovery finished."));
 
498
  return(0);
 
499
}
 
500
 
 
501
int plugin::StorageEngine::startConsistentSnapshot(Session *session)
 
502
{
 
503
  for_each(vector_of_engines.begin(), vector_of_engines.end(),
 
504
           bind2nd(mem_fun(&plugin::StorageEngine::start_consistent_snapshot),
 
505
                   session));
 
506
  return 0;
 
507
}
 
508
 
 
509
class StorageEngineGetTableDefinition: public unary_function<plugin::StorageEngine *,bool>
 
510
{
 
511
  Session& session;
 
512
  const char* path;
 
513
  const char *db;
 
514
  const char *table_name;
 
515
  const bool is_tmp;
 
516
  message::Table *table_proto;
 
517
  int *err;
 
518
 
 
519
public:
 
520
  StorageEngineGetTableDefinition(Session& session_arg,
 
521
                                  const char* path_arg,
 
522
                                  const char *db_arg,
 
523
                                  const char *table_name_arg,
 
524
                                  const bool is_tmp_arg,
 
525
                                  message::Table *table_proto_arg,
 
526
                                  int *err_arg) :
 
527
    session(session_arg), 
 
528
    path(path_arg), 
 
529
    db(db_arg),
 
530
    table_name(table_name_arg),
 
531
    is_tmp(is_tmp_arg),
 
532
    table_proto(table_proto_arg), 
 
533
    err(err_arg) {}
 
534
 
 
535
  result_type operator() (argument_type engine)
 
536
  {
 
537
    int ret= engine->doGetTableDefinition(session,
 
538
                                          path, 
 
539
                                          db,
 
540
                                          table_name,
 
541
                                          is_tmp,
 
542
                                          table_proto);
 
543
 
 
544
    if (ret != ENOENT)
 
545
      *err= ret;
 
546
 
 
547
    return *err == EEXIST;
 
548
  }
 
549
};
 
550
 
 
551
static int drizzle_read_table_proto(const char* path, message::Table* table)
 
552
{
 
553
  int fd= open(path, O_RDONLY);
 
554
 
 
555
  if (fd == -1)
 
556
    return errno;
 
557
 
 
558
  google::protobuf::io::ZeroCopyInputStream* input=
 
559
    new google::protobuf::io::FileInputStream(fd);
 
560
 
 
561
  if (table->ParseFromZeroCopyStream(input) == false)
 
562
  {
 
563
    delete input;
 
564
    close(fd);
 
565
    return -1;
 
566
  }
 
567
 
 
568
  delete input;
 
569
  close(fd);
 
570
  return 0;
 
571
}
 
572
 
 
573
/**
 
574
  Call this function in order to give the Cursor the possiblity
 
575
  to ask engine if there are any new tables that should be written to disk
 
576
  or any dropped tables that need to be removed from disk
 
577
*/
 
578
int plugin::StorageEngine::getTableDefinition(Session& session,
 
579
                                              const char* path,
 
580
                                              const char *,
 
581
                                              const char *,
 
582
                                              const bool,
 
583
                                              message::Table *table_proto)
 
584
{
 
585
  int err= ENOENT;
 
586
 
 
587
  vector<plugin::StorageEngine *>::iterator iter=
 
588
    find_if(vector_of_engines.begin(), vector_of_engines.end(),
 
589
            StorageEngineGetTableDefinition(session, path, NULL, NULL, true, table_proto, &err));
 
590
 
 
591
  if (iter == vector_of_engines.end())
 
592
  {
 
593
    string proto_path(path);
 
594
    string file_ext(".dfe");
 
595
    proto_path.append(file_ext);
 
596
 
 
597
    int error= access(proto_path.c_str(), F_OK);
 
598
 
 
599
    if (error == 0)
 
600
      err= EEXIST;
 
601
    else
 
602
      err= errno;
 
603
 
 
604
    if (table_proto)
 
605
    {
 
606
      int read_proto_err= drizzle_read_table_proto(proto_path.c_str(),
 
607
                                                   table_proto);
 
608
 
 
609
      if (read_proto_err)
 
610
        err= read_proto_err;
 
611
    }
 
612
  }
 
613
 
 
614
  return err;
 
615
}
 
616
 
 
617
/**
 
618
  An interceptor to hijack the text of the error message without
 
619
  setting an error in the thread. We need the text to present it
 
620
  in the form of a warning to the user.
 
621
*/
 
622
 
 
623
class Ha_delete_table_error_handler: public Internal_error_handler
 
624
{
 
625
public:
 
626
  Ha_delete_table_error_handler() : Internal_error_handler() {}
 
627
  virtual bool handle_error(uint32_t sql_errno,
 
628
                            const char *message,
 
629
                            DRIZZLE_ERROR::enum_warning_level level,
 
630
                            Session *session);
 
631
  char buff[DRIZZLE_ERRMSG_SIZE];
 
632
};
 
633
 
 
634
 
 
635
bool
 
636
Ha_delete_table_error_handler::
 
637
handle_error(uint32_t ,
 
638
             const char *message,
 
639
             DRIZZLE_ERROR::enum_warning_level ,
 
640
             Session *)
 
641
{
 
642
  /* Grab the error message */
 
643
  strncpy(buff, message, sizeof(buff)-1);
 
644
  return true;
 
645
}
 
646
 
 
647
 
 
648
/**
 
649
  This should return ENOENT if the file doesn't exists.
 
650
  The .frm file will be deleted only if we return 0 or ENOENT
 
651
*/
 
652
int plugin::StorageEngine::dropTable(Session& session, const char *path,
 
653
                                     const char *db, const char *alias,
 
654
                                     bool generate_warning)
 
655
{
 
656
  int error= 0;
 
657
  int error_proto;
 
658
  message::Table src_proto;
 
659
  plugin::StorageEngine* engine;
 
660
 
 
661
  error_proto= plugin::StorageEngine::getTableDefinition(session,
 
662
                                                         path, 
 
663
                                                         db,
 
664
                                                         alias,
 
665
                                                         true,
 
666
                                                         &src_proto);
 
667
 
 
668
  engine= plugin::StorageEngine::findByName(session,
 
669
                                            src_proto.engine().name());
 
670
 
 
671
  if (engine)
 
672
  {
 
673
    engine->setTransactionReadWrite(session);
 
674
    error= engine->doDropTable(session, path);
 
675
  }
 
676
 
 
677
  if (error != ENOENT)
 
678
  {
 
679
    if (error == 0)
 
680
    {
 
681
      if (engine && engine->check_flag(HTON_BIT_HAS_DATA_DICTIONARY))
 
682
        delete_table_proto_file(path);
 
683
      else
 
684
        error= delete_table_proto_file(path);
 
685
    }
 
686
  }
 
687
 
 
688
  if (error_proto && error == 0)
 
689
    return 0;
 
690
 
 
691
  if (error && generate_warning)
 
692
  {
 
693
    TableShare dummy_share;
 
694
    Table dummy_table;
 
695
    Cursor *file= NULL;
 
696
 
 
697
    if (engine)
 
698
    {
 
699
      if ((file= engine->create(dummy_share, session.mem_root)))
 
700
        file->init();
 
701
    }
 
702
    memset(&dummy_table, 0, sizeof(dummy_table));
 
703
    memset(&dummy_share, 0, sizeof(dummy_share));
 
704
    dummy_table.s= &dummy_share;
 
705
 
 
706
    /*
 
707
      Because file->print_error() use my_error() to generate the error message
 
708
      we use an internal error Cursor to intercept it and store the text
 
709
      in a temporary buffer. Later the message will be presented to user
 
710
      as a warning.
 
711
    */
 
712
    Ha_delete_table_error_handler ha_delete_table_error_handler;
 
713
 
 
714
    /* Fill up strucutures that print_error may need */
 
715
    dummy_share.path.str= (char*) path;
 
716
    dummy_share.path.length= strlen(path);
 
717
    dummy_share.db.str= (char*) db;
 
718
    dummy_share.db.length= strlen(db);
 
719
    dummy_share.table_name.str= (char*) alias;
 
720
    dummy_share.table_name.length= strlen(alias);
 
721
    dummy_table.alias= alias;
 
722
 
 
723
    if (file != NULL)
 
724
    {
 
725
      file->change_table_ptr(&dummy_table, &dummy_share);
 
726
 
 
727
      session.push_internal_handler(&ha_delete_table_error_handler);
 
728
      file->print_error(error, 0);
 
729
 
 
730
      session.pop_internal_handler();
 
731
    }
 
732
    else
 
733
      error= -1; /* General form of fail. maybe bad FRM */
 
734
 
 
735
    /*
 
736
      XXX: should we convert *all* errors to warnings here?
 
737
      What if the error is fatal?
 
738
    */
 
739
    push_warning(&session, DRIZZLE_ERROR::WARN_LEVEL_ERROR, error,
 
740
                 ha_delete_table_error_handler.buff);
 
741
  }
 
742
 
 
743
  return error;
 
744
}
 
745
 
 
746
/**
 
747
  Initiates table-file and calls appropriate database-creator.
 
748
 
 
749
  @retval
 
750
   0  ok
 
751
  @retval
 
752
   1  error
 
753
*/
 
754
int plugin::StorageEngine::createTable(Session& session, const char *path,
 
755
                                       const char *db, const char *table_name,
 
756
                                       HA_CREATE_INFO& create_info,
 
757
                                       bool update_create_info,
 
758
                                       drizzled::message::Table& table_proto, bool proto_used)
 
759
{
 
760
  int error= 1;
 
761
  Table table;
 
762
  TableShare share(db, 0, table_name, path);
 
763
  message::Table tmp_proto;
 
764
 
 
765
  if (proto_used)
 
766
  {
 
767
    if (parse_table_proto(session, table_proto, &share))
 
768
      goto err;
 
769
  }
 
770
  else
 
771
  {
 
772
    if (open_table_def(session, &share))
 
773
      goto err;
 
774
  }
 
775
 
 
776
  if (open_table_from_share(&session, &share, "", 0, (uint32_t) READ_ALL, 0,
 
777
                            &table))
 
778
    goto err;
 
779
 
 
780
  if (update_create_info)
 
781
    table.updateCreateInfo(&create_info, &table_proto);
 
782
 
 
783
  {
 
784
    char name_buff[FN_REFLEN];
 
785
    const char *table_name_arg;
 
786
 
 
787
    table_name_arg= share.storage_engine->checkLowercaseNames(path, name_buff);
 
788
 
 
789
    share.storage_engine->setTransactionReadWrite(session);
 
790
 
 
791
    error= share.storage_engine->doCreateTable(&session, table_name_arg, table,
 
792
                                               create_info, table_proto);
 
793
  }
 
794
 
 
795
  table.closefrm(false);
 
796
  if (error)
 
797
  {
 
798
    char name_buff[FN_REFLEN];
 
799
    sprintf(name_buff,"%s.%s",db,table_name);
 
800
    my_error(ER_CANT_CREATE_TABLE, MYF(ME_BELL+ME_WAITTANG), name_buff, error);
 
801
  }
 
802
err:
 
803
  share.free_table_share();
 
804
  return(error != 0);
 
805
}
 
806
 
 
807
Cursor *plugin::StorageEngine::getCursor(TableShare &share, MEM_ROOT *alloc)
 
808
{
 
809
  Cursor *file;
 
810
 
 
811
  assert(enabled);
 
812
 
 
813
  if ((file= create(share, alloc)))
 
814
    file->init();
 
815
  return file;
 
816
}
 
817
 
 
818
/**
 
819
  TODO -> Remove this to force all engines to implement their own file. Solves the "we only looked at dfe" problem.
 
820
*/
 
821
void plugin::StorageEngine::doGetTableNames(CachedDirectory &directory, string&, set<string>& set_of_names)
 
822
{
 
823
  CachedDirectory::Entries entries= directory.getEntries();
 
824
 
 
825
  for (CachedDirectory::Entries::iterator entry_iter= entries.begin(); 
 
826
       entry_iter != entries.end(); ++entry_iter)
 
827
  {
 
828
    CachedDirectory::Entry *entry= *entry_iter;
 
829
    string *filename= &entry->filename;
 
830
 
 
831
    assert(filename->size());
 
832
 
 
833
    const char *ext= strchr(filename->c_str(), '.');
 
834
 
 
835
    if (ext == NULL || my_strcasecmp(system_charset_info, ext, DEFAULT_DEFINITION_FILE_EXT.c_str()) ||
 
836
        is_prefix(filename->c_str(), TMP_FILE_PREFIX))
 
837
    { }
 
838
    else
 
839
    {
 
840
      char uname[NAME_LEN + 1];
 
841
      uint32_t file_name_len;
 
842
 
 
843
      file_name_len= filename_to_tablename(filename->c_str(), uname, sizeof(uname));
 
844
      // TODO: Remove need for memory copy here
 
845
      uname[file_name_len - sizeof(".dfe") + 1]= '\0'; // Subtract ending, place NULL 
 
846
      set_of_names.insert(uname);
 
847
    }
 
848
  }
 
849
}
 
850
 
 
851
class AddTableName : 
 
852
  public unary_function<plugin::StorageEngine *, void>
 
853
{
 
854
  string db;
 
855
  CachedDirectory& directory;
 
856
  set<string>& set_of_names;
 
857
 
 
858
public:
 
859
 
 
860
  AddTableName(CachedDirectory& directory_arg, string& database_name, set<string>& of_names) :
 
861
    directory(directory_arg),
 
862
    set_of_names(of_names)
 
863
  {
 
864
    db= database_name;
 
865
  }
 
866
 
 
867
  result_type operator() (argument_type engine)
 
868
  {
 
869
    engine->doGetTableNames(directory, db, set_of_names);
 
870
  }
 
871
};
 
872
 
 
873
void plugin::StorageEngine::getTableNames(string& db, set<string>& set_of_names)
 
874
{
 
875
  char tmp_path[FN_REFLEN];
 
876
 
 
877
  build_table_filename(tmp_path, sizeof(tmp_path), db.c_str(), "", false);
 
878
 
 
879
  CachedDirectory directory(tmp_path, set_of_table_definition_ext);
 
880
 
 
881
  if (db.compare("information_schema"))
 
882
  {
 
883
    if (directory.fail())
 
884
    {
 
885
      my_errno= directory.getError();
 
886
      if (my_errno == ENOENT)
 
887
        my_error(ER_BAD_DB_ERROR, MYF(ME_BELL+ME_WAITTANG), db.c_str());
 
888
      else
 
889
        my_error(ER_CANT_READ_DIR, MYF(ME_BELL+ME_WAITTANG), directory.getPath(), my_errno);
 
890
      return;
 
891
    }
 
892
  }
 
893
 
 
894
  for_each(vector_of_engines.begin(), vector_of_engines.end(),
 
895
           AddTableName(directory, db, set_of_names));
 
896
}
 
897
 
 
898
/* This will later be converted to TableIdentifiers */
 
899
class DropTables: public unary_function<plugin::StorageEngine *, void>
 
900
{
 
901
  Session &session;
 
902
  set<string>& set_of_names;
 
903
 
 
904
public:
 
905
 
 
906
  DropTables(Session &session_arg, set<string>& of_names) :
 
907
    session(session_arg),
 
908
    set_of_names(of_names)
 
909
  { }
 
910
 
 
911
  result_type operator() (argument_type engine)
 
912
  {
 
913
 
 
914
    for (set<string>::iterator iter= set_of_names.begin();
 
915
         iter != set_of_names.end();
 
916
         iter++)
 
917
    {
 
918
      int error= engine->doDropTable(session, *iter);
 
919
 
 
920
      // On a return of zero we know we found and deleted the table. So we
 
921
      // remove it from our search.
 
922
      if (! error)
 
923
        set_of_names.erase(iter);
 
924
    }
 
925
  }
 
926
};
 
927
 
 
928
/*
 
929
  This only works for engines which use file based DFE.
 
930
 
 
931
  Note-> Unlike MySQL, we do not, on purpose, delete files that do not match any engines. 
 
932
*/
 
933
void plugin::StorageEngine::removeLostTemporaryTables(Session &session, const char *directory)
 
934
{
 
935
  CachedDirectory dir(directory, set_of_table_definition_ext);
 
936
  set<string> set_of_table_names;
 
937
 
 
938
  if (dir.fail())
 
939
  {
 
940
    my_errno= dir.getError();
 
941
    my_error(ER_CANT_READ_DIR, MYF(0), directory, my_errno);
 
942
 
 
943
    return;
 
944
  }
 
945
 
 
946
  CachedDirectory::Entries files= dir.getEntries();
 
947
 
 
948
  for (CachedDirectory::Entries::iterator fileIter= files.begin();
 
949
       fileIter != files.end(); fileIter++)
 
950
  {
 
951
    size_t length;
 
952
    string path;
 
953
    CachedDirectory::Entry *entry= *fileIter;
 
954
 
 
955
    /* We remove the file extension. */
 
956
    length= entry->filename.length();
 
957
    entry->filename.resize(length - DEFAULT_DEFINITION_FILE_EXT.length());
 
958
 
 
959
    path+= directory;
 
960
    path+= FN_LIBCHAR;
 
961
    path+= entry->filename;
 
962
    set_of_table_names.insert(path);
 
963
  }
 
964
 
 
965
  for_each(vector_of_engines.begin(), vector_of_engines.end(),
 
966
           DropTables(session, set_of_table_names));
 
967
  
 
968
  /*
 
969
    Now we just clean up anything that might left over.
 
970
 
 
971
    We rescan because some of what might have been there should
 
972
    now be all nice and cleaned up.
 
973
  */
 
974
  set<string> all_exts= set_of_table_definition_ext;
 
975
 
 
976
  for (vector<plugin::StorageEngine *>::iterator iter= vector_of_engines.begin();
 
977
       iter != vector_of_engines.end() ; iter++)
 
978
  {
 
979
    for (const char **ext= (*iter)->bas_ext(); *ext ; ext++)
 
980
      all_exts.insert(*ext);
 
981
  }
 
982
 
 
983
  CachedDirectory rescan(directory, all_exts);
 
984
 
 
985
  files= rescan.getEntries();
 
986
  for (CachedDirectory::Entries::iterator fileIter= files.begin();
 
987
       fileIter != files.end(); fileIter++)
 
988
  {
 
989
    string path;
 
990
    CachedDirectory::Entry *entry= *fileIter;
 
991
 
 
992
    path+= directory;
 
993
    path+= FN_LIBCHAR;
 
994
    path+= entry->filename;
 
995
 
 
996
    unlink(path.c_str());
 
997
  }
 
998
}
 
999
 
 
1000
 
 
1001
} /* namespace drizzled */