← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to drizzled/statement/create_table.cc

edit

Show diffs side-by-side

added added

removed removed

Lines of Context:
drizzled/statement/create_table.cc
18
18
 *  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
19
19
 */
20
20
 
21
 
#include <config.h>
22
 
 
 
21
#include "config.h"
23
22
#include <drizzled/show.h>
24
23
#include <drizzled/lock.h>
25
24
#include <drizzled/session.h>
26
25
#include <drizzled/statement/create_table.h>
27
26
#include <drizzled/message.h>
28
27
#include <drizzled/identifier.h>
29
 
#include <drizzled/plugin/storage_engine.h>
30
 
#include <drizzled/select_create.h>
31
28
 
32
29
#include <iostream>
33
30
 
34
31
namespace drizzled
35
32
{
36
33
 
37
 
namespace statement {
38
 
 
39
 
CreateTable::CreateTable(Session *in_session, Table_ident *ident, bool is_temporary) :
40
 
  Statement(in_session),
41
 
  change(NULL),
42
 
  default_value(NULL),
43
 
  on_update_value(NULL),
44
 
  is_engine_set(false),
45
 
  is_create_table_like(false),
46
 
  lex_identified_temp_table(false),
47
 
  link_to_local(false),
48
 
  create_table_list(NULL)
49
 
{
50
 
  getSession()->getLex()->sql_command= SQLCOM_CREATE_TABLE;
51
 
  createTableMessage().set_name(ident->table.str, ident->table.length);
52
 
#if 0
53
 
  createTableMessage().set_schema(ident->db.str, ident->db.length);
54
 
#endif
55
 
 
56
 
  if (is_temporary)
57
 
  {
58
 
    createTableMessage().set_type(message::Table::TEMPORARY);
59
 
  }
60
 
  else
61
 
  {
62
 
    createTableMessage().set_type(message::Table::STANDARD);
63
 
  }
64
 
}
65
 
 
66
 
CreateTable::CreateTable(Session *in_session) :
67
 
  Statement(in_session),
68
 
  change(NULL),
69
 
  default_value(NULL),
70
 
  on_update_value(NULL),
71
 
  is_engine_set(false),
72
 
  is_create_table_like(false),
73
 
  lex_identified_temp_table(false),
74
 
  link_to_local(false),
75
 
  create_table_list(NULL)
76
 
{
77
 
  getSession()->getLex()->sql_command= SQLCOM_CREATE_TABLE;
78
 
}
79
 
 
80
 
} // namespace statement
81
 
 
82
34
bool statement::CreateTable::execute()
83
35
{
84
 
  TableList *first_table= (TableList *) getSession()->getLex()->select_lex.table_list.first;
85
 
  TableList *all_tables= getSession()->getLex()->query_tables;
 
36
  TableList *first_table= (TableList *) session->lex->select_lex.table_list.first;
 
37
  TableList *all_tables= session->lex->query_tables;
86
38
  assert(first_table == all_tables && first_table != 0);
87
39
  bool need_start_waiting= false;
88
40
  lex_identified_temp_table= createTableMessage().type() == message::Table::TEMPORARY;
92
44
  if (is_engine_set)
93
45
  {
94
46
    create_info().db_type= 
95
 
      plugin::StorageEngine::findByName(*getSession(), createTableMessage().engine().name());
 
47
      plugin::StorageEngine::findByName(*session, createTableMessage().engine().name());
96
48
 
97
49
    if (create_info().db_type == NULL)
98
50
    {
104
56
  }
105
57
  else /* We now get the default, place it in create_info, and put the engine name in table proto */
106
58
  {
107
 
    create_info().db_type= getSession()->getDefaultStorageEngine();
 
59
    create_info().db_type= session->getDefaultStorageEngine();
108
60
  }
109
61
 
110
62
  if (not validateCreateTableOption())
112
64
    return true;
113
65
  }
114
66
 
 
67
 
 
68
  /* If CREATE TABLE of non-temporary table, do implicit commit */
115
69
  if (not lex_identified_temp_table)
116
70
  {
117
 
    if (getSession()->inTransaction())
 
71
    if (not session->endActiveTransaction())
118
72
    {
119
 
      my_error(ER_TRANSACTIONAL_DDL_NOT_SUPPORTED, MYF(0));
120
73
      return true;
121
74
    }
122
75
  }
123
76
  /* Skip first table, which is the table we are creating */
124
 
  create_table_list= getSession()->getLex()->unlink_first_table(&link_to_local);
 
77
  create_table_list= session->lex->unlink_first_table(&link_to_local);
125
78
 
126
79
  drizzled::message::table::init(createTableMessage(), createTableMessage().name(), create_table_list->getSchemaName(), create_info().db_type->getName());
127
80
 
132
85
  if (not check(new_table_identifier))
133
86
  {
134
87
    /* put tables back for PS rexecuting */
135
 
    getSession()->getLex()->link_first_table_back(create_table_list, link_to_local);
 
88
    session->lex->link_first_table_back(create_table_list, link_to_local);
136
89
    return true;
137
90
  }
138
91
 
152
105
     TABLE in the same way. That way we avoid that a new table is
153
106
     created during a gobal read lock.
154
107
   */
155
 
  if (! (need_start_waiting= not getSession()->wait_if_global_read_lock(0, 1)))
 
108
  if (! (need_start_waiting= not session->wait_if_global_read_lock(0, 1)))
156
109
  {
157
110
    /* put tables back for PS rexecuting */
158
 
    getSession()->getLex()->link_first_table_back(create_table_list, link_to_local);
 
111
    session->lex->link_first_table_back(create_table_list, link_to_local);
159
112
    return true;
160
113
  }
161
114
 
165
118
    Release the protection against the global read lock and wake
166
119
    everyone, who might want to set a global read lock.
167
120
  */
168
 
  getSession()->startWaitingGlobalReadLock();
 
121
  session->startWaitingGlobalReadLock();
169
122
 
170
123
  return res;
171
124
}
173
126
bool statement::CreateTable::executeInner(identifier::Table::const_reference new_table_identifier)
174
127
{
175
128
  bool res= false;
176
 
  Select_Lex *select_lex= &getSession()->getLex()->select_lex;
177
 
  TableList *select_tables= getSession()->getLex()->query_tables;
 
129
  Select_Lex *select_lex= &session->lex->select_lex;
 
130
  TableList *select_tables= session->lex->query_tables;
178
131
 
179
132
  do 
180
133
  {
181
134
    if (select_lex->item_list.elements)         // With select
182
135
    {
183
 
      Select_Lex_Unit *unit= &getSession()->getLex()->unit;
 
136
      Select_Lex_Unit *unit= &session->lex->unit;
184
137
      select_result *result;
185
138
 
186
139
      select_lex->options|= SELECT_NO_UNLOCK;
188
141
 
189
142
      if (not lex_identified_temp_table)
190
143
      {
191
 
        getSession()->getLex()->link_first_table_back(create_table_list, link_to_local);
 
144
        session->lex->link_first_table_back(create_table_list, link_to_local);
192
145
        create_table_list->setCreate(true);
193
146
      }
194
147
 
195
 
      if (not (res= getSession()->openTablesLock(getSession()->getLex()->query_tables)))
 
148
      if (not (res= session->openTablesLock(session->lex->query_tables)))
196
149
      {
197
150
        /*
198
151
          Is table which we are changing used somewhere in other parts
201
154
        if (not lex_identified_temp_table)
202
155
        {
203
156
          TableList *duplicate= NULL;
204
 
          create_table_list= getSession()->getLex()->unlink_first_table(&link_to_local);
 
157
          create_table_list= session->lex->unlink_first_table(&link_to_local);
205
158
 
206
159
          if ((duplicate= unique_table(create_table_list, select_tables)))
207
160
          {
208
161
            my_error(ER_UPDATE_TABLE_USED, MYF(0), create_table_list->alias);
209
162
            /* put tables back for PS rexecuting */
210
 
            getSession()->getLex()->link_first_table_back(create_table_list, link_to_local);
 
163
            session->lex->link_first_table_back(create_table_list, link_to_local);
211
164
 
212
165
            res= true;
213
166
            break;
219
172
          needs to be created for every execution of a PS/SP.
220
173
        */
221
174
        if ((result= new select_create(create_table_list,
222
 
                                       getSession()->getLex()->exists(),
 
175
                                       session->getLex()->exists(),
223
176
                                       &create_info(),
224
177
                                       createTableMessage(),
225
178
                                       &alter_info,
226
179
                                       select_lex->item_list,
227
 
                                       getSession()->getLex()->duplicates,
228
 
                                       getSession()->getLex()->ignore,
 
180
                                       session->lex->duplicates,
 
181
                                       session->lex->ignore,
229
182
                                       select_tables,
230
183
                                       new_table_identifier)))
231
184
        {
233
186
            CREATE from SELECT give its Select_Lex for SELECT,
234
187
            and item_list belong to SELECT
235
188
          */
236
 
          res= handle_select(getSession(), getSession()->getLex(), result, 0);
 
189
          res= handle_select(session, session->lex, result, 0);
237
190
          delete result;
238
191
        }
239
192
      }
240
193
      else if (not lex_identified_temp_table)
241
194
      {
242
 
        create_table_list= getSession()->getLex()->unlink_first_table(&link_to_local);
 
195
        create_table_list= session->lex->unlink_first_table(&link_to_local);
243
196
      }
244
197
    }
245
198
    else
247
200
      /* regular create */
248
201
      if (is_create_table_like)
249
202
      {
250
 
        res= create_like_table(getSession(), 
 
203
        res= create_like_table(session, 
251
204
                               new_table_identifier,
252
205
                               identifier::Table(select_tables->getSchemaName(),
253
206
                                                 select_tables->getTableName()),
254
207
                               createTableMessage(),
255
 
                               getSession()->getLex()->exists(),
 
208
                               session->getLex()->exists(),
256
209
                               is_engine_set);
257
210
      }
258
211
      else
265
218
          *field= alter_info.alter_proto.added_field(x);
266
219
        }
267
220
 
268
 
        res= create_table(getSession(), 
 
221
        res= create_table(session, 
269
222
                          new_table_identifier,
270
223
                          &create_info(),
271
224
                          createTableMessage(),
272
225
                          &alter_info, 
273
226
                          false, 
274
227
                          0,
275
 
                          getSession()->getLex()->exists());
 
228
                          session->getLex()->exists());
276
229
      }
277
230
 
278
231
      if (not res)
279
232
      {
280
 
        getSession()->my_ok();
 
233
        session->my_ok();
281
234
      }
282
235
    }
283
236
  } while (0);
294
247
  // See if any storage engine objects to the name of the file
295
248
  if (not plugin::StorageEngine::canCreateTable(identifier))
296
249
  {
297
 
    identifier::Schema schema_identifier= identifier;
298
 
    error::access(*getSession()->user(), schema_identifier);
 
250
    my_error(ER_DBACCESS_DENIED_ERROR, MYF(0), "", "", identifier.getSchemaName().c_str());
299
251
 
300
252
    return false;
301
253
  }
304
256
  // create for the table.
305
257
  if (not plugin::StorageEngine::doesSchemaExist(identifier))
306
258
  {
307
 
    identifier::Schema schema_identifier= identifier;
308
 
    my_error(ER_BAD_DB_ERROR, schema_identifier);
 
259
    my_error(ER_BAD_DB_ERROR, MYF(0), identifier.getSchemaName().c_str());
309
260
 
310
261
    return false;
311
262
  }