← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to drizzled/sql_parse.cc

  • Committer: Brian Aker
  • Date: 2009-11-12 16:13:04 UTC
  • mfrom: (1211.1.7 staging)
  • Revision ID: brian@gaz-20091112161304-opamiauv36fg0n6u
Rollup of Brian, Padraig, and Stewart patches.

Show diffs side-by-side

added added

removed removed

Lines of Context:
drizzled/sql_parse.cc
11
11
 
12
12
   You should have received a copy of the GNU General Public License
13
13
   along with this program; if not, write to the Free Software
14
 
   Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA */
15
 
 
16
 
#include "config.h"
 
14
   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA */
17
15
 
18
16
#define DRIZZLE_LEX 1
19
 
 
20
 
#include "drizzled/item/num.h"
21
 
#include "drizzled/abort_exception.h"
22
 
#include <drizzled/my_hash.h>
 
17
#include <drizzled/server_includes.h>
 
18
#include <mysys/hash.h>
 
19
#include <drizzled/db.h>
23
20
#include <drizzled/error.h>
24
21
#include <drizzled/nested_join.h>
25
22
#include <drizzled/query_id.h>
26
 
#include "drizzled/transaction_services.h"
27
23
#include <drizzled/sql_parse.h>
28
24
#include <drizzled/data_home.h>
29
25
#include <drizzled/sql_base.h>
30
26
#include <drizzled/show.h>
31
 
#include <drizzled/db.h>
 
27
#include <drizzled/plugin/info_schema_table.h>
32
28
#include <drizzled/function/time/unix_timestamp.h>
33
29
#include <drizzled/function/get_system_var.h>
34
30
#include <drizzled/item/cmpfunc.h>
35
31
#include <drizzled/item/null.h>
36
32
#include <drizzled/session.h>
37
 
#include <drizzled/session/cache.h>
38
33
#include <drizzled/sql_load.h>
39
34
#include <drizzled/lock.h>
40
35
#include <drizzled/select_send.h>
42
37
#include <drizzled/statement.h>
43
38
#include <drizzled/statement/alter_table.h>
44
39
#include "drizzled/probes.h"
45
 
#include "drizzled/global_charset_info.h"
46
40
 
47
41
#include "drizzled/plugin/logging.h"
48
 
#include "drizzled/plugin/query_rewrite.h"
49
 
#include "drizzled/plugin/query_cache.h"
50
 
#include "drizzled/plugin/authorization.h"
51
 
#include "drizzled/optimizer/explain_plan.h"
52
 
#include "drizzled/pthread_globals.h"
53
 
#include "drizzled/plugin/event_observer.h"
54
 
#include "drizzled/visibility.h"
55
 
 
56
 
#include <limits.h>
 
42
#include "drizzled/plugin/info_schema_table.h"
57
43
 
58
44
#include <bitset>
59
45
#include <algorithm>
60
 
#include <boost/date_time.hpp>
61
 
#include "drizzled/internal/my_sys.h"
62
46
 
 
47
using namespace drizzled;
63
48
using namespace std;
64
49
 
65
 
extern int DRIZZLEparse(void *session); // from sql_yacc.cc
66
 
 
67
 
namespace drizzled
68
 
