← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to drizzled/statement/create_table.cc

  • Committer: Lee Bieber
  • Date: 2011-03-13 16:37:38 UTC
  • mfrom: (2227.4.18 session2)
  • Revision ID: kalebral@gmail.com-20110313163738-7ti21zk40o2xi3ew
Merge Olaf - Refactor Session

Show diffs side-by-side

added added

removed removed

Lines of Context:
drizzled/statement/create_table.cc
92
92
  if (is_engine_set)
93
93
  {
94
94
    create_info().db_type= 
95
 
      plugin::StorageEngine::findByName(*getSession(), createTableMessage().engine().name());
 
95
      plugin::StorageEngine::findByName(session(), createTableMessage().engine().name());
96
96
 
97
97
    if (create_info().db_type == NULL)
98
98
    {
104
104
  }
105
105
  else /* We now get the default, place it in create_info, and put the engine name in table proto */
106
106
  {
107
 
    create_info().db_type= getSession()->getDefaultStorageEngine();
 
107
    create_info().db_type= session().getDefaultStorageEngine();
108
108
  }
109
109
 
110
110
  if (not validateCreateTableOption())
114
114
 
115
115
  if (not lex_identified_temp_table)
116
116
  {
117
 
    if (getSession()->inTransaction())
 
117
    if (session().inTransaction())
118
118
    {
119
119
      my_error(ER_TRANSACTIONAL_DDL_NOT_SUPPORTED, MYF(0));
120
120
      return true;
152
152
     TABLE in the same way. That way we avoid that a new table is
153
153
     created during a gobal read lock.
154
154
   */
155
 
  if (! (need_start_waiting= not getSession()->wait_if_global_read_lock(0, 1)))
 
155
  if (! (need_start_waiting= not session().wait_if_global_read_lock(0, 1)))
156
156
  {
157
157
    /* put tables back for PS rexecuting */
158
158
    lex().link_first_table_back(create_table_list, link_to_local);
165
165
    Release the protection against the global read lock and wake
166
166
    everyone, who might want to set a global read lock.
167
167
  */
168
 
  getSession()->startWaitingGlobalReadLock();
 
168
  session().startWaitingGlobalReadLock();
169
169
 
170
170
  return res;
171
171
}
192
192
        create_table_list->setCreate(true);
193
193
      }
194
194
 
195
 
      if (not (res= getSession()->openTablesLock(lex().query_tables)))
 
195
      if (not (res= session().openTablesLock(lex().query_tables)))
196
196
      {
197
197
        /*
198
198
          Is table which we are changing used somewhere in other parts
233
233
            CREATE from SELECT give its Select_Lex for SELECT,
234
234
            and item_list belong to SELECT
235
235
          */
236
 
          res= handle_select(getSession(), &lex(), result, 0);
 
236
          res= handle_select(&session(), &lex(), result, 0);
237
237
          delete result;
238
238
        }
239
239
      }
247
247
      /* regular create */
248
248
      if (is_create_table_like)
249
249
      {
250
 
        res= create_like_table(getSession(), 
 
250
        res= create_like_table(&session(), 
251
251
                               new_table_identifier,
252
252
                               identifier::Table(select_tables->getSchemaName(),
253
253
                                                 select_tables->getTableName()),
265
265
          *field= alter_info.alter_proto.added_field(x);
266
266
        }
267
267
 
268
 
        res= create_table(getSession(), 
 
268
        res= create_table(&session(), 
269
269
                          new_table_identifier,
270
270
                          &create_info(),
271
271
                          createTableMessage(),
277
277
 
278
278
      if (not res)
279
279
      {
280
 
        getSession()->my_ok();
 
280
        session().my_ok();
281
281
      }
282
282
    }
283
283
  } while (0);
295
295
  if (not plugin::StorageEngine::canCreateTable(identifier))
296
296
  {
297
297
    identifier::Schema schema_identifier= identifier;
298
 
    error::access(*getSession()->user(), schema_identifier);
 
298
    error::access(*session().user(), schema_identifier);
299
299
 
300
300
    return false;
301
301
  }