← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to drizzled/schema.cc

  • Committer: Brian Aker
  • Date: 2011-02-14 17:05:06 UTC
  • mto: (2170.1.1 alter-table)
  • mto: This revision was merged to the branch mainline in revision 2172.
  • Revision ID: brian@tangent.org-20110214170506-a5tm2g8hssjirfm6
Finalize interface for schema.

Show diffs side-by-side

added added

removed removed

Lines of Context:
drizzled/schema.cc
56
56
namespace schema
57
57
{
58
58
 
59
 
static void change_db_impl(Session *session);
60
 
static void change_db_impl(Session *session, identifier::Schema &schema_identifier);
 
59
static void change_db_impl(Session &session);
 
60
static void change_db_impl(Session &session, identifier::Schema &schema_identifier);
61
61
 
62
62
/*
63
63
  Create a database
80
80
 
81
81
*/
82
82
 
83
 
bool create(Session *session, const message::Schema &schema_message, const bool is_if_not_exists)
 
83
bool create(Session &session, const message::Schema &schema_message, const bool is_if_not_exists)
84
84
{
85
85
  TransactionServices &transaction_services= TransactionServices::singleton();
86
86
  bool error= false;
97
97
    has the global read lock and refuses the operation with
98
98
    ER_CANT_UPDATE_WITH_READLOCK if applicable.
99
99
  */
100
 
  if (session->wait_if_global_read_lock(false, true))
 
100
  if (session.wait_if_global_read_lock(false, true))
101
101
  {
102
102
    return false;
103
103
  }
107
107
 
108
108
  // @todo push this lock down into the engine
109
109
  {
110
 
    boost::mutex::scoped_lock scopedLock(session->catalog().schemaLock());
 
110
    boost::mutex::scoped_lock scopedLock(session.catalog().schemaLock());
111
111
 
112
112
    // Check to see if it exists already.  
113
113
    identifier::Schema schema_identifier(schema_message.name());
120
120
      }
121
121
      else
122
122
      {
123
 
        push_warning_printf(session, DRIZZLE_ERROR::WARN_LEVEL_NOTE,
 
123
        push_warning_printf(&session, DRIZZLE_ERROR::WARN_LEVEL_NOTE,
124
124
                            ER_DB_CREATE_EXISTS, ER(ER_DB_CREATE_EXISTS),
125
125
                            schema_message.name().c_str());
126
 
        session->my_ok();
 
126
        session.my_ok();
127
127
      }
128
128
    }
129
129
    else if (not plugin::StorageEngine::createSchema(schema_message)) // Try to create it 
133
133
    }
134
134
    else // Created !
135
135
    {
136
 
      transaction_services.createSchema(*session, schema_message);
137
 
      session->my_ok(1);
 
136
      transaction_services.createSchema(session, schema_message);
 
137
      session.my_ok(1);
138
138
    }
139
139
  }
140
 
  session->startWaitingGlobalReadLock();
 
140
  session.startWaitingGlobalReadLock();
141
141
 
142
142
  return error;
143
143
}
145
145
 
146
146
/* db-name is already validated when we come here */
147
147
 
148
 
bool alter(Session *session,
 
148
bool alter(Session &session,
149
149
           const message::Schema &schema_message,
150
 
           const message::schema::shared_ptr &original_schema)
 
150
           const message::Schema &original_schema)
151
151
{
152
152
  TransactionServices &transaction_services= TransactionServices::singleton();
153
153
 
163
163
    has the global read lock and refuses the operation with
164
164
    ER_CANT_UPDATE_WITH_READLOCK if applicable.
165
165
  */
166
 
  if ((session->wait_if_global_read_lock(false, true)))
 
166
  if ((session.wait_if_global_read_lock(false, true)))
167
167
    return false;
168
168
 
169
169
  bool success;
170
170
  {
171
 
    boost::mutex::scoped_lock scopedLock(session->catalog().schemaLock());
 
171
    boost::mutex::scoped_lock scopedLock(session.catalog().schemaLock());
172
172
 
173
173
    identifier::Schema schema_idenifier(schema_message.name());
174
174
    if (not plugin::StorageEngine::doesSchemaExist(schema_idenifier))
182
182
 
183
183
    if (success)
184
184
    {
185
 
      transaction_services.alterSchema(*session, original_schema, schema_message);
186
 
      session->my_ok(1);
 
185
      transaction_services.alterSchema(session, original_schema, schema_message);
 
186
      session.my_ok(1);
187
187
    }
188
188
    else
189
189
    {
190
190
      my_error(ER_ALTER_SCHEMA, schema_idenifier);
191
191
    }
192
192
  }
193
 
  session->startWaitingGlobalReadLock();
 
193
  session.startWaitingGlobalReadLock();
194
194
 
195
195
  return success;
196
196
}
213
213
    ERROR Error
