← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to drizzled/sql_parse.cc

  • Committer: Lee Bieber
  • Date: 2011-03-29 22:31:41 UTC
  • mfrom: (2257.1.3 build)
  • Revision ID: kalebral@gmail.com-20110329223141-yxc22h3l2he58sk0
Merge Andrew - 743842: Build failure using GCC 4.6
Merge Stewart - 738022: CachedDirectory silently fails to add entries if stat() fails
Merge Olaf - Common fwd: add copyright, add more declaration

Show diffs side-by-side

added added

removed removed

Lines of Context:
drizzled/sql_parse.cc
13
13
   along with this program; if not, write to the Free Software
14
14
   Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA */
15
15
 
16
 
#include "config.h"
 
16
#include <config.h>
17
17
 
18
18
#define DRIZZLE_LEX 1
19
19
 
20
 
#include "drizzled/item/num.h"
21
 
#include "drizzled/abort_exception.h"
22
 
#include <drizzled/my_hash.h>
 
20
#include <drizzled/item/num.h>
 
21
#include <drizzled/abort_exception.h>
23
22
#include <drizzled/error.h>
24
23
#include <drizzled/nested_join.h>
25
24
#include <drizzled/query_id.h>
26
 
#include "drizzled/transaction_services.h"
 
25
#include <drizzled/transaction_services.h>
27
26
#include <drizzled/sql_parse.h>
28
27
#include <drizzled/data_home.h>
29
28
#include <drizzled/sql_base.h>
30
29
#include <drizzled/show.h>
31
 
#include <drizzled/db.h>
32
30
#include <drizzled/function/time/unix_timestamp.h>
33
31
#include <drizzled/function/get_system_var.h>
34
32
#include <drizzled/item/cmpfunc.h>
41
39
#include <drizzled/plugin/client.h>
42
40
#include <drizzled/statement.h>
43
41
#include <drizzled/statement/alter_table.h>
44
 
#include "drizzled/probes.h"
45
 
#include "drizzled/global_charset_info.h"
46
 
 
47
 
#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"
 
42
#include <drizzled/probes.h>
 
43
#include <drizzled/global_charset_info.h>
 
44
#include <drizzled/plugin/logging.h>
 
45
#include <drizzled/plugin/query_rewrite.h>
 
46
#include <drizzled/plugin/query_cache.h>
 
47
#include <drizzled/plugin/authorization.h>
 
48
#include <drizzled/optimizer/explain_plan.h>
 
49
#include <drizzled/pthread_globals.h>
 
50
#include <drizzled/plugin/event_observer.h>
 
51
#include <drizzled/display.h>
 
52
#include <drizzled/visibility.h>
 
53
#include <drizzled/kill.h>
 
54
#include <drizzled/schema.h>
 
55
#include <drizzled/item/subselect.h>
 
56
#include <drizzled/diagnostics_area.h>
 
57
#include <drizzled/table_ident.h>
 
58
#include <drizzled/statistics_variables.h>
 
59
#include <drizzled/system_variables.h>
 
60
#include <drizzled/session/transactions.h>
55
61
 
56
62
#include <limits.h>
57
63
 
58
64
#include <bitset>
59
65
#include <algorithm>
60
66
#include <boost/date_time.hpp>
61
 
#include "drizzled/internal/my_sys.h"
 
67
#include <drizzled/internal/my_sys.h>
62
68
 
63
69
using namespace std;
64
70
 
65
 
extern int DRIZZLEparse(void *session); // from sql_yacc.cc
 
71
extern int base_sql_parse(drizzled::Session *session); // from sql_yacc.cc
66
72
 
67
 
namespace drizzled
68
 
