← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to drizzled/db.cc

  • Committer: Brian Aker
  • Date: 2010-08-06 01:25:55 UTC
  • mfrom: (1688.1.3 drizzle)
  • Revision ID: brian@gaz-20100806012555-f1bxjm4iesdtiwlw
Merge Build (rollup)

Show diffs side-by-side

added added

removed removed

Lines of Context:
drizzled/db.cc
44
44
#include "drizzled/pthread_globals.h"
45
45
#include "drizzled/charset.h"
46
46
 
 
47
#include <boost/thread/mutex.hpp>
 
48
 
 
49
boost::mutex LOCK_create_db;
 
50
 
47
51
#include "drizzled/internal/my_sys.h"
48
52
 
49
53
#define MAX_DROP_TABLE_Q_LEN      1024
106
110
  assert(schema_message.has_collation());
107
111
 
108
112
  // @todo push this lock down into the engine
109
 
  pthread_mutex_lock(&LOCK_create_db);
 
113
  {
 
114
    boost::mutex::scoped_lock scopedLock(LOCK_create_db);
110
115
 
111
 
  // Check to see if it exists already.  
112
 
  SchemaIdentifier schema_identifier(schema_message.name());
113
 
  if (plugin::StorageEngine::doesSchemaExist(schema_identifier))
114
 
  {
115
 
    if (not is_if_not_exists)
116
 
    {
117
 
      my_error(ER_DB_CREATE_EXISTS, MYF(0), schema_message.name().c_str());
 
116
    // Check to see if it exists already.  
 
117
    SchemaIdentifier schema_identifier(schema_message.name());
 
118
    if (plugin::StorageEngine::doesSchemaExist(schema_identifier))
 
119
    {
 
120
      if (not is_if_not_exists)
 
121
      {
 
122
        my_error(ER_DB_CREATE_EXISTS, MYF(0), schema_message.name().c_str());
 
123
        error= true;
 
124
      }
 
125
      else
 
126
      {
 
127
        push_warning_printf(session, DRIZZLE_ERROR::WARN_LEVEL_NOTE,
 
128
                            ER_DB_CREATE_EXISTS, ER(ER_DB_CREATE_EXISTS),
 
129
                            schema_message.name().c_str());
 
130
        session->my_ok();
 
131
      }
 
132
    }
 
133
    else if (not plugin::StorageEngine::createSchema(schema_message)) // Try to create it 
 
134
    {
 
135
      my_error(ER_CANT_CREATE_DB, MYF(0), schema_message.name().c_str(), errno);
118
136
      error= true;
119
137
    }
120
 
    else
 
138
    else // Created !
121
139
    {
122
 
      push_warning_printf(session, DRIZZLE_ERROR::WARN_LEVEL_NOTE,
123
 
                          ER_DB_CREATE_EXISTS, ER(ER_DB_CREATE_EXISTS),
124
 
                          schema_message.name().c_str());
125
 
      session->my_ok();
 
140
      transaction_services.createSchema(session, schema_message);
 
141
      session->my_ok(1);
126
142
    }
127
143
  }
128
 
  else if (not plugin::StorageEngine::createSchema(schema_message)) // Try to create it 
129
 
  {
130
 
    my_error(ER_CANT_CREATE_DB, MYF(0), schema_message.name().c_str(), errno);
131
 
    error= true;
132
 
  }
133
 
  else // Created !
134
 
  {
135
 
    transaction_services.createSchema(session, schema_message);
136
 
    session->my_ok(1);
137
 
  }
138
 
 
139
 
  pthread_mutex_unlock(&LOCK_create_db);
140
144
  start_waiting_global_read_lock(session);
141
145
 
142
146
  return error;
164
168
  if ((wait_if_global_read_lock(session, 0, 1)))
165
169
    return false;
166
170
 
167
 
  pthread_mutex_lock(&LOCK_create_db);
168
 
 
169
 
  SchemaIdentifier schema_idenifier(schema_message.name());
170
 
  if (not plugin::StorageEngine::doesSchemaExist(schema_idenifier))
171
 
  {
172
 
    my_error(ER_SCHEMA_DOES_NOT_EXIST, MYF(0), schema_message.name().c_str());
173
 
    return false;
174
 
  }
175
 
 
176
 
  /* Change options if current database is being altered. */
177
 
  bool success= plugin::StorageEngine::alterSchema(schema_message);
178
 
 
179
 
  if (success)
180
 
  {
181
 
    transaction_services.rawStatement(session, session->getQueryString());
182
 
    session->my_ok(1);
183
 
  }
184
 
  else
185
 
  {
186
 
    my_error(ER_ALTER_SCHEMA, MYF(0), schema_message.name().c_str());
187
 
  }
188
 
 
189
 
  pthread_mutex_unlock(&LOCK_create_db);
 
171
  bool success;
 
172
  {
 
173
    boost::mutex::scoped_lock scopedLock(LOCK_create_db);
 
174
 
 
175
    SchemaIdentifier schema_idenifier(schema_message.name());
 
176
    if (not plugin::StorageEngine::doesSchemaExist(schema_idenifier))
 
177
    {
 
178
      my_error(ER_SCHEMA_DOES_NOT_EXIST, MYF(0), schema_message.name().c_str());
 
179
      return false;
 
180
    }
 
181
 
 
182
    /* Change options if current database is being altered. */
 
183
    success= plugin::StorageEngine::alterSchema(schema_message);
 
184
 
 
185
    if (success)
 
186
    {
 
187
      transaction_services.rawStatement(session, session->getQueryString());
 
188
      session->my_ok(1);
 
189
    }
 
190
    else
 
191
    {
 
192
      my_error(ER_ALTER_SCHEMA, MYF(0), schema_message.name().c_str());
 
193
    }
 
194
  }
190
195
  start_waiting_global_read_lock(session);
191
196
 
192
197
  return success;
245
250
    session->close_temporary_table(table);
246
251
  }
247
252
 
248
 
  pthread_mutex_lock(&LOCK_create_db);
249
 
 
250
 
 
251
 
  /* See if the schema exists */
252
 
  if (not plugin::StorageEngine::doesSchemaExist(schema_identifier))
253
253
  {
254
 
    if (if_exists)
 
254
    boost::mutex::scoped_lock scopedLock(LOCK_create_db);
 
255
 
 
256
    /* See if the schema exists */
 
257
    if (not plugin::StorageEngine::doesSchemaExist(schema_identifier))
255
258
    {
256
 
      push_warning_printf(session, DRIZZLE_ERROR::WARN_LEVEL_NOTE,
257
 
                          ER_DB_DROP_EXISTS, ER(ER_DB_DROP_EXISTS),
258
 
                          schema_identifier.getSQLPath().c_str());
 
259
      if (if_exists)
 
260
      {
 
261
        push_warning_printf(session, DRIZZLE_ERROR::WARN_LEVEL_NOTE,
 
262
                            ER_DB_DROP_EXISTS, ER(ER_DB_DROP_EXISTS),
 
263
                            schema_identifier.getSQLPath().c_str());
 
264
      }
 
265
      else
 
266
      {
 
267
        error= -1;
 
268
        my_error(ER_DB_DROP_EXISTS, MYF(0), schema_identifier.getSQLPath().c_str());
 
269
        goto exit;
 
270
      }
259
271
    }
260
272
    else
261
273
    {
 
274
      pthread_mutex_lock(&LOCK_open); /* After deleting database, remove all cache entries related to schema */
 
275
      remove_db_from_cache(schema_identifier);
 
276
      pthread_mutex_unlock(&LOCK_open);
 
277
 
 
278
 
262
279
      error= -1;
263
 
      my_error(ER_DB_DROP_EXISTS, MYF(0), schema_identifier.getSQLPath().c_str());
264
 
      goto exit;
 
280
      deleted= drop_tables_via_filenames(session, schema_identifier, dropped_tables);
 
281
      if (deleted >= 0)
 
282
      {
 
283
        error= 0;
 
284
      }
265
285
    }
266
 
  }
267
 
  else
268
 
  {
269
 
    pthread_mutex_lock(&LOCK_open); /* After deleting database, remove all cache entries related to schema */
270
 
    remove_db_from_cache(schema_identifier);
271
 
    pthread_mutex_unlock(&LOCK_open);
272
 
 
273
 
 
274
 
    error= -1;
275
 
    deleted= drop_tables_via_filenames(session, schema_identifier, dropped_tables);
276
286
    if (deleted >= 0)
277
287
    {
278
 
      error= 0;
 
288
      assert(! session->query.empty());
 
289
 
 
290
      TransactionServices &transaction_services= TransactionServices::singleton();
 
291
      transaction_services.dropSchema(session, schema_identifier.getSchemaName());
 
292
      session->clear_error();
 
293
      session->server_status|= SERVER_STATUS_DB_DROPPED;
 
294
      session->my_ok((uint32_t) deleted);
 
295
      session->server_status&= ~SERVER_STATUS_DB_DROPPED;
279
296
    }
280
 
  }
281
 
  if (deleted >= 0)
282
 
  {
283
 
    assert(! session->query.empty());
284
 
 
285
 
    TransactionServices &transaction_services= TransactionServices::singleton();
286
 
    transaction_services.dropSchema(session, schema_identifier.getSchemaName());
287
 
    session->clear_error();
288
 
    session->server_status|= SERVER_STATUS_DB_DROPPED;
289
 
    session->my_ok((uint32_t) deleted);
290
 
    session->server_status&= ~SERVER_STATUS_DB_DROPPED;
291
 
  }
292
 
  else
293
 
  {
294
 
    char *query, *query_pos, *query_end, *query_data_start;
295
 
 
296
 
    if (!(query= (char*) session->alloc(MAX_DROP_TABLE_Q_LEN)))
297
 
      goto exit; /* not much else we can do */
298
 
    query_pos= query_data_start= strcpy(query,"drop table ")+11;
299
 
    query_end= query + MAX_DROP_TABLE_Q_LEN;
300
 
 
301
 
    TransactionServices &transaction_services= TransactionServices::singleton();
302
 
    for (TableIdentifiers::iterator it= dropped_tables.begin();
303
 
         it != dropped_tables.end();
304
 
         it++)
 
297
    else
305
298
    {
306
 
      uint32_t tbl_name_len;
307
 
 
308
 
      /* 3 for the quotes and the comma*/
309
 
      tbl_name_len= (*it).getTableName().length() + 3;
310
 
      if (query_pos + tbl_name_len + 1 >= query_end)
 
299
      char *query, *query_pos, *query_end, *query_data_start;
 
300
 
 
301
      if (!(query= (char*) session->alloc(MAX_DROP_TABLE_Q_LEN)))
 
302
        goto exit; /* not much else we can do */
 
303
      query_pos= query_data_start= strcpy(query,"drop table ")+11;
 
304
      query_end= query + MAX_DROP_TABLE_Q_LEN;
 
305
 
 
306
      TransactionServices &transaction_services= TransactionServices::singleton();
 
307
      for (TableIdentifiers::iterator it= dropped_tables.begin();
 
308
           it != dropped_tables.end();
 
309
           it++)
 
310
      {
 
311
        uint32_t tbl_name_len;
 
312
 
 
313
        /* 3 for the quotes and the comma*/
 
314
        tbl_name_len= (*it).getTableName().length() + 3;
 
315
        if (query_pos + tbl_name_len + 1 >= query_end)
 
316
        {
 
317
          /* These DDL methods and logging protected with LOCK_create_db */
 
318
          transaction_services.rawStatement(session, query);
 
319
          query_pos= query_data_start;
 
320
        }
 
321
 
 
322
        *query_pos++ = '`';
 
323
        query_pos= strcpy(query_pos, (*it).getTableName().c_str()) + (tbl_name_len-3);
 
324
        *query_pos++ = '`';
 
325
        *query_pos++ = ',';
 
326
      }
 
327
 
 
328
      if (query_pos != query_data_start)
311
329
      {
312
330
        /* These DDL methods and logging protected with LOCK_create_db */
313
331
        transaction_services.rawStatement(session, query);
314
 
        query_pos= query_data_start;
315
332
      }
316
 
 
317
 
      *query_pos++ = '`';
318
 
      query_pos= strcpy(query_pos, (*it).getTableName().c_str()) + (tbl_name_len-3);
319
 
      *query_pos++ = '`';
320
 
      *query_pos++ = ',';
321
 
    }
322
 
 
323
 
    if (query_pos != query_data_start)
324
 
    {
325
 
      /* These DDL methods and logging protected with LOCK_create_db */
326
 
      transaction_services.rawStatement(session, query);
327
 
    }
328
 
  }
 
333
    }
329
334
 
330
335
exit:
331
 
  /*
332
 
    If this database was the client's selected database, we silently
333
 
    change the client's selected database to nothing (to have an empty
334
 
    SELECT DATABASE() in the future). For this we free() session->db and set
335
 
    it to 0.
336
 
  */
337
 
  if (schema_identifier.compare(session->db))
338
 
    mysql_change_db_impl(session);
339
 
  pthread_mutex_unlock(&LOCK_create_db);
 
336
    /*
 
337
      If this database was the client's selected database, we silently
 
338
      change the client's selected database to nothing (to have an empty
 
339
      SELECT DATABASE() in the future). For this we free() session->db and set
 
340
      it to 0.
 
341
    */
 
342
    if (schema_identifier.compare(session->db))
 
343
      mysql_change_db_impl(session);
 
344
  }
 
345
 
340
346
  start_waiting_global_read_lock(session);
341
347
 
342
348
  return error;
680
686
      the previous database name, we should do it explicitly.
681
687
    */
682
688
 
683
 
    session->set_db(schema_identifier.getLower());
 
689
    session->set_db(schema_identifier.getSchemaName());
684
690
  }
685
691
}
686
692