214
214
*/
215
215
 
216
 
bool drop(Session *session, identifier::Schema &schema_identifier, const bool if_exists)
 
216
bool drop(Session &session, identifier::Schema &schema_identifier, const bool if_exists)
217
217
{
218
218
  bool error= false;
219
219
 
229
229
    has the global read lock and refuses the operation with
230
230
    ER_CANT_UPDATE_WITH_READLOCK if applicable.
231
231
  */
232
 
  if (session->wait_if_global_read_lock(false, true))
 
232
  if (session.wait_if_global_read_lock(false, true))
233
233
  {
234
234
    return true;
235
235
  }
236
236
 
237
237
  do
238
238
  {
239
 
    boost::mutex::scoped_lock scopedLock(session->catalog().schemaLock());
 
239
    boost::mutex::scoped_lock scopedLock(session.catalog().schemaLock());
240
240
 
241
241
    /* See if the schema exists */
242
242
    if (not plugin::StorageEngine::doesSchemaExist(schema_identifier))
246
246
        std::string path;
247
247
        schema_identifier.getSQLPath(path);
248
248
 
249
 
        push_warning_printf(session, DRIZZLE_ERROR::WARN_LEVEL_NOTE,
 
249
        push_warning_printf(&session, DRIZZLE_ERROR::WARN_LEVEL_NOTE,
250
250
                            ER_DB_DROP_EXISTS, ER(ER_DB_DROP_EXISTS),
251
251
                            path.c_str());
252
252
      }
259
259
    }
260
260
    else
261
261
    {
262
 
      error= plugin::StorageEngine::dropSchema(*session, schema_identifier);
 
262
      error= plugin::StorageEngine::dropSchema(session, schema_identifier);
263
263
    }
264
264
 
265
265
  } while (0);
270
270
    SELECT DATABASE() in the future). For this we free() session->db and set
271
271
    it to 0.
272
272
  */
273
 
  if (not error and schema_identifier.compare(*session->schema()))
 
273
  if (not error and schema_identifier.compare(*session.schema()))
274
274
    change_db_impl(session);
275
275
 
276
 
  session->startWaitingGlobalReadLock();
 
276
  session.startWaitingGlobalReadLock();
277
277
 
278
278
  return error;
279
279
}
340
340
    @retval true  Error
341
341
*/
342
342
 
343
 
bool change(Session *session, identifier::Schema &schema_identifier)
 
343
bool change(Session &session, identifier::Schema &schema_identifier)
344
344
{
345
345
 
346
 
  if (not plugin::Authorization::isAuthorized(session->user(), schema_identifier))
 
346
  if (not plugin::Authorization::isAuthorized(session.user(), schema_identifier))
347
347
  {
348
348
    /* Error message is set in isAuthorized */
349
349
    return true;
350
350
  }
351
351
 
352
 
  if (not check_db_name(session, schema_identifier))
 
352
  if (not check(session, schema_identifier))
353
353
  {
354
354
    my_error(ER_WRONG_DB_NAME, schema_identifier);
355
355
 
381
381
  @param new_db_charset Character set of the new database.
382
382
*/
383
383
 
384
 
static void change_db_impl(Session *session, identifier::Schema &schema_identifier)
 
384
static void change_db_impl(Session &session, identifier::Schema &schema_identifier)
385
385
{
386
386
  /* 1. Change current database in Session. */
387
387
 
404
404
      the previous database name, we should do it explicitly.
405
405
    */
406
406
 
407
 
    session->set_db(schema_identifier.getSchemaName());
408
 
  }
409
 
}
410
 
 
411
 
static void change_db_impl(Session *session)
412
 
{
413
 
  session->set_db(string());
 
407
    session.set_db(schema_identifier.getSchemaName());
 
408
  }
 
409
}
 
410
 
 
411
static void change_db_impl(Session &session)
 
412
{
 
413
  session.set_db(string());
 
414
}
 
415
 
 
416
/*
 
417
  Check if database name is valid
 
418
 
 
419
  SYNPOSIS
 
420
    check()
 
421
    org_name            Name of database and length
 
422
 
 
423
  RETURN
 
424
    false error
 
425
    true ok
 
426
*/
 
427
 
 
428
bool check(Session &session, identifier::Schema &schema_identifier)
 
429
{
 
430
  if (not plugin::Authorization::isAuthorized(session.user(), schema_identifier))
 
431
  {
 
432
    return false;
 
433
  }
 
434
 
 
435
  return schema_identifier.isValid();
414
436
}
415
437
 
416
438
} /* namespace schema */