{
 
73
namespace drizzled {
69
74
 
70
75
/* Prototypes */
71
 
bool my_yyoverflow(short **a, YYSTYPE **b, ulong *yystacksize);
 
76
bool my_yyoverflow(short **a, ParserType **b, ulong *yystacksize);
72
77
static bool parse_sql(Session *session, Lex_input_stream *lip);
73
78
void parse(Session *session, const char *inBuf, uint32_t length);
74
79
 
78
83
*/
79
84
 
80
85
extern size_t my_thread_stack_size;
81
 
extern const CHARSET_INFO *character_set_filesystem;
 
86
extern const charset_info_st *character_set_filesystem;
82
87
 
83
88
namespace
84
89
{
91
96
  "Shutdown",
92
97
  "Connect",
93
98
  "Ping",
 
99
  "Kill",
94
100
  "Error"  // Last command number
95
101
};
96
102
 
167
173
                         can be zero.
168
174
 
169
175
  @todo
170
 
    set session->lex->sql_command to SQLCOM_END here.
 
176
    set session->lex().sql_command to SQLCOM_END here.
171
177
  @todo
172
178
    The following has to be changed to an 8 byte integer
173
179
 
177
183
    1   request of thread shutdown, i. e. if command is
178
184
        COM_QUIT/COM_SHUTDOWN
179
185
*/
180
 
bool dispatch_command(enum enum_server_command command, Session *session,
 
186
bool dispatch_command(enum_server_command command, Session *session,
181
187
                      char* packet, uint32_t packet_length)
182
188
{
183
189
  bool error= 0;
186
192
  DRIZZLE_COMMAND_START(session->thread_id, command);
187
193
 
188
194
  session->command= command;
189
 
  session->lex->sql_command= SQLCOM_END; /* to avoid confusing VIEW detectors */
 
195
  session->lex().sql_command= SQLCOM_END; /* to avoid confusing VIEW detectors */
190
196
  session->set_time();
191
197
  session->setQueryId(query_id.value());
192
198
 
200
206
    query_id.next();
201
207
  }
202
208
 
203
 
  /* @todo set session->lex->sql_command to SQLCOM_END here */
 
209
  /* @todo set session->lex().sql_command to SQLCOM_END here */
204
210
 
205
211
  plugin::Logging::preDo(session);
206
212
  if (unlikely(plugin::EventObserver::beforeStatement(*session)))
210
216
 
211
217
  session->server_status&=
212
218
           ~(SERVER_QUERY_NO_INDEX_USED | SERVER_QUERY_NO_GOOD_INDEX_USED);
 
219
 
213
220
  switch (command) {
214
221
  case COM_INIT_DB:
215
222
  {
223
230
 
224
231
    identifier::Schema identifier(tmp);
225
232
 
226
 
    if (not change_db(session, identifier))
 
233
    if (not schema::change(*session, identifier))
227
234
    {
228
235
      session->my_ok();
229
236
    }
243
250
  }
244
251
  case COM_QUIT:
245
252
    /* We don't calculate statistics for this command */
246
 
    session->main_da.disable_status();              // Don't send anything back
247
 
    error=true;                                 // End server
 
253
    session->main_da().disable_status();              // Don't send anything back
 
254
    error= true;                                        // End server
248
255
    break;
 
256
  case COM_KILL:
 
257
    {
 
258
      if (packet_length != 4)
 
259
      {
 
260
        my_error(ER_NO_SUCH_THREAD, MYF(0), 0);
 
261
        break;
 
262
      }
 
263
      else
 
264
      {
 
265
        uint32_t kill_id;
 
266
        memcpy(&kill_id, packet, sizeof(uint32_t));
 
267
 
 
268
        kill_id= ntohl(kill_id);
 
269
        (void)drizzled::kill(*session->user(), kill_id, true);
 
270
      }
 
271
      session->my_ok();
 
272
      break;
 
273
    }
249
274
  case COM_SHUTDOWN:
250
275
  {
251
276
    session->status_var.com_other++;
252
277
    session->my_eof();
253
278
    session->close_thread_tables();                     // Free before kill
254
279
    kill_drizzle();
255
 
    error=true;
 
280
    error= true;
256
281
    break;
257
282
  }
258
283
  case COM_PING:
268
293
  }
269
294
 
270
295
  /* If commit fails, we should be able to reset the OK status. */
271
 
  session->main_da.can_overwrite_status= true;
 
296
  session->main_da().can_overwrite_status= true;
272
297
  TransactionServices &transaction_services= TransactionServices::singleton();
273
298
  transaction_services.autocommitOrRollback(*session, session->is_error());
274
 
  session->main_da.can_overwrite_status= false;
 
299
  session->main_da().can_overwrite_status= false;
275
300
 
276
301
  session->transaction.stmt.reset();
277
302
 
279
304
  /* report error issued during command execution */
280
305
  if (session->killed_errno())
281
306
  {
282
 
    if (! session->main_da.is_set())
 
307
    if (! session->main_da().is_set())
283
308
      session->send_kill_message();
284
309
  }
285
310
  if (session->getKilled() == Session::KILL_QUERY || session->getKilled() == Session::KILL_BAD_DATA)
289
314
  }
290
315
 
291
316
  /* Can not be true, but do not take chances in production. */
292
 
  assert(! session->main_da.is_sent);
 
317
  assert(! session->main_da().is_sent);
293
318
 
294
 
  switch (session->main_da.status())
 
319
  switch (session->main_da().status())
295
320
  {
296
321
  case Diagnostics_area::DA_ERROR:
297
322
    /* The query failed, send error to log and abort bootstrap. */
298
 
    session->getClient()->sendError(session->main_da.sql_errno(),
299
 
                               session->main_da.message());
 
323
    session->getClient()->sendError(session->main_da().sql_errno(),
 
324
                               session->main_da().message());
300
325
    break;
301
326
 
302
327
  case Diagnostics_area::DA_EOF:
316
341
    break;
317
342
  }
318
343
 
319
 
  session->main_da.is_sent= true;
 
344
  session->main_da().is_sent= true;
320
345
 
321
346
  session->set_proc_info("closing tables");
322
347
  /* Free tables */
386
411
  session->make_lex_string(&db, "data_dictionary", sizeof("data_dictionary"), false);
387
412
  session->make_lex_string(&table, schema_table_name, false);
388
413
 
389
 
  if (! sel->add_table_to_list(session, new Table_ident(db, table),
390
 
                               NULL, table_options, TL_READ))
 
414
  if (not sel->add_table_to_list(session, new Table_ident(db, table), NULL, table_options, TL_READ))
391
415
  {
392
416
    return true;
393
417
  }
394
418
  return false;
395
419
}
396
420
 
397
 
int prepare_new_schema_table(Session *session, LEX *lex,
 
421
int prepare_new_schema_table(Session *session, LEX& lex,
398
422
                             const string& schema_table_name)
399
423
{
400
424
  Select_Lex *schema_select_lex= NULL;
401
425
 
402
 
  Select_Lex *select_lex= lex->current_select;
 
426
  Select_Lex *select_lex= lex.current_select;
403
427
  assert(select_lex);
404
428
  if (_schema_select(session, select_lex, schema_table_name))
405
429
  {
445
469
static int execute_command(Session *session)
446
470
{
447
471
  bool res= false;
448
 
  LEX  *lex= session->lex;
 
472
 
449
473
  /* first Select_Lex (have special meaning for many of non-SELECTcommands) */
450
 
  Select_Lex *select_lex= &lex->select_lex;
 
474
  Select_Lex *select_lex= &session->lex().select_lex;
 
475
 
451
476
  /* list of all tables in query */
452
477
  TableList *all_tables;
453
478
 
466
491
    assert(first_table == all_tables);
467
492
    assert(first_table == all_tables && first_table != 0);
468
493
  */
469
 
  lex->first_lists_tables_same();
 
494
  session->lex().first_lists_tables_same();
 
495
 
470
496
  /* should be assigned after making first tables same */
471
 
  all_tables= lex->query_tables;
 
497
  all_tables= session->lex().query_tables;
 
498
 
472
499
  /* set context for commands which do not use setup_tables */
473
 
  select_lex->
474
 
    context.resolve_in_table_list_only((TableList*)select_lex->
475
 
                                       table_list.first);
 
500
  select_lex->context.resolve_in_table_list_only((TableList*)select_lex->table_list.first);
476
501
 
477
502
  /*
478
503
    Reset warning count for each query that uses tables
481
506
    variables, but for now this is probably good enough.
482
507
    Don't reset warnings when executing a stored routine.
483
508
  */
484
 
  if (all_tables || ! lex->is_single_level_stmt())
 
509
  if (all_tables || ! session->lex().is_single_level_stmt())
485
510
  {
486
511
    drizzle_reset_errors(session, 0);
487
512
  }
490
515
 
491
516
  if (! (session->server_status & SERVER_STATUS_AUTOCOMMIT)
492
517
      && ! session->inTransaction()
493
 
      && lex->statement->isTransactional())
 
518
      && session->lex().statement->isTransactional())
494
519
  {
495
520
    if (session->startTransaction() == false)
496
521
    {
500
525
  }
501
526
 
502
527
  /* now we are ready to execute the statement */
503
 
  res= lex->statement->execute();
 
528
  res= session->lex().statement->execute();
504
529
  session->set_proc_info("query end");
505
530
  /*
506
531
    The return value for ROW_COUNT() is "implementation dependent" if the
508
533
    wants. We also keep the last value in case of SQLCOM_CALL or
509
534
    SQLCOM_EXECUTE.
510
535
  */
511
 
  if (! (sql_command_flags[lex->sql_command].test(CF_BIT_HAS_ROW_COUNT)))
 
536
  if (! (sql_command_flags[session->lex().sql_command].test(CF_BIT_HAS_ROW_COUNT)))
512
537
  {
513
538
    session->row_count_func= -1;
514
539
  }
517
542
}
518
543
bool execute_sqlcom_select(Session *session, TableList *all_tables)
519
544
{
520
 
  LEX   *lex= session->lex;
 
545
  LEX   *lex= &session->lex();
521
546
  select_result *result=lex->result;
522
547
  bool res= false;
523
548
  /* assign global limit variable if limit is not given */
554
579
        return true;
555
580
      session->send_explain_fields(result);
556
581
      optimizer::ExplainPlan planner;
557
 
      res= planner.explainUnion(session, &session->lex->unit, result);
 
582
      res= planner.explainUnion(session, &session->lex().unit, result);
558
583
      if (lex->describe & DESCRIBE_EXTENDED)
559
584
      {
560
585
        char buff[1024];
561
586
        String str(buff,(uint32_t) sizeof(buff), system_charset_info);
562
587
        str.length(0);
563
 
        session->lex->unit.print(&str, QT_ORDINARY);
 
588
        session->lex().unit.print(&str);
564
589
        str.append('\0');
565
590
        push_warning(session, DRIZZLE_ERROR::WARN_LEVEL_NOTE,
566
591
                     ER_YES, str.ptr());
569
594
        result->abort();
570
595
      else
571
596
        result->send_eof();
 
597
 
572
598
      delete result;
573
599
    }
574
600
    else
577
603
        return true;
578
604
 
579
605
      /* Init the Query Cache plugin */
580
 
      plugin::QueryCache::prepareResultset(session); 
 
606
      plugin::QueryCache::prepareResultset(session);
581
607
      res= handle_select(session, lex, result, 0);
582
608
      /* Send the Resultset to the cache */
583
 
      plugin::QueryCache::setResultset(session); 
 
609
      plugin::QueryCache::setResultset(session);
584
610
 
585
611
      if (result != lex->result)
586
612
        delete result;
593
619
#define MY_YACC_INIT 1000                       // Start with big alloc
594
620
#define MY_YACC_MAX  32000                      // Because of 'short'
595
621
 
596
 
bool my_yyoverflow(short **yyss, YYSTYPE **yyvs, ulong *yystacksize)
 
622
bool my_yyoverflow(short **yyss, ParserType **yyvs, ulong *yystacksize)
597
623
{
598
 
  LEX   *lex= current_session->lex;
 
624
  LEX   *lex= &current_session->lex();
599
625
  ulong old_info=0;
600
626
  if ((uint32_t) *yystacksize >= MY_YACC_MAX)
601
627
    return 1;
618
644
    memcpy(lex->yacc_yyvs, *yyvs, old_info*sizeof(**yyvs));
619
645
  }
620
646
  *yyss=(short*) lex->yacc_yyss;
621
 
  *yyvs=(YYSTYPE*) lex->yacc_yyvs;
 
647
  *yyvs=(ParserType*) lex->yacc_yyvs;
622
648
  return 0;
623
649
}
624
650
 
728
754
  char buff[MAX_SYS_VAR_LENGTH*2+4+8];
729
755
  char *end= buff;
730
756
 
731
 
  lex= session->lex;
 
757
  lex= &session->lex();
732
758
  init_select(lex);
733
759
  lex->sql_command= SQLCOM_SELECT;
734
760
  tmp.str= (char*) var_name;
757
783
 
758
784
void parse(Session *session, const char *inBuf, uint32_t length)
759
785
{
760
 
  session->lex->start(session);
 
786
  session->lex().start(session);
761
787
 
762
788
  session->reset_for_next_command();
763
789
  /* Check if the Query is Cached if and return true if yes
773
799
  {
774
800
    return;
775
801
  }
776
 
  LEX *lex= session->lex;
 
802
  LEX *lex= &session->lex();
777
803
  Lex_input_stream lip(session, inBuf, length);
778
804
  bool err= parse_sql(session, &lip);
779
805
  if (!err)
786
812
                                 const_cast<const char *>(session->schema()->c_str()));
787
813
        // Implement Views here --Brian
788
814
        /* Actually execute the query */
789
 
        try 
 
815
        try
790
816
        {
791
817
          execute_command(session);
792
818
        }
827
853
                       Item *default_value, Item *on_update_value,
828
854
                       LEX_STRING *comment,
829
855
                       char *change,
830
 
                       List<String> *interval_list, const CHARSET_INFO * const cs)
 
856
                       List<String> *interval_list, const charset_info_st * const cs)
831
857
{
832
858
  register CreateField *new_field;
833
 
  LEX  *lex= session->lex;
 
859
  LEX  *lex= &session->lex();
834
860
  statement::AlterTable *statement= (statement::AlterTable *)lex->statement;
835
861
 
836
862
  if (check_identifier_name(field_name, ER_TOO_LONG_IDENT))
844
870
                      &default_key_create_info,
845
871
                      0, lex->col_list);
846
872
    statement->alter_info.key_list.push_back(key);
847
 
    lex->col_list.empty();
 
873
    lex->col_list.clear();
848
874
  }
849
875
  if (type_modifier & (UNIQUE_FLAG | UNIQUE_KEY_FLAG))
850
876
  {
854
880
                 &default_key_create_info, 0,
855
881
                 lex->col_list);
856
882
    statement->alter_info.key_list.push_back(key);
857
 
    lex->col_list.empty();
 
883
    lex->col_list.clear();
858
884
  }
859
885
 
860
886
  if (default_value)
895
921
    return true;
896
922
  }
