← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to drizzled/db.cc

  • Committer: Stewart Smith
  • Date: 2011-01-14 05:15:23 UTC
  • mto: (2086.1.3 build)
  • mto: This revision was merged to the branch mainline in revision 2087.
  • Revision ID: stewart@flamingspork.com-20110114051523-n57f99sr3qzs9ijw
rearrange explanation of absence of old weird types in numeric data types doc to be after explanation of what we do have. I think it reads better that way

Show diffs side-by-side

added added

removed removed

Lines of Context:
drizzled/db.cc
15
15
 
16
16
 
17
17
/* create and drop of databases */
18
 
#include <config.h>
 
18
#include "config.h"
19
19
 
20
20
#include <fcntl.h>
21
21
#include <sys/stat.h>
25
25
#include <string>
26
26
#include <fstream>
27
27
 
28
 
#include <drizzled/error.h>
 
28
#include <drizzled/message/schema.pb.h>
 
29
#include "drizzled/error.h"
29
30
#include <drizzled/gettext.h>
30
31
#include <drizzled/my_hash.h>
31
 
#include <drizzled/internal/m_string.h>
 
32
#include "drizzled/internal/m_string.h"
32
33
#include <drizzled/session.h>
33
 
#include <drizzled/schema.h>
 
34
#include <drizzled/db.h>
34
35
#include <drizzled/sql_base.h>
35
36
#include <drizzled/lock.h>
36
37
#include <drizzled/errmsg_print.h>
37
38
#include <drizzled/transaction_services.h>
38
39
#include <drizzled/message/schema.pb.h>
39
 
#include <drizzled/sql_table.h>
40
 
#include <drizzled/plugin/storage_engine.h>
41
 
#include <drizzled/plugin/authorization.h>
42
 
#include <drizzled/global_charset_info.h>
43
 
#include <drizzled/pthread_globals.h>
44
 
#include <drizzled/charset.h>
45
 
#include <drizzled/internal/my_sys.h>
 
40
#include "drizzled/sql_table.h"
 
41
#include "drizzled/plugin/storage_engine.h"
 
42
#include "drizzled/plugin/authorization.h"
 
43
#include "drizzled/global_charset_info.h"
 
44
#include "drizzled/pthread_globals.h"
 
45
#include "drizzled/charset.h"
46
46
 
47
47
#include <boost/thread/mutex.hpp>
48
48
 
 
49
#include "drizzled/internal/my_sys.h"
 
50
 
49
51
#define MAX_DROP_TABLE_Q_LEN      1024
50
52
 
