← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to drizzled/sql_table.h

This patch completes the first step in the splitting of
the XA resource manager API from the storage engine API,
as outlined in the specification here:

http://drizzle.org/wiki/XaStorageEngine

* Splits plugin::StorageEngine into a base StorageEngine
  class and two derived classes, TransactionalStorageEngine
  and XaStorageEngine.  XaStorageEngine derives from
  TransactionalStorageEngine and creates the XA Resource
  Manager API for storage engines.

  - The methods moved from StorageEngine to TransactionalStorageEngine
    include releaseTemporaryLatches(), startConsistentSnapshot(), 
    commit(), rollback(), setSavepoint(), releaseSavepoint(),
    rollbackToSavepoint() and hasTwoPhaseCommit()
  - The methods moved from StorageEngine to XaStorageEngine
    include recover(), commitXid(), rollbackXid(), and prepare()

* Places all static "EngineVector"s into their proper
  namespaces (typedefs belong in header files, not implementation files)
  and places all static methods corresponding
  to either only transactional engines or only XA engines
  into their respective files in /drizzled/plugin/

* Modifies the InnoDB "handler" files to extend plugin::XaStorageEngine
  and not plugin::StorageEngine

The next step, as outlined in the wiki spec page above, is to isolate
the XA Resource Manager API into its own plugin class and modify
plugin::XaStorageEngine to implement plugin::XaResourceManager via
composition.  This is necessary to enable building plugins which can
participate in an XA transaction *without having to have that plugin
implement the entire storage engine API*

Show diffs side-by-side

added added

removed removed

Lines of Context:
drizzled/sql_table.h
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
26
26
#ifndef DRIZZLED_SQL_TABLE_H
27
27
#define DRIZZLED_SQL_TABLE_H
28
28
 
29
 
#include <drizzled/base.h>
 
29
#include "drizzled/base.h"
30
30
 
31
31
namespace drizzled
32
32
{
35
35
class TableList;
36
36
typedef struct st_ha_check_opt HA_CHECK_OPT;
37
37
class Table;
 
38
typedef struct st_key KEY;
38
39
typedef struct st_ha_create_information HA_CREATE_INFO;
39
40
class AlterInfo;
40
41
class Cursor;
41
42
 
 
43
/* Flags for conversion functions. */
 
44
static const uint32_t FN_FROM_IS_TMP(1 << 0);
 
45
static const uint32_t FN_TO_IS_TMP(1 << 0);
 
46
 
42
47
namespace message { class Table; }
43
 
namespace identifier { class Table; }
 
48
class TableIdentifier;
44
49
 
45
 
int rm_table_part2(Session *session, TableList *tables, bool if_exists,
 
50
int mysql_rm_table_part2(Session *session, TableList *tables, bool if_exists,
46
51
                         bool drop_temporary);
 
52
void write_bin_log_drop_table(Session *session,
 
53
                              bool if_exists, const char *db_name,
 
54
                              const char *table_name);
 
55
bool quick_rm_table(Session& session,
 
56
                    TableIdentifier &identifier);
47
57
void close_cached_table(Session *session, Table *table);
48
58
 
49
59
void wait_while_table_is_used(Session *session, Table *table,
50
60
                              enum ha_extra_function function);
51
61
 
52
 
bool check_table(Session* session, TableList* table_list,
53
 
                 HA_CHECK_OPT* check_opt);
54
 
bool analyze_table(Session* session, TableList* table_list,
55
 
                   HA_CHECK_OPT* check_opt);
56
 
bool optimize_table(Session* session, TableList* table_list,
57
 
                    HA_CHECK_OPT* check_opt);
58
 
 
59
 
void write_bin_log(Session *session, const std::string &query);
60
 
 
61
 
bool is_primary_key(KeyInfo *key_info);
 
62
bool mysql_checksum_table(Session* session, TableList* table_list,
 
63
                          HA_CHECK_OPT* check_opt);
 
64
bool mysql_check_table(Session* session, TableList* table_list,
 
65
                       HA_CHECK_OPT* check_opt);
 
66
bool mysql_analyze_table(Session* session, TableList* table_list,
 
67
                         HA_CHECK_OPT* check_opt);
 
68
bool mysql_optimize_table(Session* session, TableList* table_list,
 
69
                          HA_CHECK_OPT* check_opt);
 
70
 
 
71
void write_bin_log(Session *session,
 
72
                   char const *query, size_t query_length);
 
73
 
 
74
bool is_primary_key(KEY *key_info);
62
75
const char* is_primary_key_name(const char* key_name);
63
76
bool check_engine(Session *, const char *, message::Table *, HA_CREATE_INFO *);
64
77
void set_table_default_charset(HA_CREATE_INFO *create_info, const char *db);
 
78
/*
 
79
  Preparation for table creation
 
80
 
 
81
  SYNOPSIS
 
82
    mysql_prepare_create_table()
 
83
      session                       Thread object.
 
84
      create_info               Create information (like MAX_ROWS).
 
85
      alter_info                List of columns and indexes to create
 
86
      tmp_table                 If a temporary table is to be created.
 
87
      db_options          INOUT Table options (like HA_OPTION_PACK_RECORD).
 
88
      file                      The Cursor for the new table.
 
89
      key_info_buffer     OUT   An array of KEY structs for the indexes.
 
90
      key_count           OUT   The number of elements in the array.
 
91
      select_field_count        The number of fields coming from a select table.
 
92
 
 
93
  DESCRIPTION
 
94
    Prepares the table and key structures for table creation.
 
95
 
 
96
  NOTES
 
97
    sets create_info->varchar if the table has a varchar
 
98
 
 
99
  RETURN VALUES
 
100
    false    OK
 
101
    true     error
 
102
*/
 
103
int mysql_prepare_create_table(Session *session,
 
104
                               HA_CREATE_INFO *create_info,
 
105
                               message::Table *create_proto,
 
106
                               AlterInfo *alter_info,
 
107
                               bool tmp_table,
 
108
                               uint32_t *db_options,
 
109
                               Cursor *file,
 
110
                               KEY **key_info_buffer,
 
111
                               uint32_t *key_count,
 
112
                               int select_field_count);
 
113
 
 
114
 
 
115
/* Conversion functions */
 
116
size_t build_tmptable_filename(char *buff, size_t bufflen);
 
117
size_t build_table_filename(char *buff, size_t bufflen, const char *db,
 
118
                            const char *table_name, bool is_tmp);
 
119
 
65
120
} /* namespace drizzled */
66
121
 
67
122
#endif /* DRIZZLED_SQL_TABLE_H */