897
923
 
898
 
  if (!(new_field= new CreateField()) ||
899
 
      new_field->init(session, field_name->str, type, length, decimals, type_modifier,
900
 
                      default_value, on_update_value, comment, change,
901
 
                      interval_list, cs, 0, column_format))
 
924
  if (!(new_field= new CreateField())
 
925
      || new_field->init(session, field_name->str, type, length, decimals,
 
926
                         type_modifier, comment, change, interval_list,
 
927
                         cs, 0, column_format)
 
928
      || new_field->setDefaultValue(default_value, on_update_value))
902
929
    return true;
903
930
 
904
931
  statement->alter_info.create_list.push_back(new_field);
935
962
                                         List<Index_hint> *index_hints_arg,
936
963
                                         LEX_STRING *option)
937
964
{
938
 
  TableList *ptr;
939
965
  TableList *previous_table_ref; /* The table preceding the current one. */
940
966
  char *alias_str;
941
 
  LEX *lex= session->lex;
 
967
  LEX *lex= &session->lex();
942
968
 
943
969
  if (!table)
944
970
    return NULL;                                // End of memory
955
981
    my_casedn_str(files_charset_info, table->db.str);
956
982
 
957
983
    identifier::Schema schema_identifier(string(table->db.str));
958
 
    if (not check_db_name(session, schema_identifier))
 
984
    if (not schema::check(*session, schema_identifier))
959
985
    {
960
986
 
961
987
      my_error(ER_WRONG_DB_NAME, MYF(0), table->db.str);
974
1000
    if (!(alias_str= (char*) session->getMemRoot()->duplicate(alias_str,table->table.length+1)))
975
1001
      return NULL;
976
1002
  }
977
 
  if (!(ptr = (TableList *) session->calloc(sizeof(TableList))))
978
 
    return NULL;
 
1003
  TableList *ptr = (TableList *) session->calloc(sizeof(TableList));
979
1004
 
980
1005
  if (table->db.str)
981
1006
  {
1016
1041
    }
1017
1042
  }