{
69
 
 
70
50
/* Prototypes */
71
51
bool my_yyoverflow(short **a, YYSTYPE **b, ulong *yystacksize);
72
52
static bool parse_sql(Session *session, Lex_input_stream *lip);
73
 
void parse(Session *session, const char *inBuf, uint32_t length);
 
53
static void mysql_parse(Session *session, const char *inBuf, uint32_t length,
 
54
                 const char ** found_semicolon);
74
55
 
75
56
/**
76
57
  @defgroup Runtime_Environment Runtime Environment
79
60
 
80
61
extern size_t my_thread_stack_size;
81
62
extern const CHARSET_INFO *character_set_filesystem;
82
 
 
83
 
namespace
84
 
{
85
 
 
86
 
static const std::string command_name[COM_END+1]={
87
 
  "Sleep",
88
 
  "Quit",
89
 
  "Init DB",
90
 
  "Query",
91
 
  "Shutdown",
92
 
  "Connect",
93
 
  "Ping",
94
 
  "Error"  // Last command number
 
63
const char *any_db="*any*";     // Special symbol for check_access
 
64
 
 
65
const LEX_STRING command_name[COM_END+1]={
 
66
  { C_STRING_WITH_LEN("Sleep") },
 
67
  { C_STRING_WITH_LEN("Quit") },
 
68
  { C_STRING_WITH_LEN("Init DB") },
 
69
  { C_STRING_WITH_LEN("Query") },
 
70
  { C_STRING_WITH_LEN("Shutdown") },
 
71
  { C_STRING_WITH_LEN("Connect") },
 
72
  { C_STRING_WITH_LEN("Ping") },
 
73
  { C_STRING_WITH_LEN("Error") }  // Last command number
95
74
};
96
75
 
97
 
}
98
 
 
99
76
const char *xa_state_names[]={
100
77
  "NON-EXISTING", "ACTIVE", "IDLE", "PREPARED"
101
78
};
114
91
*/
115
92
bitset<CF_BIT_SIZE> sql_command_flags[SQLCOM_END+1];
116
93
 
117
 
const std::string &getCommandName(const enum_server_command& command)
118
 
{
119
 
  return command_name[command];
120
 
}
121
 
 
122
94
void init_update_queries(void)
123
95
{
124
96
  uint32_t x;
144
116
  sql_command_flags[SQLCOM_REPLACE]=        CF_CHANGES_DATA | CF_HAS_ROW_COUNT;
145
117
  sql_command_flags[SQLCOM_REPLACE_SELECT]= CF_CHANGES_DATA | CF_HAS_ROW_COUNT;
146
118
 
 
119
  sql_command_flags[SQLCOM_SHOW_STATUS]=      CF_STATUS_COMMAND;
 
120
  sql_command_flags[SQLCOM_SHOW_DATABASES]=   CF_STATUS_COMMAND;
 
121
  sql_command_flags[SQLCOM_SHOW_OPEN_TABLES]= CF_STATUS_COMMAND;
 
122
  sql_command_flags[SQLCOM_SHOW_FIELDS]=      CF_STATUS_COMMAND;
 
123
  sql_command_flags[SQLCOM_SHOW_KEYS]=        CF_STATUS_COMMAND;
 
124
  sql_command_flags[SQLCOM_SHOW_VARIABLES]=   CF_STATUS_COMMAND;
147
125
  sql_command_flags[SQLCOM_SHOW_WARNS]= CF_STATUS_COMMAND;
148
126
  sql_command_flags[SQLCOM_SHOW_ERRORS]= CF_STATUS_COMMAND;
 
127
  sql_command_flags[SQLCOM_SHOW_ENGINE_STATUS]= CF_STATUS_COMMAND;
 
128
  sql_command_flags[SQLCOM_SHOW_PROCESSLIST]= CF_STATUS_COMMAND;
149
129
  sql_command_flags[SQLCOM_SHOW_CREATE_DB]=  CF_STATUS_COMMAND;
150
130
  sql_command_flags[SQLCOM_SHOW_CREATE]=  CF_STATUS_COMMAND;
151
131
 
 
132
   sql_command_flags[SQLCOM_SHOW_TABLES]=       (CF_STATUS_COMMAND |
 
133
                                               CF_SHOW_TABLE_COMMAND);
 
134
  sql_command_flags[SQLCOM_SHOW_TABLE_STATUS]= (CF_STATUS_COMMAND |
 
135
                                                CF_SHOW_TABLE_COMMAND);
152
136
  /*
153
137
    The following admin table operations are allowed
154
138
    on log tables.
155
139
  */
 
140
  sql_command_flags[SQLCOM_OPTIMIZE]=         CF_WRITE_LOGS_COMMAND;
156
141
  sql_command_flags[SQLCOM_ANALYZE]=          CF_WRITE_LOGS_COMMAND;
157
142
}
158
143
 
183
168
  bool error= 0;
184
169
  Query_id &query_id= Query_id::get_query_id();
185
170
 
186
 
  DRIZZLE_COMMAND_START(session->thread_id, command);
 
171
  DRIZZLE_COMMAND_START(session->thread_id,
 
172
                        command);
187
173
 
188
174
  session->command= command;
189
175
  session->lex->sql_command= SQLCOM_END; /* to avoid confusing VIEW detectors */
190
176
  session->set_time();
191
 
  session->setQueryId(query_id.value());
 
177
  session->query_id= query_id.value();
192
178
 
193
179
  switch( command ) {
194
180
  /* Ignore these statements. */
196
182
    break;
197
183
  /* Increase id and count all other statements. */
198
184
  default:
199
 
    session->status_var.questions++;
 
185
    statistic_increment(session->status_var.questions, &LOCK_status);
200
186
    query_id.next();
201
187
  }
202
188
 
203
 
  /* @todo set session->lex->sql_command to SQLCOM_END here */
 
189
  /* TODO: set session->lex->sql_command to SQLCOM_END here */
204
190
 
205
191
  plugin::Logging::preDo(session);
206
 
  if (unlikely(plugin::EventObserver::beforeStatement(*session)))
207
 
  {
208
 
    // We should do something about an error...
209
 
  }
210
192
 
211
193
  session->server_status&=
212
194
           ~(SERVER_QUERY_NO_INDEX_USED | SERVER_QUERY_NO_GOOD_INDEX_USED);
213
195
  switch (command) {
214
196
  case COM_INIT_DB:
215
197
  {
216
 
    if (packet_length == 0)
217
 
    {
218
 
      my_message(ER_NO_DB_ERROR, ER(ER_NO_DB_ERROR), MYF(0));
219
 
      break;
220
 
    }
221
 
 
222
 
    string tmp(packet, packet_length);
223
 
 
224
 
    identifier::Schema identifier(tmp);
225
 
 
226
 
    if (not change_db(session, identifier))
 
198
    LEX_STRING tmp;
 
199
    status_var_increment(session->status_var.com_stat[SQLCOM_CHANGE_DB]);
 
200
    tmp.str= packet;
 
201
    tmp.length= packet_length;
 
202
    if (!mysql_change_db(session, &tmp, false))
227
203
    {
228
204
      session->my_ok();
229
205
    }
231
207
  }
232
208
  case COM_QUERY:
233
209
  {
234
 
    if (not session->readAndStoreQuery(packet, packet_length))
 
210
    if (! session->readAndStoreQuery(packet, packet_length))
235
211
      break;                                    // fatal error is set
236
 
    DRIZZLE_QUERY_START(session->getQueryString()->c_str(),
 
212
    DRIZZLE_QUERY_START(session->query,
237
213
                        session->thread_id,
238
 
                        const_cast<const char *>(session->schema()->c_str()));
 
214
                        const_cast<const char *>(session->db ? session->db : ""));
 
215
    const char* end_of_stmt= NULL;
239
216
 
240
 
    parse(session, session->getQueryString()->c_str(), session->getQueryString()->length());
 
217
    mysql_parse(session, session->query, session->query_length, &end_of_stmt);
241
218
 
242
219
    break;
243
220
  }
248
225
    break;
249
226
  case COM_SHUTDOWN:
250
227
  {
251
 
    session->status_var.com_other++;
 
228
    status_var_increment(session->status_var.com_other);
252
229
    session->my_eof();
253
230
    session->close_thread_tables();                     // Free before kill
254
231
    kill_drizzle();
256
233
    break;
257
234
  }
258
235
  case COM_PING:
259
 
    session->status_var.com_other++;
 
236
    status_var_increment(session->status_var.com_other);
260
237
    session->my_ok();                           // Tell client we are alive
261
238
    break;
262
239
  case COM_SLEEP:
269
246
 
270
247
  /* If commit fails, we should be able to reset the OK status. */
271
248
  session->main_da.can_overwrite_status= true;
272
 
  TransactionServices &transaction_services= TransactionServices::singleton();
273
 
  transaction_services.autocommitOrRollback(*session, session->is_error());
 
249
  ha_autocommit_or_rollback(session, session->is_error());
274
250
  session->main_da.can_overwrite_status= false;
275
251
 
276
252
  session->transaction.stmt.reset();
282
258
    if (! session->main_da.is_set())
283
259
      session->send_kill_message();
284
260
  }
285
 
  if (session->getKilled() == Session::KILL_QUERY || session->getKilled() == Session::KILL_BAD_DATA)
 
261
  if (session->killed == Session::KILL_QUERY || session->killed == Session::KILL_BAD_DATA)
286
262
  {
287
 
    session->setKilled(Session::NOT_KILLED);
288
 
    session->setAbort(false);
 
263
    session->killed= Session::NOT_KILLED;
 
264
    session->mysys_var->abort= 0;
289
265
  }
290
266
 
291
267
  /* Can not be true, but do not take chances in production. */
295
271
  {
296
272
  case Diagnostics_area::DA_ERROR:
297
273
    /* The query failed, send error to log and abort bootstrap. */
298
 
    session->getClient()->sendError(session->main_da.sql_errno(),
 
274
    session->client->sendError(session->main_da.sql_errno(),
299
275
                               session->main_da.message());
300
276
    break;
301
277
 
302
278
  case Diagnostics_area::DA_EOF:
303
 
    session->getClient()->sendEOF();
 
279
    session->client->sendEOF();
304
280
    break;
305
281
 
306
282
  case Diagnostics_area::DA_OK:
307
 
    session->getClient()->sendOK();
 
283
    session->client->sendOK();
308
284
    break;
309
285
 
310
286
  case Diagnostics_area::DA_DISABLED:
312
288
 
313
289
  case Diagnostics_area::DA_EMPTY:
314
290
  default:
315
 
    session->getClient()->sendOK();
 
291
    session->client->sendOK();
316
292
    break;
317
293
  }
318
294
 
323
299
  session->close_thread_tables();
324
300
 
325
301
  plugin::Logging::postDo(session);
326
 
  if (unlikely(plugin::EventObserver::afterStatement(*session)))
327
 
  {
328
 
    // We should do something about an error...
329
 
  }
330
302
 
331
303
  /* Store temp state for processlist */
332
304
  session->set_proc_info("cleaning up");
333
305
  session->command= COM_SLEEP;
334
 
  session->resetQueryString();
 
306
  memset(session->process_list_info, 0, PROCESS_LIST_WIDTH);
 
307
  session->query= 0;
 
308
  session->query_length= 0;
335
309
 
336
310
  session->set_proc_info(NULL);
337
 
  session->mem_root->free_root(MYF(memory::KEEP_PREALLOC));
 
311
  free_root(session->mem_root,MYF(MY_KEEP_PREALLOC));
338
312
 
339
313
  if (DRIZZLE_QUERY_DONE_ENABLED() || DRIZZLE_COMMAND_DONE_ENABLED())
340
314
  {
374
348
    1                 out of memory or SHOW commands are not allowed
375
349
                      in this version of the server.
376
350
*/
377
 
static bool _schema_select(Session *session, Select_Lex *sel,
378
 
                           const string& schema_table_name)
379
 
{
380
 
  LEX_STRING db, table;
381
 
  bitset<NUM_OF_TABLE_OPTIONS> table_options;
382
 
  /*
383
 
     We have to make non const db_name & table_name
384
 
     because of lower_case_table_names
385
 
  */
386
 
  session->make_lex_string(&db, "data_dictionary", sizeof("data_dictionary"), false);
387
 
  session->make_lex_string(&table, schema_table_name, false);
388
 
 
389
 
  if (! sel->add_table_to_list(session, new Table_ident(db, table),
390
 
                               NULL, table_options, TL_READ))
391
 
  {
392
 
    return true;
393
 
  }
394
 
  return false;
395
 
}
396
 
 
397
 
int prepare_new_schema_table(Session *session, LEX *lex,
398
 
                             const string& schema_table_name)
 
351
 
 
352
int prepare_schema_table(Session *session, LEX *lex, Table_ident *table_ident,
 
353
                         const string& schema_table_name)
399
354
{
400
355
  Select_Lex *schema_select_lex= NULL;
401
356
 
 
357
 
 
358
  if (schema_table_name.compare("TABLES") == 0 ||
 
359
      schema_table_name.compare("TABLE_NAMES") == 0)
 
360
  {
 
361
    LEX_STRING db;
 
362
    size_t dummy;
 
363
    if (lex->select_lex.db == NULL &&
 
364
        lex->copy_db_to(&lex->select_lex.db, &dummy))
 
365
    {
 
366
      return (1);
 
367
    }
 
368
    schema_select_lex= new Select_Lex();
 
369
    db.str= schema_select_lex->db= lex->select_lex.db;
 
370
    schema_select_lex->table_list.first= NULL;
 
371
    db.length= strlen(db.str);
 
372
 
 
373
    if (check_db_name(&db))
 
374
    {
 
375
      my_error(ER_WRONG_DB_NAME, MYF(0), db.str);
 
376
      return (1);
 
377
    }
 
378
  }
 
379
  else if (schema_table_name.compare("COLUMNS") == 0 ||
 
380
           schema_table_name.compare("STATISTICS") == 0)
 
381
  {
 
382
    assert(table_ident);
 
383
    TableList **query_tables_last= lex->query_tables_last;
 
384
    schema_select_lex= new Select_Lex();
 
385
    /* 'parent_lex' is used in init_query() so it must be before it. */
 
386
    schema_select_lex->parent_lex= lex;
 
387
    schema_select_lex->init_query();
 
388
    if (! schema_select_lex->add_table_to_list(session, table_ident, 0, 0, TL_READ))
 
389
    {
 
390
      return (1);
 
391
    }
 
392
    lex->query_tables_last= query_tables_last;
 
393
  }
 
394
 
402
395
  Select_Lex *select_lex= lex->current_select;
403
396
  assert(select_lex);
404
 
  if (_schema_select(session, select_lex, schema_table_name))
 
397
  if (make_schema_select(session, select_lex, schema_table_name))
405
398
  {
406
399
    return(1);
407
400
  }
442
435
    true        Error
443
436
*/
444
437
 
445
 
static int execute_command(Session *session)
 
438
static int
 
439
mysql_execute_command(Session *session)
446
440
{
447
441
  bool res= false;
448
442
  LEX  *lex= session->lex;
450
444
  Select_Lex *select_lex= &lex->select_lex;
451
445
  /* list of all tables in query */
452
446
  TableList *all_tables;
 
447
  /* A peek into the query string */
 
448
  size_t proc_info_len= session->query_length > PROCESS_LIST_WIDTH ?
 
449
                        PROCESS_LIST_WIDTH : session->query_length;
 
450
 
 
451
  memcpy(session->process_list_info, session->query, proc_info_len);
 
452
  session->process_list_info[proc_info_len]= '\0';
453
453
 
454
454
  /*
455
455
    In many cases first table of main Select_Lex have special meaning =>
486
486
    drizzle_reset_errors(session, 0);
487
487
  }
488
488
 
489
 
  assert(session->transaction.stmt.hasModifiedNonTransData() == false);
 
489
  status_var_increment(session->status_var.com_stat[lex->sql_command]);
490
490
 
491
 
  if (! (session->server_status & SERVER_STATUS_AUTOCOMMIT)
492
 
      && ! session->inTransaction()
493
 
      && lex->statement->isTransactional())
494
 
  {
495
 
    if (session->startTransaction() == false)
496
 
    {
497
 
      my_error(drizzled::ER_UNKNOWN_ERROR, MYF(0));
498
 
      return true;
499
 
    }
500
 
  }
 
491
  assert(session->transaction.stmt.modified_non_trans_table == false);
501
492
 
502
493
  /* now we are ready to execute the statement */
503
494
  res= lex->statement->execute();
 
495
 
504
496
  session->set_proc_info("query end");
 
497
 
505
498
  /*
506
499
    The return value for ROW_COUNT() is "implementation dependent" if the
507
500
    statement is not DELETE, INSERT or UPDATE, but -1 is what JDBC and ODBC
515
508
 
516
509
  return (res || session->is_error());
517
510
}
 
511
 
518
512
bool execute_sqlcom_select(Session *session, TableList *all_tables)
519
513
{
520
514
  LEX   *lex= session->lex;
527
521
      param->select_limit=
528
522
        new Item_int((uint64_t) session->variables.select_limit);
529
523
  }
530
 
 
531
 
  if (all_tables
532
 
      && ! (session->server_status & SERVER_STATUS_AUTOCOMMIT)
533
 
      && ! session->inTransaction()
534
 
      && ! lex->statement->isShow())
535
 
  {
536
 
    if (session->startTransaction() == false)
537
 
    {
538
 
      my_error(drizzled::ER_UNKNOWN_ERROR, MYF(0));
539
 
      return true;
540
 
    }
541
 
  }
542
 
 
543
 
  if (not (res= session->openTablesLock(all_tables)))
 
524
  if (!(res= session->openTablesLock(all_tables)))
544
525
  {
545
526
    if (lex->describe)
546
527
    {
553
534
      if (!(result= new select_send()))
554
535
        return true;
555
536
      session->send_explain_fields(result);
556
 
      optimizer::ExplainPlan planner;
557
 
      res= planner.explainUnion(session, &session->lex->unit, result);
 
537
      res= mysql_explain_union(session, &session->lex->unit, result);
558
538
      if (lex->describe & DESCRIBE_EXTENDED)
559
539
      {
560
540
        char buff[1024];
575
555
    {
576
556
      if (!result && !(result= new select_send()))
577
557
        return true;
578
 
 
579
 
      /* Init the Query Cache plugin */
580
 
      plugin::QueryCache::prepareResultset(session); 
581
558
      res= handle_select(session, lex, result, 0);
582
 
      /* Send the Resultset to the cache */
583
 
      plugin::QueryCache::setResultset(session); 
584
 
 
585
559
      if (result != lex->result)
586
560
        delete result;
587
561
    }
624
598
 
625
599
 
626
600
void
627
 
init_select(LEX *lex)
 
601
mysql_init_select(LEX *lex)
628
602
{
629
603
  Select_Lex *select_lex= lex->current_select;
630
604
  select_lex->init_select();
638
612
 
639
613
 
640
614
bool
641
 
new_select(LEX *lex, bool move_down)
 
615
mysql_new_select(LEX *lex, bool move_down)
642
616
{
643
617
  Select_Lex *select_lex;
644
618
  Session *session= lex->session;
645
619
 
646
620
  if (!(select_lex= new (session->mem_root) Select_Lex()))
647
 
    return true;
648
 
 
 
621
    return(1);
649
622
  select_lex->select_number= ++session->select_number;
650
623
  select_lex->parent_lex= lex; /* Used in init_query. */
651
624
  select_lex->init_query();
652
625
  select_lex->init_select();
653
626
  lex->nest_level++;
654
 
 
655
627
  if (lex->nest_level > (int) MAX_SELECT_NESTING)
656
628
  {
657
629
    my_error(ER_TOO_HIGH_LEVEL_OF_NESTING_FOR_SELECT,MYF(0),MAX_SELECT_NESTING);
658
630
    return(1);
659
631
  }
660
 
 
661
632
  select_lex->nest_level= lex->nest_level;
662
633
  if (move_down)
663
634
  {
685
656
    if (lex->current_select->order_list.first && !lex->current_select->braces)
686
657
    {
687
658
      my_error(ER_WRONG_USAGE, MYF(0), "UNION", "order_st BY");
688
 
      return true;
 
659
      return(1);
689
660
    }
690
 
 
691
661
    select_lex->include_neighbour(lex->current_select);
692
662
    Select_Lex_Unit *unit= select_lex->master_unit();
693
 
 
694
 
    if (not unit->fake_select_lex && unit->add_fake_select_lex(lex->session))
695
 
      return true;
696
 
 
 
663
    if (!unit->fake_select_lex && unit->add_fake_select_lex(lex->session))
 
664
      return(1);
697
665
    select_lex->context.outer_context=
698
666
                unit->first_select()->context.outer_context;
699
667
  }
706
674
    list
707
675
  */
708
676
  select_lex->context.resolve_in_select_list= true;
709
 
 
710
 
  return false;
 
677
  return(0);
711
678
}
712
679
 
713
680
/**
720
687
  @param var_name               Variable name
721
688
*/
722
689
 
723
 
void create_select_for_variable(Session *session, const char *var_name)
 
690
void create_select_for_variable(const char *var_name)
724
691
{
 
692
  Session *session;
725
693
  LEX *lex;
726
694
  LEX_STRING tmp, null_lex_string;
727
695
  Item *var;
728
696
  char buff[MAX_SYS_VAR_LENGTH*2+4+8];
729
697
  char *end= buff;
730
698
 
 
699
  session= current_session;
731
700
  lex= session->lex;
732
 
  init_select(lex);
 
701
  mysql_init_select(lex);
733
702
  lex->sql_command= SQLCOM_SELECT;
734
703
  tmp.str= (char*) var_name;
735
704
  tmp.length=strlen(var_name);
740
709
  */
741
710
  if ((var= get_system_var(session, OPT_SESSION, tmp, null_lex_string)))
742
711
  {
743
 
    end+= snprintf(buff, sizeof(buff), "@@session.%s", var_name);
 
712
    end+= sprintf(buff, "@@session.%s", var_name);
744
713
    var->set_name(buff, end-buff, system_charset_info);
745
714
    session->add_item_to_list(var);
746
715
  }
 
716
  return;
747
717
}
748
718
 
749
719
 
753
723
  @param       session     Current thread
754
724
  @param       inBuf   Begining of the query text
755
725
  @param       length  Length of the query text
 
726
  @param[out]  found_semicolon For multi queries, position of the character of
 
727
                               the next query in the query text.
756
728
*/
757
729
 
758
 
void parse(Session *session, const char *inBuf, uint32_t length)
 
730
static void mysql_parse(Session *session, const char *inBuf, uint32_t length,
 
731
                 const char ** found_semicolon)
759
732
{
760
 
  session->lex->start(session);
761
 
 
 
733
  /*
 
734
    Warning.
 
735
    The purpose of query_cache_send_result_to_client() is to lookup the
 
736
    query in the query cache first, to avoid parsing and executing it.
 
737
    So, the natural implementation would be to:
 
738
    - first, call query_cache_send_result_to_client,
 
739
    - second, if caching failed, initialise the lexical and syntactic parser.
 
740
    The problem is that the query cache depends on a clean initialization
 
741
    of (among others) lex->safe_to_cache_query and session->server_status,
 
742
    which are reset respectively in
 
743
    - lex_start()
 
744
    - mysql_reset_session_for_next_command()
 
745
    So, initializing the lexical analyser *before* using the query cache
 
746
    is required for the cache to work properly.
 
747
    FIXME: cleanup the dependencies in the code to simplify this.
 
748
  */
 
749
  lex_start(session);
762
750
  session->reset_for_next_command();
763
 
  /* Check if the Query is Cached if and return true if yes
764
 
   * TODO the plugin has to make sure that the query is cacheble
765
 
   * by setting the query_safe_cache param to TRUE
766
 
   */
767
 
  bool res= true;
768
 
  if (plugin::QueryCache::isCached(session))
769
 
  {
770
 
    res= plugin::QueryCache::sendCachedResultset(session);
771
 
  }
772
 
  if (not res)
773
 
  {
774
 
    return;
775
 
  }
776
 
  LEX *lex= session->lex;
777
 
  Lex_input_stream lip(session, inBuf, length);
778
 
  bool err= parse_sql(session, &lip);
779
 
  if (!err)
780
 
  {
 
751
 
 
752
  {
 
753
    LEX *lex= session->lex;
 
754
 
 
755
    Lex_input_stream lip(session, inBuf, length);
 
756
 
 
757
    bool err= parse_sql(session, &lip);
 
758
    *found_semicolon= lip.found_semicolon;
 
759
 
 
760
    if (!err)
781
761
    {
782
 
      if (not session->is_error())
783
762
      {
784
 
        DRIZZLE_QUERY_EXEC_START(session->getQueryString()->c_str(),
785
 
                                 session->thread_id,
786
 
                                 const_cast<const char *>(session->schema()->c_str()));
787
 
        // Implement Views here --Brian
788
 
        /* Actually execute the query */
789
 
        try 
790
 
        {
791
 
          execute_command(session);
792
 
        }
793
 
        catch (...)
794
 
        {
795
 
          // Just try to catch any random failures that could have come
796
 
          // during execution.
797
 
          DRIZZLE_ABORT;
798
 
        }
799
 
        DRIZZLE_QUERY_EXEC_DONE(0);
 
763
        if (! session->is_error())
 
764
        {
 
765
          /*
 
766
            Binlog logs a string starting from session->query and having length
 
767
            session->query_length; so we set session->query_length correctly (to not
 
768
            log several statements in one event, when we executed only first).
 
769
            We set it to not see the ';' (otherwise it would get into binlog
 
770
            and Query_log_event::print() would give ';;' output).
 
771
            This also helps display only the current query in SHOW
 
772
            PROCESSLIST.
 
773
            Note that we don't need LOCK_thread_count to modify query_length.
 
774
          */
 
775
          if (*found_semicolon &&
 
776
              (session->query_length= (ulong)(*found_semicolon - session->query)))
 
777
            session->query_length--;
 
778
          DRIZZLE_QUERY_EXEC_START(session->query,
 
779
                                   session->thread_id,
 
780
                                   const_cast<const char *>(session->db ? session->db : ""));
 
781
          /* Actually execute the query */
 
782
          mysql_execute_command(session);
 
783
          DRIZZLE_QUERY_EXEC_DONE(0);
 
784
        }
800
785
      }
801
786
    }
802
 
  }
803
 
  else
804
 
  {
805
 
    assert(session->is_error());
806
 
  }
807
 
  lex->unit.cleanup();
808
 
  session->set_proc_info("freeing items");
809
 
  session->end_statement();
810
 
  session->cleanup_after_query();
811
 
  session->set_end_timer();
 
787
    else
 
788
    {
 
789
      assert(session->is_error());
 
790
    }
 
791
    lex->unit.cleanup();
 
792
    session->set_proc_info("freeing items");
 
793
    session->end_statement();
 
794
    session->cleanup_after_query();
 
795
  }
 
796
 
 
797
  return;
812
798
}
813
799
 
814
800
 
831
817
{
832
818
  register CreateField *new_field;
833
819
  LEX  *lex= session->lex;
834
 
  statement::AlterTable *statement= (statement::AlterTable *)lex->statement;
 
820
  drizzled::statement::AlterTable *statement= (drizzled::statement::AlterTable *)lex->statement;
835
821
 
836
822
  if (check_identifier_name(field_name, ER_TOO_LONG_IDENT))
837
823
    return true;
868
854
    */
869
855
    if (default_value->type() == Item::FUNC_ITEM &&
870
856
        !(((Item_func*)default_value)->functype() == Item_func::NOW_FUNC &&
871
 
         (type == DRIZZLE_TYPE_TIMESTAMP or type == DRIZZLE_TYPE_MICROTIME)))
 
857
         type == DRIZZLE_TYPE_TIMESTAMP))
872
858
    {
873
859
      my_error(ER_INVALID_DEFAULT, MYF(0), field_name->str);
874
860
      return true;
876
862
    else if (default_value->type() == Item::NULL_ITEM)
877
863
    {
878
864
      default_value= 0;
879
 
      if ((type_modifier & (NOT_NULL_FLAG | AUTO_INCREMENT_FLAG)) == NOT_NULL_FLAG)
 
865
      if ((type_modifier & (NOT_NULL_FLAG | AUTO_INCREMENT_FLAG)) ==
 
866
          NOT_NULL_FLAG)
880
867
      {
881
868
        my_error(ER_INVALID_DEFAULT, MYF(0), field_name->str);
882
869
        return true;
889
876
    }
890
877
  }
891
878
 
892
 
  if (on_update_value && (type != DRIZZLE_TYPE_TIMESTAMP and type != DRIZZLE_TYPE_MICROTIME))
 
879
  if (on_update_value && type != DRIZZLE_TYPE_TIMESTAMP)
893
880
  {
894
881
    my_error(ER_INVALID_ON_UPDATE, MYF(0), field_name->str);
895
882
    return true;
908
895
}
909
896
 
910
897
 
 
898
/** Store position for column in ALTER TABLE .. ADD column. */
 
899
 
 
900
void store_position_for_column(const char *name)
 
901
{
 
902
  current_session->lex->last_field->after=const_cast<char*> (name);
 
903
}
 
904
 
911
905
/**
912
906
  Add a table to list of used tables.
913
907
 
928
922
*/
929
923
 
930
924
TableList *Select_Lex::add_table_to_list(Session *session,
931
 
                                         Table_ident *table,
932
 
                                         LEX_STRING *alias,
933
 
                                         const bitset<NUM_OF_TABLE_OPTIONS>& table_options,
934
 
                                         thr_lock_type lock_type,
935
 
                                         List<Index_hint> *index_hints_arg,
936
 
                                         LEX_STRING *option)
 
925
                                             Table_ident *table,
 
926
                                             LEX_STRING *alias,
 
927
                                             uint32_t table_options,
 
928
                                             thr_lock_type lock_type,
 
929
                                             List<Index_hint> *index_hints_arg,
 
930
                                             LEX_STRING *option)
937
931
{
938
 
  TableList *ptr;
 
932
  register TableList *ptr;
939
933
  TableList *previous_table_ref; /* The table preceding the current one. */
940
934
  char *alias_str;
941
935
  LEX *lex= session->lex;
943
937
  if (!table)
944
938
    return NULL;                                // End of memory
945
939
  alias_str= alias ? alias->str : table->table.str;
946
 
  if (! table_options.test(TL_OPTION_ALIAS) &&
 
940
  if (!test(table_options & TL_OPTION_ALIAS) &&
947
941
      check_table_name(table->table.str, table->table.length))
948
942
  {
949
943
    my_error(ER_WRONG_TABLE_NAME, MYF(0), table->table.str);
950
944
    return NULL;
951
945
  }
952
946
 
953
 
  if (table->is_derived_table() == false && table->db.str)
 
947
  if (table->is_derived_table() == false && table->db.str &&
 
948
      check_db_name(&table->db))
954
949
  {
955
 
    my_casedn_str(files_charset_info, table->db.str);
956
 
 
957
 
    identifier::Schema schema_identifier(string(table->db.str));
958
 
    if (not check_db_name(session, schema_identifier))
959
 
    {
960
 
 
961
 
      my_error(ER_WRONG_DB_NAME, MYF(0), table->db.str);
962
 
      return NULL;
963
 
    }
 
950
    my_error(ER_WRONG_DB_NAME, MYF(0), table->db.str);
 
951
    return NULL;
964
952
  }
965
953
 
966
954
  if (!alias)                                   /* Alias is case sensitive */
971
959
                 ER(ER_DERIVED_MUST_HAVE_ALIAS), MYF(0));
972
960
      return NULL;
973
961
    }
974
 
    if (!(alias_str= (char*) session->getMemRoot()->duplicate(alias_str,table->table.length+1)))
 
962
    if (!(alias_str= (char*) session->memdup(alias_str,table->table.length+1)))
975
963
      return NULL;
976
964
  }
977
965
  if (!(ptr = (TableList *) session->calloc(sizeof(TableList))))
978
966
    return NULL;
979
 
 
980
967
  if (table->db.str)
981
968
  {
982
 
    ptr->setIsFqtn(true);
983
 
    ptr->setSchemaName(table->db.str);
 
969
    ptr->is_fqtn= true;
 
970
    ptr->db= table->db.str;
984
971
    ptr->db_length= table->db.length;
985
972
  }
986
 
  else if (lex->copy_db_to(ptr->getSchemaNamePtr(), &ptr->db_length))
 
973
  else if (lex->copy_db_to(&ptr->db, &ptr->db_length))
987
974
    return NULL;
988
975
  else
989
 
    ptr->setIsFqtn(false);
 
976
    ptr->is_fqtn= false;
990
977
 
991
978
  ptr->alias= alias_str;
992
 
  ptr->setIsAlias(alias ? true : false);
993
 
  ptr->setTableName(table->table.str);
 
979
  ptr->is_alias= alias ? true : false;
 
980
  if (table->table.length)
 
981
    table->table.length= my_casedn_str(files_charset_info, table->table.str);
 
982
  ptr->table_name=table->table.str;
994
983
  ptr->table_name_length=table->table.length;
995
984
  ptr->lock_type=   lock_type;
996
 
  ptr->force_index= table_options.test(TL_OPTION_FORCE_INDEX);
997
 
  ptr->ignore_leaves= table_options.test(TL_OPTION_IGNORE_LEAVES);
 
985
  ptr->updating=    test(table_options & TL_OPTION_UPDATING);
 
986
  ptr->force_index= test(table_options & TL_OPTION_FORCE_INDEX);
 
987
  ptr->ignore_leaves= test(table_options & TL_OPTION_IGNORE_LEAVES);
998
988
  ptr->derived=     table->sel;
 
989
  if (!ptr->derived && !my_strcasecmp(system_charset_info, ptr->db,
 
990
                                      INFORMATION_SCHEMA_NAME.c_str()))
 
991
  {
 
992
    plugin::InfoSchemaTable *schema_table= plugin::InfoSchemaTable::getTable(ptr->table_name);
 
993
    if (!schema_table ||
 
994
        (schema_table->isHidden() &&
 
995
         ((sql_command_flags[lex->sql_command].test(CF_BIT_STATUS_COMMAND)) == 0 ||
 
996
          /*
 
997
            this check is used for show columns|keys from I_S hidden table
 
998
          */
 
999
          lex->sql_command == SQLCOM_SHOW_FIELDS ||
 
1000
          lex->sql_command == SQLCOM_SHOW_KEYS)))
 
1001
    {
 
1002
      my_error(ER_UNKNOWN_TABLE, MYF(0),
 
1003
               ptr->table_name, INFORMATION_SCHEMA_NAME.c_str());
 
1004
      return NULL;
 
1005
    }
 
1006
    ptr->schema_table_name= ptr->table_name;
 
1007
    ptr->schema_table= schema_table;
 
1008
  }
999
1009
  ptr->select_lex=  lex->current_select;
1000
1010
  ptr->index_hints= index_hints_arg;
1001
1011
  ptr->option= option ? option->str : 0;
1007
1017
         tables ;
1008
1018
         tables=tables->next_local)
1009
1019
    {
1010
 
      if (not my_strcasecmp(table_alias_charset, alias_str, tables->alias) &&
1011
 
          not my_strcasecmp(system_charset_info, ptr->getSchemaName(), tables->getSchemaName()))
 
1020
      if (!my_strcasecmp(table_alias_charset, alias_str, tables->alias) &&
 
1021
          !strcmp(ptr->db, tables->db))
1012
1022
      {
1013
1023
        my_error(ER_NONUNIQ_TABLE, MYF(0), alias_str);
1014
1024
        return NULL;
1072
1082
bool Select_Lex::init_nested_join(Session *session)
1073
1083
{
1074
1084
  TableList *ptr;
1075
 
  NestedJoin *nested_join;
 
1085
  nested_join_st *nested_join;
1076
1086
 
1077
1087
  if (!(ptr= (TableList*) session->calloc(ALIGN_SIZE(sizeof(TableList))+
1078
 
                                       sizeof(NestedJoin))))
 
1088
                                       sizeof(nested_join_st))))
1079
1089
    return true;
1080
 
  ptr->setNestedJoin(((NestedJoin*) ((unsigned char*) ptr + ALIGN_SIZE(sizeof(TableList)))));
1081
 
  nested_join= ptr->getNestedJoin();
 
1090
  nested_join= ptr->nested_join=
 
1091
    ((nested_join_st*) ((unsigned char*) ptr + ALIGN_SIZE(sizeof(TableList))));
 
1092
 
1082
1093
  join_list->push_front(ptr);
1083
 
  ptr->setEmbedding(embedding);
1084
 
  ptr->setJoinList(join_list);
 
1094
  ptr->embedding= embedding;
 
1095
  ptr->join_list= join_list;
1085
1096
  ptr->alias= (char*) "(nested_join)";
1086
1097
  embedding= ptr;
1087
1098
  join_list= &nested_join->join_list;
1107
1118
TableList *Select_Lex::end_nested_join(Session *)
1108
1119
{
1109
1120
  TableList *ptr;
1110
 
  NestedJoin *nested_join;
 
1121
  nested_join_st *nested_join;
1111
1122
 
1112
1123
  assert(embedding);
1113
1124
  ptr= embedding;
1114
 
  join_list= ptr->getJoinList();
1115
 
  embedding= ptr->getEmbedding();
1116
 
  nested_join= ptr->getNestedJoin();
 
1125
  join_list= ptr->join_list;
 
1126
  embedding= ptr->embedding;
 
1127
  nested_join= ptr->nested_join;
1117
1128
  if (nested_join->join_list.elements == 1)
1118
1129
  {
1119
1130
    TableList *embedded= nested_join->join_list.head();
1120
1131
    join_list->pop();
1121
 
    embedded->setJoinList(join_list);
1122
 
    embedded->setEmbedding(embedding);
 
1132
    embedded->join_list= join_list;
 
1133
    embedded->embedding= embedding;
1123
1134
    join_list->push_front(embedded);
1124
1135
    ptr= embedded;
1125
1136
  }
1148
1159
TableList *Select_Lex::nest_last_join(Session *session)
1149
1160
{
1150
1161
  TableList *ptr;
1151
 
  NestedJoin *nested_join;
 
1162
  nested_join_st *nested_join;
1152
1163
  List<TableList> *embedded_list;
1153
1164
 
1154
1165
  if (!(ptr= (TableList*) session->calloc(ALIGN_SIZE(sizeof(TableList))+
1155
 
                                          sizeof(NestedJoin))))
 
1166
                                       sizeof(nested_join_st))))
1156
1167
    return NULL;
1157
 
  ptr->setNestedJoin(((NestedJoin*) ((unsigned char*) ptr + ALIGN_SIZE(sizeof(TableList)))));
1158
 
  nested_join= ptr->getNestedJoin();
1159
 
  ptr->setEmbedding(embedding);
1160
 
  ptr->setJoinList(join_list);
 
1168
  nested_join= ptr->nested_join=
 
1169
    ((nested_join_st*) ((unsigned char*) ptr + ALIGN_SIZE(sizeof(TableList))));
 
1170
 
 
1171
  ptr->embedding= embedding;
 
1172
  ptr->join_list= join_list;
1161
1173
  ptr->alias= (char*) "(nest_last_join)";
1162
1174
  embedded_list= &nested_join->join_list;
1163
1175
  embedded_list->empty();
1165
1177
  for (uint32_t i=0; i < 2; i++)
1166
1178
  {
1167
1179
    TableList *table= join_list->pop();
1168
 
    table->setJoinList(embedded_list);
1169
 
    table->setEmbedding(ptr);
 
1180
    table->join_list= embedded_list;
 
1181
    table->embedding= ptr;
1170
1182
    embedded_list->push_back(table);
1171
1183
    if (table->natural_join)
1172
1184
    {
1202
1214
void Select_Lex::add_joined_table(TableList *table)
1203
1215
{
1204
1216
  join_list->push_front(table);
1205
 
  table->setJoinList(join_list);
1206
 
  table->setEmbedding(embedding);
 
1217
  table->join_list= join_list;
 
1218
  table->embedding= embedding;
1207
1219
}
1208
1220
 
1209
1221
 
1263
1275
 
1264
1276
void Select_Lex::set_lock_for_tables(thr_lock_type lock_type)
1265
1277
{
 
1278
  bool for_update= lock_type >= TL_READ_NO_INSERT;
 
1279
 
1266
1280
  for (TableList *tables= (TableList*) table_list.first;
1267
1281
       tables;
1268
1282
       tables= tables->next_local)
1269
1283
  {
1270
1284
    tables->lock_type= lock_type;
 
1285
    tables->updating=  for_update;
1271
1286
  }
 
1287
  return;
1272
1288
}
1273
1289
 
1274
1290
 
1279
1295
    This object is created for any union construct containing a union
1280
1296
    operation and also for any single select union construct of the form
1281
1297
    @verbatim
1282
 
    (SELECT ... ORDER BY order_list [LIMIT n]) ORDER BY ...
 
1298
    (SELECT ... order_st BY order_list [LIMIT n]) order_st BY ...
1283
1299
    @endvarbatim
1284
1300
    or of the form
1285
1301
    @varbatim
1286
 
    (SELECT ... ORDER BY LIMIT n) ORDER BY ...
 
1302
    (SELECT ... order_st BY LIMIT n) order_st BY ...
1287
1303
    @endvarbatim
1288
1304
 
1289
1305
  @param session_arg               thread handle
1314
1330
  fake_select_lex->select_limit= 0;
1315
1331
 
1316
1332
  fake_select_lex->context.outer_context=first_sl->context.outer_context;
1317
 
  /* allow item list resolving in fake select for ORDER BY */
 
1333
  /* allow item list resolving in fake select for order_st BY */
1318
1334
  fake_select_lex->context.resolve_in_select_list= true;
1319
1335
  fake_select_lex->context.select_lex= fake_select_lex;
1320
1336
 
1322
1338
  {
1323
1339
    /*
1324
1340
      This works only for
1325
 
      (SELECT ... ORDER BY list [LIMIT n]) ORDER BY order_list [LIMIT m],
1326
 
      (SELECT ... LIMIT n) ORDER BY order_list [LIMIT m]
 
1341
      (SELECT ... order_st BY list [LIMIT n]) order_st BY order_list [LIMIT m],
 
1342
      (SELECT ... LIMIT n) order_st BY order_list [LIMIT m]
1327
1343
      just before the parser starts processing order_list
1328
1344
    */
1329
1345
    global_parameters= fake_select_lex;
1446
1462
 
1447
1463
 
1448
1464
/**
 
1465
  kill on thread.
 
1466
 
 
1467
  @param session                        Thread class
 
1468
  @param id                     Thread id
 
1469
  @param only_kill_query        Should it kill the query or the connection
 
1470
 
 
1471
  @note
 
1472
    This is written such that we have a short lock on LOCK_thread_count
 
1473
*/
 
1474
 
 
1475
static unsigned int
 
1476
kill_one_thread(Session *, ulong id, bool only_kill_query)
 
1477
{
 
1478
  Session *tmp= NULL;
 
1479
  uint32_t error=ER_NO_SUCH_THREAD;
 
1480
  pthread_mutex_lock(&LOCK_thread_count); // For unlink from list
 
1481
  
 
1482
  for( vector<Session*>::iterator it= session_list.begin(); it != session_list.end(); ++it )
 
1483
  {
 
1484
    if ((*it)->thread_id == id)
 
1485
    {
 
1486
      tmp= *it;
 
1487
      pthread_mutex_lock(&tmp->LOCK_delete);    // Lock from delete
 
1488
      break;
 
1489
    }
 
1490
  }
 
1491
  pthread_mutex_unlock(&LOCK_thread_count);
 
1492
  if (tmp)
 
1493
  {
 
1494
    tmp->awake(only_kill_query ? Session::KILL_QUERY : Session::KILL_CONNECTION);
 
1495
    error=0;
 
1496
    pthread_mutex_unlock(&tmp->LOCK_delete);
 
1497
  }
 
1498
  return(error);
 
1499
}
 
1500
 
 
1501
 
 
1502
/*
 
1503
  kills a thread and sends response
 
1504
 
 
1505
  SYNOPSIS
 
1506
    sql_kill()
 
1507
    session                     Thread class
 
1508
    id                  Thread id
 
1509
    only_kill_query     Should it kill the query or the connection
 
1510
*/
 
1511
 
 
1512
void sql_kill(Session *session, ulong id, bool only_kill_query)
 
1513
{
 
1514
  uint32_t error;
 
1515
  if (!(error= kill_one_thread(session, id, only_kill_query)))
 
1516
    session->my_ok();
 
1517
  else
 
1518
    my_error(error, MYF(0), id);
 
1519
}
 
1520
 
 
1521
 
 
1522
/**
1449
1523
  Check if the select is a simple select (not an union).
1450
1524
 
1451
1525
  @retval
1454
1528
    1   error   ; In this case the error messege is sent to the client
1455
1529
*/
1456
1530
 
1457
 
bool check_simple_select(Session::pointer session)
 
1531
bool check_simple_select()
1458
1532
{
 
1533
  Session *session= current_session;
1459
1534
  LEX *lex= session->lex;
1460
1535
  if (lex->current_select != &lex->select_lex)
1461
1536
  {
1572
1647
 
1573
1648
 
1574
1649
/**
 
1650
  CREATE TABLE query pre-check.
 
1651
 
 
1652
  @param session                        Thread handler
 
1653
  @param tables         Global table list
 
1654
  @param create_table           Table which will be created
 
1655
 
 
1656
  @retval
 
1657
    false   OK
 
1658
  @retval
 
1659
    true   Error
 
1660
*/
 
1661
 
 
1662
bool create_table_precheck(Session *, TableList *,
 
1663
                           TableList *create_table)
 
1664
{
 
1665
  bool error= true;                                 // Error message is given
 
1666
 
 
1667
  if (create_table && (strcmp(create_table->db, "information_schema") == 0))
 
1668
  {
 
1669
    my_error(ER_DBACCESS_DENIED_ERROR, MYF(0), "", "", INFORMATION_SCHEMA_NAME.c_str());
 
1670
    return(true);
 
1671
  }
 
1672
 
 
1673
  error= false;
 
1674
 
 
1675
  return(error);
 
1676
}
 
1677
 
 
1678
 
 
1679
/**
1575
1680
  negate given expression.
1576
1681
 
1577
1682
  @param session  thread handler
1638
1743
}
1639
1744
 
1640
1745
 
1641
 
bool check_identifier_name(LEX_STRING *str, error_t err_code,
 
1746
bool check_identifier_name(LEX_STRING *str, uint32_t err_code,
1642
1747
                           uint32_t max_char_length,
1643
1748
                           const char *param_for_err_msg)
1644
1749
{
1664
1769
 
1665
1770
  switch (err_code)
1666
1771
  {
1667
 
  case EE_OK:
 
1772
  case 0:
1668
1773
    break;
1669
1774
  case ER_WRONG_STRING_LENGTH:
1670
1775
    my_error(err_code, MYF(0), str->str, param_for_err_msg, max_char_length);
1676
1781
    assert(0);
1677
1782
    break;
1678
1783
  }
1679
 
 
1680
1784
  return true;
1681
1785
}
1682
1786
 
 
1787
extern int DRIZZLEparse(void *session); // from sql_yacc.cc
 
1788
 
1683
1789
 
1684
1790
/**
1685
1791
  This is a wrapper of DRIZZLEparse(). All the code should call parse_sql()
1697
1803
{
1698
1804
  assert(session->m_lip == NULL);
1699
1805
 
1700
 
  DRIZZLE_QUERY_PARSE_START(session->getQueryString()->c_str());
 
1806
  DRIZZLE_QUERY_PARSE_START(session->query);
1701
1807
 
1702
1808
  /* Set Lex_input_stream. */
1703
1809
 
1705
1811
 
1706
1812
  /* Parse the query. */
1707
1813
 
1708
 
  bool parse_status= DRIZZLEparse(session) != 0;
 
1814
  bool mysql_parse_status= DRIZZLEparse(session) != 0;
1709
1815
 
1710
1816
  /* Check that if DRIZZLEparse() failed, session->is_error() is set. */
1711
1817
 
1712
 
  assert(!parse_status || session->is_error());
 
1818
  assert(!mysql_parse_status || session->is_error());
1713
1819
 
1714
1820
  /* Reset Lex_input_stream. */
1715
1821
 
1716
1822
  session->m_lip= NULL;
1717
1823
 
1718
 
  DRIZZLE_QUERY_PARSE_DONE(parse_status || session->is_fatal_error);
 
1824
  DRIZZLE_QUERY_PARSE_DONE(mysql_parse_status || session->is_fatal_error);
1719
1825
 
1720
1826
  /* That's it. */
1721
1827
 
1722
 
  return parse_status || session->is_fatal_error;
 
1828
  return mysql_parse_status || session->is_fatal_error;
1723
1829
}
1724
1830
 
1725
1831
/**
1726
1832
  @} (end of group Runtime_Environment)
1727
1833
*/
1728
 
 
1729
 
} /* namespace drizzled */