← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to drizzled/statement/create_table.cc

  • Committer: Brian Aker
  • Date: 2011-01-22 18:52:16 UTC
  • mfrom: (2098.4.1 catalogs)
  • Revision ID: brian@tangent.org-20110122185216-18and6vncipd7x72
Session encapsulation.

Show diffs side-by-side

added added

removed removed

Lines of Context:
drizzled/statement/create_table.cc
76
76
 
77
77
bool statement::CreateTable::execute()
78
78
{
79
 
  TableList *first_table= (TableList *) session->lex->select_lex.table_list.first;
80
 
  TableList *all_tables= session->lex->query_tables;
 
79
  TableList *first_table= (TableList *) getSession()->lex->select_lex.table_list.first;
 
80
  TableList *all_tables= getSession()->lex->query_tables;
81
81
  assert(first_table == all_tables && first_table != 0);
82
82
  bool need_start_waiting= false;
83
83
  lex_identified_temp_table= createTableMessage().type() == message::Table::TEMPORARY;
87
87
  if (is_engine_set)
88
88
  {
89
89
    create_info().db_type= 
90
 
      plugin::StorageEngine::findByName(*session, createTableMessage().engine().name());
 
90
      plugin::StorageEngine::findByName(*getSession(), createTableMessage().engine().name());
91
91
 
92
92
    if (create_info().db_type == NULL)
93
93
    {
99
99
  }
100
100
  else /* We now get the default, place it in create_info, and put the engine name in table proto */
101
101
  {
102
 
    create_info().db_type= session->getDefaultStorageEngine();
 
102
    create_info().db_type= getSession()->getDefaultStorageEngine();
103
103
  }
104
104
 
105
105
  if (not validateCreateTableOption())
109
109
 
110
110
  if (not lex_identified_temp_table)
111
111
  {
112
 
    if (session->inTransaction())
 
112
    if (getSession()->inTransaction())
113
113
    {
114
114
      my_error(ER_TRANSACTIONAL_DDL_NOT_SUPPORTED, MYF(0));
115
115
      return true;
116
116
    }
117
117
  }
118
118
  /* Skip first table, which is the table we are creating */
119
 
  create_table_list= session->lex->unlink_first_table(&link_to_local);
 
119
  create_table_list= getSession()->lex->unlink_first_table(&link_to_local);
120
120
 
121
121
  drizzled::message::table::init(createTableMessage(), createTableMessage().name(), create_table_list->getSchemaName(), create_info().db_type->getName());
122
122
 
127
127
  if (not check(new_table_identifier))
128
128
  {
129
129
    /* put tables back for PS rexecuting */
130
 
    session->lex->link_first_table_back(create_table_list, link_to_local);
 
130
    getSession()->lex->link_first_table_back(create_table_list, link_to_local);
131
131
    return true;
132
132
  }
133
133
 
147
147
     TABLE in the same way. That way we avoid that a new table is
148
148
     created during a gobal read lock.
149
149
   */
150
 
  if (! (need_start_waiting= not session->wait_if_global_read_lock(0, 1)))
 
150
  if (! (need_start_waiting= not getSession()->wait_if_global_read_lock(0, 1)))
151
151
  {
152
152
    /* put tables back for PS rexecuting */
153
 
    session->lex->link_first_table_back(create_table_list, link_to_local);
 
153
    getSession()->lex->link_first_table_back(create_table_list, link_to_local);
154
154
    return true;
155
155
  }
156
156
 
160
160
    Release the protection against the global read lock and wake
161
161
    everyone, who might want to set a global read lock.
162
162
  */
163
 
  session->startWaitingGlobalReadLock();
 
163
  getSession()->startWaitingGlobalReadLock();
164
164
 
165
165
  return res;
166
166
}
168
168
bool statement::CreateTable::executeInner(identifier::Table::const_reference new_table_identifier)
169
169
{
170
170
  bool res= false;
171
 
  Select_Lex *select_lex= &session->lex->select_lex;
172
 
  TableList *select_tables= session->lex->query_tables;
 
171
  Select_Lex *select_lex= &getSession()->lex->select_lex;
 
172
  TableList *select_tables= getSession()->lex->query_tables;
173
173
 
174
174
  do 
175
175
  {
176
176
    if (select_lex->item_list.elements)         // With select
177
177
    {
178
 
      Select_Lex_Unit *unit= &session->lex->unit;
 
178
      Select_Lex_Unit *unit= &getSession()->lex->unit;
179
179
      select_result *result;
180
180
 
181
181
      select_lex->options|= SELECT_NO_UNLOCK;
183
183
 
184
184
      if (not lex_identified_temp_table)
185
185
      {
186
 
        session->lex->link_first_table_back(create_table_list, link_to_local);
 
186
        getSession()->lex->link_first_table_back(create_table_list, link_to_local);
187
187
        create_table_list->setCreate(true);
188
188
      }
189
189
 
190
 
      if (not (res= session->openTablesLock(session->lex->query_tables)))
 
190
      if (not (res= getSession()->openTablesLock(getSession()->lex->query_tables)))
191
191
      {
192
192
        /*
193
193
          Is table which we are changing used somewhere in other parts
196
196
        if (not lex_identified_temp_table)
197
197
        {
198
198
          TableList *duplicate= NULL;
199
 
          create_table_list= session->lex->unlink_first_table(&link_to_local);
 
199
          create_table_list= getSession()->lex->unlink_first_table(&link_to_local);
200
200
 
201
201
          if ((duplicate= unique_table(create_table_list, select_tables)))
202
202
          {
203
203
            my_error(ER_UPDATE_TABLE_USED, MYF(0), create_table_list->alias);
204
204
            /* put tables back for PS rexecuting */
205
 
            session->lex->link_first_table_back(create_table_list, link_to_local);
 
205
            getSession()->lex->link_first_table_back(create_table_list, link_to_local);
206
206
 
207
207
            res= true;
208
208
            break;
214
214
          needs to be created for every execution of a PS/SP.
215
215
        */
216
216
        if ((result= new select_create(create_table_list,
217
 
                                       session->getLex()->exists(),
 
217
                                       getSession()->getLex()->exists(),
218
218
                                       &create_info(),
219
219
                                       createTableMessage(),
220
220
                                       &alter_info,
221
221
                                       select_lex->item_list,
222
 
                                       session->lex->duplicates,
223
 
                                       session->lex->ignore,
 
222
                                       getSession()->lex->duplicates,
 
223
                                       getSession()->lex->ignore,
224
224
                                       select_tables,
225
225
                                       new_table_identifier)))
226
226
        {
228
228
            CREATE from SELECT give its Select_Lex for SELECT,
229
229
            and item_list belong to SELECT
230
230
          */
231
 
          res= handle_select(session, session->lex, result, 0);
 
231
          res= handle_select(getSession(), getSession()->lex, result, 0);
232
232
          delete result;
233
233
        }
234
234
      }
235
235
      else if (not lex_identified_temp_table)
236
236
      {
237
 
        create_table_list= session->lex->unlink_first_table(&link_to_local);
 
237
        create_table_list= getSession()->lex->unlink_first_table(&link_to_local);
238
238
      }
239
239
    }
240
240
    else
242
242
      /* regular create */
243
243
      if (is_create_table_like)
244
244
      {
245
 
        res= create_like_table(session, 
 
245
        res= create_like_table(getSession(), 
246
246
                               new_table_identifier,
247
247
                               identifier::Table(select_tables->getSchemaName(),
248
248
                                                 select_tables->getTableName()),
249
249
                               createTableMessage(),
250
 
                               session->getLex()->exists(),
 
250
                               getSession()->getLex()->exists(),
251
251
                               is_engine_set);
252
252
      }
253
253
      else
260
260
          *field= alter_info.alter_proto.added_field(x);
261
261
        }
262
262
 
263
 
        res= create_table(session, 
 
263
        res= create_table(getSession(), 
264
264
                          new_table_identifier,
265
265
                          &create_info(),
266
266
                          createTableMessage(),
267
267
                          &alter_info, 
268
268
                          false, 
269
269
                          0,
270
 
                          session->getLex()->exists());
 
270
                          getSession()->getLex()->exists());
271
271
      }
272
272
 
273
273
      if (not res)
274
274
      {
275
 
        session->my_ok();
 
275
        getSession()->my_ok();
276
276
      }
277
277
    }
278
278
  } while (0);