1018
1043
  /* Store the table reference preceding the current one. */
1019
 
  if (table_list.elements > 0)
 
1044
  if (table_list.size() > 0)
1020
1045
  {
1021
1046
    /*
1022
1047
      table_list.next points to the last inserted TableList->next_local'
1085
1110
  ptr->alias= (char*) "(nested_join)";
1086
1111
  embedding= ptr;
1087
1112
  join_list= &nested_join->join_list;
1088
 
  join_list->empty();
 
1113
  join_list->clear();
1089
1114
  return false;
1090
1115
}
1091
1116
 
1114
1139
  join_list= ptr->getJoinList();
1115
1140
  embedding= ptr->getEmbedding();
1116
1141
  nested_join= ptr->getNestedJoin();
1117
 
  if (nested_join->join_list.elements == 1)
 
1142
  if (nested_join->join_list.size() == 1)
1118
1143
  {
1119
 
    TableList *embedded= nested_join->join_list.head();
 
1144
    TableList *embedded= &nested_join->join_list.front();
1120
1145
    join_list->pop();
1121
1146
    embedded->setJoinList(join_list);
1122
1147
    embedded->setEmbedding(embedding);
1123
1148
    join_list->push_front(embedded);
1124
1149
    ptr= embedded;
1125
1150
  }
1126
 
  else if (nested_join->join_list.elements == 0)
 
1151
  else if (nested_join->join_list.size() == 0)
1127
1152
  {
1128
1153
    join_list->pop();
1129
1154
    ptr= NULL;                                     // return value
1160
1185
  ptr->setJoinList(join_list);
1161
1186
  ptr->alias= (char*) "(nest_last_join)";
1162
1187
  embedded_list= &nested_join->join_list;
1163
 
  embedded_list->empty();
 
1188
  embedded_list->clear();
1164
1189
 
1165
1190
  for (uint32_t i=0; i < 2; i++)
1166
1191
  {
1308
1333
  fake_select_lex->include_standalone(this,
1309
1334
                                      (Select_Lex_Node**)&fake_select_lex);
1310
1335
  fake_select_lex->select_number= INT_MAX;
1311
 
  fake_select_lex->parent_lex= session_arg->lex; /* Used in init_query. */
 
1336
  fake_select_lex->parent_lex= &session_arg->lex(); /* Used in init_query. */
1312
1337
  fake_select_lex->make_empty_select();
1313
1338
  fake_select_lex->linkage= GLOBAL_OPTIONS_TYPE;
1314
1339
  fake_select_lex->select_limit= 0;
1328
1353
    */
1329
1354
    global_parameters= fake_select_lex;
1330
1355
    fake_select_lex->no_table_names_allowed= 1;
1331
 
    session_arg->lex->current_select= fake_select_lex;
 
1356
    session_arg->lex().current_select= fake_select_lex;
1332
1357
  }