51
53
using namespace std;
53
55
namespace drizzled
54
56
{
55
57
 
56
 
namespace schema
57
 
{
58
 
 
59
 
static void change_db_impl(Session &session);
60
 
static void change_db_impl(Session &session, identifier::Schema &schema_identifier);
 
58
static void change_db_impl(Session *session);
 
59
static void change_db_impl(Session *session, SchemaIdentifier &schema_identifier);
61
60
 
62
61
/*
63
62
  Create a database
80
79
 
81
80
*/
82
81
 
83
 
bool create(Session &session, const message::Schema &schema_message, const bool is_if_not_exists)
 
82
bool create_db(Session *session, const message::Schema &schema_message, const bool is_if_not_exists)
84
83
{
85
84
  TransactionServices &transaction_services= TransactionServices::singleton();
86
85
  bool error= false;
97
96
    has the global read lock and refuses the operation with
98
97
    ER_CANT_UPDATE_WITH_READLOCK if applicable.
99
98
  */
100
 
  if (session.wait_if_global_read_lock(false, true))
 
99
  if (session->wait_if_global_read_lock(false, true))
101
100
  {
102
101
    return false;
103
102
  }
107
106
 
108
107
  // @todo push this lock down into the engine
109
108
  {
110
 
    boost::mutex::scoped_lock scopedLock(session.catalog().schemaLock());
 
109
    boost::mutex::scoped_lock scopedLock(session->catalog().schemaLock());
111
110
 
112
111
    // Check to see if it exists already.  
113
 
    identifier::Schema schema_identifier(schema_message.name());
 
112
    SchemaIdentifier schema_identifier(schema_message.name());
114
113
    if (plugin::StorageEngine::doesSchemaExist(schema_identifier))
115
114
    {
116
115
      if (not is_if_not_exists)
120
119
      }
121
120
      else
122
121
      {
123
 
        push_warning_printf(&session, DRIZZLE_ERROR::WARN_LEVEL_NOTE,
 
122
        push_warning_printf(session, DRIZZLE_ERROR::WARN_LEVEL_NOTE,
124
123
                            ER_DB_CREATE_EXISTS, ER(ER_DB_CREATE_EXISTS),
125
124
                            schema_message.name().c_str());
126
 
        session.my_ok();
 
125
        session->my_ok();
127
126
      }
128
127
    }
129
128
    else if (not plugin::StorageEngine::createSchema(schema_message)) // Try to create it 
134
133
    else // Created !
135
134
    {
136
135
      transaction_services.createSchema(session, schema_message);
137
 
      session.my_ok(1);
 
136
      session->my_ok(1);
138
137
    }
139
138
  }
140
 
  session.startWaitingGlobalReadLock();
 
139
  session->startWaitingGlobalReadLock();
141
140
 
142
141
  return error;
143
142
}
145
144
 
146
145
/* db-name is already validated when we come here */
147
146
 
148
 
bool alter(Session &session,
149
 
           const message::Schema &schema_message,
150
 
           const message::Schema &original_schema)
 
147
bool alter_db(Session *session, const message::Schema &schema_message)
151
148
{
152
149
  TransactionServices &transaction_services= TransactionServices::singleton();
153
150
 
163
160
    has the global read lock and refuses the operation with
164
161
    ER_CANT_UPDATE_WITH_READLOCK if applicable.
165
162
  */
166
 
  if ((session.wait_if_global_read_lock(false, true)))
 
163
  if ((session->wait_if_global_read_lock(false, true)))
167
164
    return false;
168
165
 
169
166
  bool success;
170
167
  {
171
 
    boost::mutex::scoped_lock scopedLock(session.catalog().schemaLock());
 
168
    boost::mutex::scoped_lock scopedLock(session->catalog().schemaLock());
172
169
 
173
 
    identifier::Schema schema_idenifier(schema_message.name());
 
170
    SchemaIdentifier schema_idenifier(schema_message.name());
174
171
    if (not plugin::StorageEngine::doesSchemaExist(schema_idenifier))
175
172
    {
176
173
      my_error(ER_SCHEMA_DOES_NOT_EXIST, schema_idenifier);
182
179
 
183
180
    if (success)
184
181
    {
185
 
      transaction_services.alterSchema(session, original_schema, schema_message);
186
 
      session.my_ok(1);
 
182
      transaction_services.rawStatement(session, *session->getQueryString());
 
183
      session->my_ok(1);
187
184
    }
188
185
    else
189
186
    {
190
187
      my_error(ER_ALTER_SCHEMA, schema_idenifier);
191
188
    }
192
189
  }
193
 
  session.startWaitingGlobalReadLock();
 
190
  session->startWaitingGlobalReadLock();
194
191
 
195
192
  return success;
196
193
}
213
210
    ERROR Error
214
211
*/
215
212
 
216
 
bool drop(Session &session, identifier::Schema &schema_identifier, const bool if_exists)
 
213
bool rm_db(Session *session, SchemaIdentifier &schema_identifier, const bool if_exists)
217
214
{
218
215
  bool error= false;
219
216
 
229
226
    has the global read lock and refuses the operation with
230
227
    ER_CANT_UPDATE_WITH_READLOCK if applicable.
231
228
  */
232
 
  if (session.wait_if_global_read_lock(false, true))
 
229
  if (session->wait_if_global_read_lock(false, true))
233
230
  {
234
231
    return true;
235
232
  }
236
233
 
237
234
  do
238
235
  {
239
 
    boost::mutex::scoped_lock scopedLock(session.catalog().schemaLock());
240
 
    message::schema::shared_ptr message= plugin::StorageEngine::getSchemaDefinition(schema_identifier);
 
236
    boost::mutex::scoped_lock scopedLock(session->catalog().schemaLock());
241
237
 
242
238
    /* See if the schema exists */
243
 
    if (not message)
 
239
    if (not plugin::StorageEngine::doesSchemaExist(schema_identifier))
244
240
    {
 
241
      std::string path;
 
242
      schema_identifier.getSQLPath(path);
 
243
 
245
244
      if (if_exists)
246
245
      {
247
 
        std::string path;
248
 
        schema_identifier.getSQLPath(path);
249
 
 
250
 
        push_warning_printf(&session, DRIZZLE_ERROR::WARN_LEVEL_NOTE,
 
246
        push_warning_printf(session, DRIZZLE_ERROR::WARN_LEVEL_NOTE,
251
247
                            ER_DB_DROP_EXISTS, ER(ER_DB_DROP_EXISTS),
252
248
                            path.c_str());
253
249
      }
260
256
    }
261
257
    else
262
258
    {
263
 
      error= plugin::StorageEngine::dropSchema(session, schema_identifier, *message);
 
259
      error= plugin::StorageEngine::dropSchema(*session, schema_identifier);
264
260
    }
265
261
 
266
262
  } while (0);
271
267
    SELECT DATABASE() in the future). For this we free() session->db and set
272
268
    it to 0.
273
269
  */
274
 
  if (not error and schema_identifier.compare(*session.schema()))
 
270
  if (not error and schema_identifier.compare(*session->schema()))
275
271
    change_db_impl(session);
276
272
 
277
 
  session.startWaitingGlobalReadLock();
 
273
  session->startWaitingGlobalReadLock();
278
274
 
279
275
  return error;
280
276
}
341
337
    @retval true  Error
342
338
*/
343
339
 
344
 
bool change(Session &session, identifier::Schema &schema_identifier)
 
340
bool change_db(Session *session, SchemaIdentifier &schema_identifier)
345
341
{
346
342
 
347
 
  if (not plugin::Authorization::isAuthorized(*session.user(), schema_identifier))
 
343
  if (not plugin::Authorization::isAuthorized(session->user(), schema_identifier))
348
344
  {
349
345
    /* Error message is set in isAuthorized */
350
346
    return true;
351
347
  }
352
348
 
353
 
  if (not check(session, schema_identifier))
 
349
  if (not check_db_name(session, schema_identifier))
354
350
  {
 
351
    std::string path;
 
352
    schema_identifier.getSQLPath(path);
355
353
    my_error(ER_WRONG_DB_NAME, schema_identifier);
356
354
 
357
355
    return true;
382
380
  @param new_db_charset Character set of the new database.
383
381
*/
384
382
 
385
 
static void change_db_impl(Session &session, identifier::Schema &schema_identifier)
 
383
static void change_db_impl(Session *session, SchemaIdentifier &schema_identifier)
386
384
{
387
385
  /* 1. Change current database in Session. */
388
386
 
405
403
      the previous database name, we should do it explicitly.
406
404
    */
407
405
 
408
 
    session.set_db(schema_identifier.getSchemaName());
409
 
  }
410
 
}
411
 
 
412
 
static void change_db_impl(Session &session)
413
 
{
414
 
  session.set_db(string());
415
 
}
416
 
 
417
 
/*
418
 
  Check if database name is valid
419
 
 
420
 
  SYNPOSIS
421
 
    check()
422
 
    org_name            Name of database and length
423
 
 
424
 
  RETURN
425
 
    false error
426
 
    true ok
427
 
*/
428
 
 
429
 
bool check(Session &session, identifier::Schema &schema_identifier)
430
 
{
431
 
  if (not plugin::Authorization::isAuthorized(*session.user(), schema_identifier))
432
 
  {
433
 
    return false;
434
 
  }
435
 
 
436
 
  return schema_identifier.isValid();
437
 
}
438
 
 
439
 
} /* namespace schema */
 
406
    session->set_db(schema_identifier.getSchemaName());
 
407
  }
 
408
}
 
409
 
 
410
static void change_db_impl(Session *session)
 
411
{
 
412
  session->set_db(string());
 
413
}
440
414
 
441
415
} /* namespace drizzled */