1333
 
  session_arg->lex->pop_context();
 
1358
  session_arg->lex().pop_context();
1334
1359
  return(0);
1335
1360
}
1336
1361
 
1354
1379
    true   if a memory allocation error occured
1355
1380
*/
1356
1381
 
1357
 
bool
1358
 
push_new_name_resolution_context(Session *session,
1359
 
                                 TableList *left_op, TableList *right_op)
 
1382
void push_new_name_resolution_context(Session& session, TableList& left_op, TableList& right_op)
1360
1383
{
1361
 
  Name_resolution_context *on_context;
1362
 
  if (!(on_context= new (session->mem_root) Name_resolution_context))
1363
 
    return true;
 
1384
  Name_resolution_context *on_context= new (session.mem_root) Name_resolution_context;
1364
1385
  on_context->init();
1365
 
  on_context->first_name_resolution_table=
1366
 
    left_op->first_leaf_for_name_resolution();
1367
 
  on_context->last_name_resolution_table=
1368
 
    right_op->last_leaf_for_name_resolution();
1369
 
  return session->lex->push_context(on_context);
 
1386
  on_context->first_name_resolution_table= left_op.first_leaf_for_name_resolution();
 
1387
  on_context->last_name_resolution_table= right_op.last_leaf_for_name_resolution();
 
1388
  session.lex().push_context(on_context);
1370
1389
}
1371
1390
 
1372
1391
 
1454
1473
    1   error   ; In this case the error messege is sent to the client
1455
1474
*/
1456
1475
 
1457
 
bool check_simple_select(Session::pointer session)
 
1476
bool check_simple_select(Session* session)
1458
1477
{
1459
 
  LEX *lex= session->lex;
1460
 
  if (lex->current_select != &lex->select_lex)
 
1478
  if (session->lex().current_select != &session->lex().select_lex)
1461
1479
  {
1462
1480
    char command[80];
1463
1481
    Lex_input_stream *lip= session->m_lip;
1517
1535
bool update_precheck(Session *session, TableList *)
1518
1536
{
1519
1537
  const char *msg= 0;
1520
 
  LEX *lex= session->lex;
1521
 
  Select_Lex *select_lex= &lex->select_lex;
 
1538
  Select_Lex *select_lex= &session->lex().select_lex;
1522
1539
 
1523
 
  if (session->lex->select_lex.item_list.elements != session->lex->value_list.elements)
 
1540
  if (session->lex().select_lex.item_list.size() != session->lex().value_list.size())
1524
1541
  {
1525
1542
    my_message(ER_WRONG_VALUE_COUNT, ER(ER_WRONG_VALUE_COUNT), MYF(0));
1526
1543
    return(true);
1527
1544
  }
1528
1545
 
1529
 
  if (session->lex->select_lex.table_list.elements > 1)
 
1546
  if (session->lex().select_lex.table_list.size() > 1)
1530
1547
  {
1531
 
    if (select_lex->order_list.elements)
 
1548
    if (select_lex->order_list.size())
1532
1549
      msg= "ORDER BY";
1533
1550
    else if (select_lex->select_limit)
1534
1551
      msg= "LIMIT";
1556
1573
 
1557
1574
bool insert_precheck(Session *session, TableList *)
1558
1575
{
1559
 
  LEX *lex= session->lex;
1560
 
 
1561
1576
  /*
1562
1577
    Check that we have modify privileges for the first table and
1563
1578
    select privileges for the rest
1564
1579
  */
1565
 
  if (lex->update_list.elements != lex->value_list.elements)
 
1580
  if (session->lex().update_list.size() != session->lex().value_list.size())
1566
1581
  {
1567
1582
    my_message(ER_WRONG_VALUE_COUNT, ER(ER_WRONG_VALUE_COUNT), MYF(0));
1568
1583
    return(true);
1589
1604
  {
1590
1605
    /* it is NOT(NOT( ... )) */
1591
1606
    Item *arg= ((Item_func *) expr)->arguments()[0];
1592
 
    enum_parsing_place place= session->lex->current_select->parsing_place;
 
1607
    enum_parsing_place place= session->lex().current_select->parsing_place;
1593
1608
    if (arg->is_bool_func() || place == IN_WHERE || place == IN_HAVING)
1594
1609
      return arg;
1595
1610
    /*
1622
1637
 
1623
1638
 
1624
1639
bool check_string_char_length(LEX_STRING *str, const char *err_msg,
1625
 
                              uint32_t max_char_length, const CHARSET_INFO * const cs,
 
1640
                              uint32_t max_char_length, const charset_info_st * const cs,
1626
1641
                              bool no_error)
1627
1642
{
1628
1643
  int well_formed_error;
1647
1662
    so they should be prohibited until such support is done.
1648
1663
    This is why we use the 3-byte utf8 to check well-formedness here.
1649
1664
  */
1650
 
  const CHARSET_INFO * const cs= &my_charset_utf8mb4_general_ci;
 
1665
  const charset_info_st * const cs= &my_charset_utf8mb4_general_ci;
1651
1666
 
1652
1667
  int well_formed_error;
1653
1668
  uint32_t res= cs->cset->well_formed_len(cs, str->str, str->str + str->length,
1705
1720
 
1706
1721
  /* Parse the query. */
1707
1722
 
1708
 
  bool parse_status= DRIZZLEparse(session) != 0;
 
1723
  bool parse_status= base_sql_parse(session) != 0;
1709
1724
 
1710
1725
  /* Check that if DRIZZLEparse() failed, session->is_error() is set. */
1711
1726