← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to drizzled/sql_parse.cc

  • Committer: Stewart Smith
  • Author(s): Vasil Dimov, Stewart Smith
  • Date: 2010-12-20 02:24:00 UTC
  • mto: (2021.1.2 build)
  • mto: This revision was merged to the branch mainline in revision 2022.
  • Revision ID: stewart@flamingspork.com-20101220022400-0p9lvvppwgaowdju
Merge Revision revid:vasil.dimov@oracle.com-20101102165720-164z3666y3tut4c2 from MySQL InnoDB

Original revid:vasil.dimov@oracle.com-20101102165720-164z3666y3tut4c2

Original Authors: Vasil Dimov <vasil.dimov@oracle.com>
Original commit message:
Fix Bug#53046 dict_update_statistics_low can still be run concurrently on same table

Replace the array of mutexes that used to protect
dict_index_t::stat_n_diff_key_vals[] with an array of rw locks that protects
all the stats related members in dict_table_t and all of its indexes.

Approved by:    Jimmy (rb://503)

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
20
#include <drizzled/my_hash.h>
23
21
#include <drizzled/error.h>
24
22
#include <drizzled/nested_join.h>
25
23
#include <drizzled/query_id.h>
26
 
#include <drizzled/transaction_services.h>
 
24
#include "drizzled/transaction_services.h"
27
25
#include <drizzled/sql_parse.h>
28
26
#include <drizzled/data_home.h>
29
27
#include <drizzled/sql_base.h>
30
28
#include <drizzled/show.h>
 
29
#include <drizzled/db.h>
31
30
#include <drizzled/function/time/unix_timestamp.h>
32
31
#include <drizzled/function/get_system_var.h>
33
32
#include <drizzled/item/cmpfunc.h>
34
33
#include <drizzled/item/null.h>
35
34
#include <drizzled/session.h>
36
 
#include <drizzled/session/cache.h>
37
35
#include <drizzled/sql_load.h>
38
36
#include <drizzled/lock.h>
39
37
#include <drizzled/select_send.h>
40
38
#include <drizzled/plugin/client.h>
41
39
#include <drizzled/statement.h>
42
40
#include <drizzled/statement/alter_table.h>
43
 
#include <drizzled/probes.h>
44
 
#include <drizzled/global_charset_info.h>
45
 
 
46
 
#include <drizzled/plugin/logging.h>
47
 
#include <drizzled/plugin/query_rewrite.h>
48
 
#include <drizzled/plugin/query_cache.h>
49
 
#include <drizzled/plugin/authorization.h>
50
 
#include <drizzled/optimizer/explain_plan.h>
51
 
#include <drizzled/pthread_globals.h>
52
 
#include <drizzled/plugin/event_observer.h>
53
 
#include <drizzled/visibility.h>
54
 
 
55
 
#include <drizzled/schema.h>
 
41
#include "drizzled/probes.h"
 
42
#include "drizzled/session/cache.h"
 
43
#include "drizzled/global_charset_info.h"
 
44
 
 
45
#include "drizzled/plugin/logging.h"
 
46
#include "drizzled/plugin/query_rewrite.h"
 
47
#include "drizzled/plugin/query_cache.h"
 
48
#include "drizzled/plugin/authorization.h"
 
49
#include "drizzled/optimizer/explain_plan.h"
 
50
#include "drizzled/pthread_globals.h"
 
51
#include "drizzled/plugin/event_observer.h"
56
52
 
57
53
#include <limits.h>
58
54
 
59
55
#include <bitset>
60
56
#include <algorithm>
61
57
#include <boost/date_time.hpp>
62
 
#include <drizzled/internal/my_sys.h>
 
58
#include "drizzled/internal/my_sys.h"
63
59
 
64
60
using namespace std;
65
61
 
66
 
extern int base_sql_parse(drizzled::Session *session); // from sql_yacc.cc
 
62
extern int DRIZZLEparse(void *session); // from sql_yacc.cc
67
63
 
68
64
namespace drizzled
69
65
{
70
66
 
71
67
/* Prototypes */
72
 
bool my_yyoverflow(short **a, ParserType **b, ulong *yystacksize);
 
68
bool my_yyoverflow(short **a, YYSTYPE **b, ulong *yystacksize);
73
69
static bool parse_sql(Session *session, Lex_input_stream *lip);
74
 
void parse(Session *session, const char *inBuf, uint32_t length);
 
70
void mysql_parse(Session *session, const char *inBuf, uint32_t length);
75
71
 
76
72
/**
77
73
  @defgroup Runtime_Environment Runtime Environment
81
77
extern size_t my_thread_stack_size;
82
78
extern const CHARSET_INFO *character_set_filesystem;
83
79
 
84
 
namespace
85
 
{
86
 
 
87
 
static const std::string command_name[COM_END+1]={
88
 
  "Sleep",
89
 
  "Quit",
90
 
  "Init DB",
91
 
  "Query",
92
 
  "Shutdown",
93
 
  "Connect",
94
 
  "Ping",
95
 
  "Error"  // Last command number
 
80
const LEX_STRING command_name[COM_END+1]={
 
81
  { C_STRING_WITH_LEN("Sleep") },
 
82
  { C_STRING_WITH_LEN("Quit") },
 
83
  { C_STRING_WITH_LEN("Init DB") },
 
84
  { C_STRING_WITH_LEN("Query") },
 
85
  { C_STRING_WITH_LEN("Shutdown") },
 
86
  { C_STRING_WITH_LEN("Connect") },
 
87
  { C_STRING_WITH_LEN("Ping") },
 
88
  { C_STRING_WITH_LEN("Error") }  // Last command number
96
89
};
97
90
 
98
 
}
99
 
 
100
91
const char *xa_state_names[]={
101
92
  "NON-EXISTING", "ACTIVE", "IDLE", "PREPARED"
102
93
};
115
106
*/
116
107
bitset<CF_BIT_SIZE> sql_command_flags[SQLCOM_END+1];
117
108
 
118
 
const std::string &getCommandName(const enum_server_command& command)
119
 
{
120
 
  return command_name[command];
121
 
}
122
 
 
123
109
void init_update_queries(void)
124
110
{
125
111
  uint32_t x;
168
154
                         can be zero.
169
155
 
170
156
  @todo
171
 
    set session->getLex()->sql_command to SQLCOM_END here.
 
157
    set session->lex->sql_command to SQLCOM_END here.
172
158
  @todo
173
159
    The following has to be changed to an 8 byte integer
174
160
 
187
173
  DRIZZLE_COMMAND_START(session->thread_id, command);
188
174
 
189
175
  session->command= command;
190
 
  session->getLex()->sql_command= SQLCOM_END; /* to avoid confusing VIEW detectors */
 
176
  session->lex->sql_command= SQLCOM_END; /* to avoid confusing VIEW detectors */
191
177
  session->set_time();
192
178
  session->setQueryId(query_id.value());
193
179
 
201
187
    query_id.next();
202
188
  }
203
189
 
204
 
  /* @todo set session->getLex()->sql_command to SQLCOM_END here */
 
190
  /* TODO: set session->lex->sql_command to SQLCOM_END here */
205
191
 
206
192
  plugin::Logging::preDo(session);
207
193
  if (unlikely(plugin::EventObserver::beforeStatement(*session)))
222
208
 
223
209
    string tmp(packet, packet_length);
224
210
 
225
 
    identifier::Schema identifier(tmp);
 
211
    SchemaIdentifier identifier(tmp);
226
212
 
227
 
    if (not schema::change(*session, identifier))
 
213
    if (not mysql_change_db(session, identifier))
228
214
    {
229
215
      session->my_ok();
230
216
    }
238
224
                        session->thread_id,
239
225
                        const_cast<const char *>(session->schema()->c_str()));
240
226
 
241
 
    parse(session, session->getQueryString()->c_str(), session->getQueryString()->length());
 
227
    mysql_parse(session, session->getQueryString()->c_str(), session->getQueryString()->length());
242
228
 
243
229
    break;
244
230
  }
271
257
  /* If commit fails, we should be able to reset the OK status. */
272
258
  session->main_da.can_overwrite_status= true;
273
259
  TransactionServices &transaction_services= TransactionServices::singleton();
274
 
  transaction_services.autocommitOrRollback(*session, session->is_error());
 
260
  transaction_services.autocommitOrRollback(session, session->is_error());
275
261
  session->main_da.can_overwrite_status= false;
276
262
 
277
263
  session->transaction.stmt.reset();
296
282
  {
297
283
  case Diagnostics_area::DA_ERROR:
298
284
    /* The query failed, send error to log and abort bootstrap. */
299
 
    session->getClient()->sendError(session->main_da.sql_errno(),
 
285
    session->client->sendError(session->main_da.sql_errno(),
300
286
                               session->main_da.message());
301
287
    break;
302
288
 
303
289
  case Diagnostics_area::DA_EOF:
304
 
    session->getClient()->sendEOF();
 
290
    session->client->sendEOF();
305
291
    break;
306
292
 
307
293
  case Diagnostics_area::DA_OK:
308
 
    session->getClient()->sendOK();
 
294
    session->client->sendOK();
309
295
    break;
310
296
 
311
297
  case Diagnostics_area::DA_DISABLED:
313
299
 
314
300
  case Diagnostics_area::DA_EMPTY:
315
301
  default:
316
 
    session->getClient()->sendOK();
 
302
    session->client->sendOK();
317
303
    break;
318
304
  }
319
305
 
443
429
    true        Error
444
430
*/
445
431
 
446
 
static int execute_command(Session *session)
 
432
static int mysql_execute_command(Session *session)
447
433
{
448
434
  bool res= false;
449
 
 
 
435
  LEX  *lex= session->lex;
450
436
  /* first Select_Lex (have special meaning for many of non-SELECTcommands) */
451
 
  Select_Lex *select_lex= &session->getLex()->select_lex;
452
 
 
 
437
  Select_Lex *select_lex= &lex->select_lex;
453
438
  /* list of all tables in query */
454
439
  TableList *all_tables;
455
440
 
468
453
    assert(first_table == all_tables);
469
454
    assert(first_table == all_tables && first_table != 0);
470
455
  */
471
 
  session->getLex()->first_lists_tables_same();
472
 
 
 
456
  lex->first_lists_tables_same();
473
457
  /* should be assigned after making first tables same */
474
 
  all_tables= session->getLex()->query_tables;
475
 
 
 
458
  all_tables= lex->query_tables;
476
459
  /* set context for commands which do not use setup_tables */
477
 
  select_lex->context.resolve_in_table_list_only((TableList*)select_lex->table_list.first);
 
460
  select_lex->
 
461
    context.resolve_in_table_list_only((TableList*)select_lex->
 
462
                                       table_list.first);
478
463
 
479
464
  /*
480
465
    Reset warning count for each query that uses tables
483
468
    variables, but for now this is probably good enough.
484
469
    Don't reset warnings when executing a stored routine.
485
470
  */
486
 
  if (all_tables || ! session->getLex()->is_single_level_stmt())
 
471
  if (all_tables || ! lex->is_single_level_stmt())
487
472
  {
488
473
    drizzle_reset_errors(session, 0);
489
474
  }
490
475
 
491
476
  assert(session->transaction.stmt.hasModifiedNonTransData() == false);
492
477
 
493
 
  if (! (session->server_status & SERVER_STATUS_AUTOCOMMIT)
494
 
      && ! session->inTransaction()
495
 
      && session->getLex()->statement->isTransactional())
496
 
  {
497
 
    if (session->startTransaction() == false)
498
 
    {
499
 
      my_error(drizzled::ER_UNKNOWN_ERROR, MYF(0));
500
 
      return true;
501
 
    }
502
 
  }
503
 
 
504
478
  /* now we are ready to execute the statement */
505
 
  res= session->getLex()->statement->execute();
 
479
  res= lex->statement->execute();
506
480
  session->set_proc_info("query end");
507
481
  /*
508
482
    The return value for ROW_COUNT() is "implementation dependent" if the
510
484
    wants. We also keep the last value in case of SQLCOM_CALL or
511
485
    SQLCOM_EXECUTE.
512
486
  */
513
 
  if (! (sql_command_flags[session->getLex()->sql_command].test(CF_BIT_HAS_ROW_COUNT)))
 
487
  if (! (sql_command_flags[lex->sql_command].test(CF_BIT_HAS_ROW_COUNT)))
514
488
  {
515
489
    session->row_count_func= -1;
516
490
  }
519
493
}
520
494
bool execute_sqlcom_select(Session *session, TableList *all_tables)
521
495
{
522
 
  LEX   *lex= session->getLex();
 
496
  LEX   *lex= session->lex;
523
497
  select_result *result=lex->result;
524
498
  bool res= false;
525
499
  /* assign global limit variable if limit is not given */
529
503
      param->select_limit=
530
504
        new Item_int((uint64_t) session->variables.select_limit);
531
505
  }
532
 
 
533
 
  if (all_tables
534
 
      && ! (session->server_status & SERVER_STATUS_AUTOCOMMIT)
535
 
      && ! session->inTransaction()
536
 
      && ! lex->statement->isShow())
537
 
  {
538
 
    if (session->startTransaction() == false)
539
 
    {
540
 
      my_error(drizzled::ER_UNKNOWN_ERROR, MYF(0));
541
 
      return true;
542
 
    }
543
 
  }
544
 
 
545
506
  if (not (res= session->openTablesLock(all_tables)))
546
507
  {
547
508
    if (lex->describe)
556
517
        return true;
557
518
      session->send_explain_fields(result);
558
519
      optimizer::ExplainPlan planner;
559
 
      res= planner.explainUnion(session, &session->getLex()->unit, result);
 
520
      res= planner.explainUnion(session, &session->lex->unit, result);
560
521
      if (lex->describe & DESCRIBE_EXTENDED)
561
522
      {
562
523
        char buff[1024];
563
524
        String str(buff,(uint32_t) sizeof(buff), system_charset_info);
564
525
        str.length(0);
565
 
        session->getLex()->unit.print(&str, QT_ORDINARY);
 
526
        session->lex->unit.print(&str, QT_ORDINARY);
566
527
        str.append('\0');
567
528
        push_warning(session, DRIZZLE_ERROR::WARN_LEVEL_NOTE,
568
529
                     ER_YES, str.ptr());
571
532
        result->abort();
572
533
      else
573
534
        result->send_eof();
574
 
 
575
535
      delete result;
576
536
    }
577
537
    else
596
556
#define MY_YACC_INIT 1000                       // Start with big alloc
597
557
#define MY_YACC_MAX  32000                      // Because of 'short'
598
558
 
599
 
bool my_yyoverflow(short **yyss, ParserType **yyvs, ulong *yystacksize)
 
559
bool my_yyoverflow(short **yyss, YYSTYPE **yyvs, ulong *yystacksize)
600
560
{
601
 
  LEX   *lex= current_session->getLex();
 
561
  LEX   *lex= current_session->lex;
602
562
  ulong old_info=0;
603
563
  if ((uint32_t) *yystacksize >= MY_YACC_MAX)
604
564
    return 1;
621
581
    memcpy(lex->yacc_yyvs, *yyvs, old_info*sizeof(**yyvs));
622
582
  }
623
583
  *yyss=(short*) lex->yacc_yyss;
624
 
  *yyvs=(ParserType*) lex->yacc_yyvs;
 
584
  *yyvs=(YYSTYPE*) lex->yacc_yyvs;
625
585
  return 0;
626
586
}
627
587
 
628
588
 
629
589
void
630
 
init_select(LEX *lex)
 
590
mysql_init_select(LEX *lex)
631
591
{
632
592
  Select_Lex *select_lex= lex->current_select;
633
593
  select_lex->init_select();
641
601
 
642
602
 
643
603
bool
644
 
new_select(LEX *lex, bool move_down)
 
604
mysql_new_select(LEX *lex, bool move_down)
645
605
{
646
606
  Select_Lex *select_lex;
647
607
  Session *session= lex->session;
648
608
 
649
609
  if (!(select_lex= new (session->mem_root) Select_Lex()))
650
 
    return true;
651
 
 
 
610
    return(1);
652
611
  select_lex->select_number= ++session->select_number;
653
612
  select_lex->parent_lex= lex; /* Used in init_query. */
654
613
  select_lex->init_query();
655
614
  select_lex->init_select();
656
615
  lex->nest_level++;
657
 
 
658
616
  if (lex->nest_level > (int) MAX_SELECT_NESTING)
659
617
  {
660
618
    my_error(ER_TOO_HIGH_LEVEL_OF_NESTING_FOR_SELECT,MYF(0),MAX_SELECT_NESTING);
661
619
    return(1);
662
620
  }
663
 
 
664
621
  select_lex->nest_level= lex->nest_level;
665
622
  if (move_down)
666
623
  {
688
645
    if (lex->current_select->order_list.first && !lex->current_select->braces)
689
646
    {
690
647
      my_error(ER_WRONG_USAGE, MYF(0), "UNION", "order_st BY");
691
 
      return true;
 
648
      return(1);
692
649
    }
693
 
 
694
650
    select_lex->include_neighbour(lex->current_select);
695
651
    Select_Lex_Unit *unit= select_lex->master_unit();
696
 
 
697
 
    if (not unit->fake_select_lex && unit->add_fake_select_lex(lex->session))
698
 
      return true;
699
 
 
 
652
    if (!unit->fake_select_lex && unit->add_fake_select_lex(lex->session))
 
653
      return(1);
700
654
    select_lex->context.outer_context=
701
655
                unit->first_select()->context.outer_context;
702
656
  }
709
663
    list
710
664
  */
711
665
  select_lex->context.resolve_in_select_list= true;
712
 
 
713
 
  return false;
 
666
  return(0);
714
667
}
715
668
 
716
669
/**
723
676
  @param var_name               Variable name
724
677
*/
725
678
 
726
 
void create_select_for_variable(Session *session, const char *var_name)
 
679
void create_select_for_variable(const char *var_name)
727
680
{
 
681
  Session *session;
728
682
  LEX *lex;
729
683
  LEX_STRING tmp, null_lex_string;
730
684
  Item *var;
731
685
  char buff[MAX_SYS_VAR_LENGTH*2+4+8];
732
686
  char *end= buff;
733
687
 
734
 
  lex= session->getLex();
735
 
  init_select(lex);
 
688
  session= current_session;
 
689
  lex= session->lex;
 
690
  mysql_init_select(lex);
736
691
  lex->sql_command= SQLCOM_SELECT;
737
692
  tmp.str= (char*) var_name;
738
693
  tmp.length=strlen(var_name);
747
702
    var->set_name(buff, end-buff, system_charset_info);
748
703
    session->add_item_to_list(var);
749
704
  }
 
705
  return;
750
706
}
751
707
 
752
708
 
758
714
  @param       length  Length of the query text
759
715
*/
760
716
 
761
 
void parse(Session *session, const char *inBuf, uint32_t length)
 
717
void mysql_parse(Session *session, const char *inBuf, uint32_t length)
762
718
{
763
 
  session->getLex()->start(session);
 
719
  boost::posix_time::ptime start_time=boost::posix_time::microsec_clock::local_time();
 
720
  session->lex->start(session);
764
721
 
765
722
  session->reset_for_next_command();
766
723
  /* Check if the Query is Cached if and return true if yes
776
733
  {
777
734
    return;
778
735
  }
779
 
  LEX *lex= session->getLex();
 
736
  LEX *lex= session->lex;
780
737
  Lex_input_stream lip(session, inBuf, length);
781
738
  bool err= parse_sql(session, &lip);
782
739
  if (!err)
791
748
        /* Actually execute the query */
792
749
        try 
793
750
        {
794
 
          execute_command(session);
 
751
          mysql_execute_command(session);
795
752
        }
796
753
        catch (...)
797
754
        {
798
755
          // Just try to catch any random failures that could have come
799
756
          // during execution.
800
 
          DRIZZLE_ABORT;
 
757
          unireg_abort(1);
801
758
        }
802
759
        DRIZZLE_QUERY_EXEC_DONE(0);
803
760
      }
811
768
  session->set_proc_info("freeing items");
812
769
  session->end_statement();
813
770
  session->cleanup_after_query();
814
 
  session->set_end_timer();
 
771
  boost::posix_time::ptime end_time=boost::posix_time::microsec_clock::local_time();
 
772
  session->status_var.execution_time_nsec+=(end_time-start_time).total_microseconds();
815
773
}
816
774
 
817
775
 
833
791
                       List<String> *interval_list, const CHARSET_INFO * const cs)
834
792
{
835
793
  register CreateField *new_field;
836
 
  LEX  *lex= session->getLex();
 
794
  LEX  *lex= session->lex;
837
795
  statement::AlterTable *statement= (statement::AlterTable *)lex->statement;
838
796
 
839
797
  if (check_identifier_name(field_name, ER_TOO_LONG_IDENT))
847
805
                      &default_key_create_info,
848
806
                      0, lex->col_list);
849
807
    statement->alter_info.key_list.push_back(key);
850
 
    lex->col_list.clear();
 
808
    lex->col_list.empty();
851
809
  }
852
810
  if (type_modifier & (UNIQUE_FLAG | UNIQUE_KEY_FLAG))
853
811
  {
857
815
                 &default_key_create_info, 0,
858
816
                 lex->col_list);
859
817
    statement->alter_info.key_list.push_back(key);
860
 
    lex->col_list.clear();
 
818
    lex->col_list.empty();
861
819
  }
862
820
 
863
821
  if (default_value)
871
829
    */
872
830
    if (default_value->type() == Item::FUNC_ITEM &&
873
831
        !(((Item_func*)default_value)->functype() == Item_func::NOW_FUNC &&
874
 
         (type == DRIZZLE_TYPE_TIMESTAMP or type == DRIZZLE_TYPE_MICROTIME)))
 
832
         type == DRIZZLE_TYPE_TIMESTAMP))
875
833
    {
876
834
      my_error(ER_INVALID_DEFAULT, MYF(0), field_name->str);
877
835
      return true;
879
837
    else if (default_value->type() == Item::NULL_ITEM)
880
838
    {
881
839
      default_value= 0;
882
 
      if ((type_modifier & (NOT_NULL_FLAG | AUTO_INCREMENT_FLAG)) == NOT_NULL_FLAG)
 
840
      if ((type_modifier & (NOT_NULL_FLAG | AUTO_INCREMENT_FLAG)) ==
 
841
          NOT_NULL_FLAG)
883
842
      {
884
843
        my_error(ER_INVALID_DEFAULT, MYF(0), field_name->str);
885
844
        return true;
892
851
    }
893
852
  }
894
853
 
895
 
  if (on_update_value && (type != DRIZZLE_TYPE_TIMESTAMP and type != DRIZZLE_TYPE_MICROTIME))
 
854
  if (on_update_value && type != DRIZZLE_TYPE_TIMESTAMP)
896
855
  {
897
856
    my_error(ER_INVALID_ON_UPDATE, MYF(0), field_name->str);
898
857
    return true;
911
870
}
912
871
 
913
872
 
 
873
/** Store position for column in ALTER TABLE .. ADD column. */
 
874
 
 
875
void store_position_for_column(const char *name)
 
876
{
 
877
  current_session->lex->last_field->after=const_cast<char*> (name);
 
878
}
 
879
 
914
880
/**
915
881
  Add a table to list of used tables.
916
882
 
931
897
*/
932
898
 
933
899
TableList *Select_Lex::add_table_to_list(Session *session,
934
 
                                         Table_ident *table,
935
 
                                         LEX_STRING *alias,
936
 
                                         const bitset<NUM_OF_TABLE_OPTIONS>& table_options,
937
 
                                         thr_lock_type lock_type,
938
 
                                         List<Index_hint> *index_hints_arg,
 
900
                                                             Table_ident *table,
 
901
                                                             LEX_STRING *alias,
 
902
                                                             const bitset<NUM_OF_TABLE_OPTIONS>& table_options,
 
903
                                                             thr_lock_type lock_type,
 
904
                                                             List<Index_hint> *index_hints_arg,
939
905
                                         LEX_STRING *option)
940
906
{
941
907
  TableList *ptr;
942
908
  TableList *previous_table_ref; /* The table preceding the current one. */
943
909
  char *alias_str;
944
 
  LEX *lex= session->getLex();
 
910
  LEX *lex= session->lex;
945
911
 
946
912
  if (!table)
947
913
    return NULL;                                // End of memory
957
923
  {
958
924
    my_casedn_str(files_charset_info, table->db.str);
959
925
 
960
 
    identifier::Schema schema_identifier(string(table->db.str));
961
 
    if (not schema::check(*session, schema_identifier))
 
926
    SchemaIdentifier schema_identifier(string(table->db.str));
 
927
    if (not check_db_name(session, schema_identifier))
962
928
    {
963
929
 
964
930
      my_error(ER_WRONG_DB_NAME, MYF(0), table->db.str);
974
940
                 ER(ER_DERIVED_MUST_HAVE_ALIAS), MYF(0));
975
941
      return NULL;
976
942
    }
977
 
    if (!(alias_str= (char*) session->getMemRoot()->duplicate(alias_str,table->table.length+1)))
 
943
    if (!(alias_str= (char*) session->memdup(alias_str,table->table.length+1)))
978
944
      return NULL;
979
945
  }
980
946
  if (!(ptr = (TableList *) session->calloc(sizeof(TableList))))
1010
976
         tables ;
1011
977
         tables=tables->next_local)
1012
978
    {
1013
 
      if (not my_strcasecmp(table_alias_charset, alias_str, tables->alias) &&
1014
 
          not my_strcasecmp(system_charset_info, ptr->getSchemaName(), tables->getSchemaName()))
 
979
      if (!my_strcasecmp(table_alias_charset, alias_str, tables->alias) &&
 
980
          !strcasecmp(ptr->getSchemaName(), tables->getSchemaName()))
1015
981
      {
1016
982
        my_error(ER_NONUNIQ_TABLE, MYF(0), alias_str);
1017
983
        return NULL;
1075
1041
bool Select_Lex::init_nested_join(Session *session)
1076
1042
{
1077
1043
  TableList *ptr;
1078
 
  NestedJoin *nested_join;
 
1044
  nested_join_st *nested_join;
1079
1045
 
1080
1046
  if (!(ptr= (TableList*) session->calloc(ALIGN_SIZE(sizeof(TableList))+
1081
 
                                       sizeof(NestedJoin))))
 
1047
                                       sizeof(nested_join_st))))
1082
1048
    return true;
1083
 
  ptr->setNestedJoin(((NestedJoin*) ((unsigned char*) ptr + ALIGN_SIZE(sizeof(TableList)))));
 
1049
  ptr->setNestedJoin(((nested_join_st*) ((unsigned char*) ptr + ALIGN_SIZE(sizeof(TableList)))));
1084
1050
  nested_join= ptr->getNestedJoin();
1085
1051
  join_list->push_front(ptr);
1086
1052
  ptr->setEmbedding(embedding);
1088
1054
  ptr->alias= (char*) "(nested_join)";
1089
1055
  embedding= ptr;
1090
1056
  join_list= &nested_join->join_list;
1091
 
  join_list->clear();
 
1057
  join_list->empty();
1092
1058
  return false;
1093
1059
}
1094
1060
 
1110
1076
TableList *Select_Lex::end_nested_join(Session *)
1111
1077
{
1112
1078
  TableList *ptr;
1113
 
  NestedJoin *nested_join;
 
1079
  nested_join_st *nested_join;
1114
1080
 
1115
1081
  assert(embedding);
1116
1082
  ptr= embedding;
1151
1117
TableList *Select_Lex::nest_last_join(Session *session)
1152
1118
{
1153
1119
  TableList *ptr;
1154
 
  NestedJoin *nested_join;
 
1120
  nested_join_st *nested_join;
1155
1121
  List<TableList> *embedded_list;
1156
1122
 
1157
1123
  if (!(ptr= (TableList*) session->calloc(ALIGN_SIZE(sizeof(TableList))+
1158
 
                                          sizeof(NestedJoin))))
 
1124
                                          sizeof(nested_join_st))))
1159
1125
    return NULL;
1160
 
  ptr->setNestedJoin(((NestedJoin*) ((unsigned char*) ptr + ALIGN_SIZE(sizeof(TableList)))));
 
1126
  ptr->setNestedJoin(((nested_join_st*) ((unsigned char*) ptr + ALIGN_SIZE(sizeof(TableList)))));
1161
1127
  nested_join= ptr->getNestedJoin();
1162
1128
  ptr->setEmbedding(embedding);
1163
1129
  ptr->setJoinList(join_list);
1164
1130
  ptr->alias= (char*) "(nest_last_join)";
1165
1131
  embedded_list= &nested_join->join_list;
1166
 
  embedded_list->clear();
 
1132
  embedded_list->empty();
1167
1133
 
1168
1134
  for (uint32_t i=0; i < 2; i++)
1169
1135
  {
1311
1277
  fake_select_lex->include_standalone(this,
1312
1278
                                      (Select_Lex_Node**)&fake_select_lex);
1313
1279
  fake_select_lex->select_number= INT_MAX;
1314
 
  fake_select_lex->parent_lex= session_arg->getLex(); /* Used in init_query. */
 
1280
  fake_select_lex->parent_lex= session_arg->lex; /* Used in init_query. */
1315
1281
  fake_select_lex->make_empty_select();
1316
1282
  fake_select_lex->linkage= GLOBAL_OPTIONS_TYPE;
1317
1283
  fake_select_lex->select_limit= 0;
1331
1297
    */
1332
1298
    global_parameters= fake_select_lex;
1333
1299
    fake_select_lex->no_table_names_allowed= 1;
1334
 
    session_arg->getLex()->current_select= fake_select_lex;
 
1300
    session_arg->lex->current_select= fake_select_lex;
1335
1301
  }
1336
 
  session_arg->getLex()->pop_context();
 
1302
  session_arg->lex->pop_context();
1337
1303
  return(0);
1338
1304
}
1339
1305
 
1369
1335
    left_op->first_leaf_for_name_resolution();
1370
1336
  on_context->last_name_resolution_table=
1371
1337
    right_op->last_leaf_for_name_resolution();
1372
 
  return session->getLex()->push_context(on_context);
 
1338
  return session->lex->push_context(on_context);
1373
1339
}
1374
1340
 
1375
1341
 
1457
1423
    1   error   ; In this case the error messege is sent to the client
1458
1424
*/
1459
1425
 
1460
 
bool check_simple_select(Session::pointer session)
 
1426
bool check_simple_select()
1461
1427
{
1462
 
  if (session->getLex()->current_select != &session->getLex()->select_lex)
 
1428
  Session *session= current_session;
 
1429
  LEX *lex= session->lex;
 
1430
  if (lex->current_select != &lex->select_lex)
1463
1431
  {
1464
1432
    char command[80];
1465
1433
    Lex_input_stream *lip= session->m_lip;
1519
1487
bool update_precheck(Session *session, TableList *)
1520
1488
{
1521
1489
  const char *msg= 0;
1522
 
  Select_Lex *select_lex= &session->getLex()->select_lex;
 
1490
  LEX *lex= session->lex;
 
1491
  Select_Lex *select_lex= &lex->select_lex;
1523
1492
 
1524
 
  if (session->getLex()->select_lex.item_list.elements != session->getLex()->value_list.elements)
 
1493
  if (session->lex->select_lex.item_list.elements != session->lex->value_list.elements)
1525
1494
  {
1526
1495
    my_message(ER_WRONG_VALUE_COUNT, ER(ER_WRONG_VALUE_COUNT), MYF(0));
1527
1496
    return(true);
1528
1497
  }
1529
1498
 
1530
 
  if (session->getLex()->select_lex.table_list.elements > 1)
 
1499
  if (session->lex->select_lex.table_list.elements > 1)
1531
1500
  {
1532
1501
    if (select_lex->order_list.elements)
1533
1502
      msg= "ORDER BY";
1557
1526
 
1558
1527
bool insert_precheck(Session *session, TableList *)
1559
1528
{
 
1529
  LEX *lex= session->lex;
 
1530
 
1560
1531
  /*
1561
1532
    Check that we have modify privileges for the first table and
1562
1533
    select privileges for the rest
1563
1534
  */
1564
 
  if (session->getLex()->update_list.elements != session->getLex()->value_list.elements)
 
1535
  if (lex->update_list.elements != lex->value_list.elements)
1565
1536
  {
1566
1537
    my_message(ER_WRONG_VALUE_COUNT, ER(ER_WRONG_VALUE_COUNT), MYF(0));
1567
1538
    return(true);
1571
1542
 
1572
1543
 
1573
1544
/**
 
1545
  CREATE TABLE query pre-check.
 
1546
 
 
1547
  @param session                        Thread handler
 
1548
  @param tables         Global table list
 
1549
  @param create_table           Table which will be created
 
1550
 
 
1551
  @retval
 
1552
    false   OK
 
1553
  @retval
 
1554
    true   Error
 
1555
*/
 
1556
 
 
1557
bool create_table_precheck(TableIdentifier &identifier)
 
1558
{
 
1559
  if (not plugin::StorageEngine::canCreateTable(identifier))
 
1560
  {
 
1561
    my_error(ER_DBACCESS_DENIED_ERROR, MYF(0), "", "", identifier.getSchemaName().c_str());
 
1562
    return true;
 
1563
  }
 
1564
 
 
1565
  if (not plugin::StorageEngine::doesSchemaExist(identifier))
 
1566
  {
 
1567
    my_error(ER_BAD_DB_ERROR, MYF(0), identifier.getSchemaName().c_str());
 
1568
    return true;
 
1569
  }
 
1570
 
 
1571
  return false;
 
1572
}
 
1573
 
 
1574
 
 
1575
/**
1574
1576
  negate given expression.
1575
1577
 
1576
1578
  @param session  thread handler
1588
1590
  {
1589
1591
    /* it is NOT(NOT( ... )) */
1590
1592
    Item *arg= ((Item_func *) expr)->arguments()[0];
1591
 
    enum_parsing_place place= session->getLex()->current_select->parsing_place;
 
1593
    enum_parsing_place place= session->lex->current_select->parsing_place;
1592
1594
    if (arg->is_bool_func() || place == IN_WHERE || place == IN_HAVING)
1593
1595
      return arg;
1594
1596
    /*
1637
1639
}
1638
1640
 
1639
1641
 
1640
 
bool check_identifier_name(LEX_STRING *str, error_t err_code,
 
1642
bool check_identifier_name(LEX_STRING *str, uint32_t err_code,
1641
1643
                           uint32_t max_char_length,
1642
1644
                           const char *param_for_err_msg)
1643
1645
{
1663
1665
 
1664
1666
  switch (err_code)
1665
1667
  {
1666
 
  case EE_OK:
 
1668
  case 0:
1667
1669
    break;
1668
1670
  case ER_WRONG_STRING_LENGTH:
1669
1671
    my_error(err_code, MYF(0), str->str, param_for_err_msg, max_char_length);
1675
1677
    assert(0);
1676
1678
    break;
1677
1679
  }
1678
 
 
1679
1680
  return true;
1680
1681
}
1681
1682
 
1704
1705
 
1705
1706
  /* Parse the query. */
1706
1707
 
1707
 
  bool parse_status= base_sql_parse(session) != 0;
 
1708
  bool mysql_parse_status= DRIZZLEparse(session) != 0;
1708
1709
 
1709
1710
  /* Check that if DRIZZLEparse() failed, session->is_error() is set. */
1710
1711
 
1711
 
  assert(!parse_status || session->is_error());
 
1712
  assert(!mysql_parse_status || session->is_error());
1712
1713
 
1713
1714
  /* Reset Lex_input_stream. */
1714
1715
 
1715
1716
  session->m_lip= NULL;
1716
1717
 
1717
 
  DRIZZLE_QUERY_PARSE_DONE(parse_status || session->is_fatal_error);
 
1718
  DRIZZLE_QUERY_PARSE_DONE(mysql_parse_status || session->is_fatal_error);
1718
1719
 
1719
1720
  /* That's it. */
1720
1721
 
1721
 
  return parse_status || session->is_fatal_error;
 
1722
  return mysql_parse_status || session->is_fatal_error;
1722
1723
}
1723
1724
 
1724
1725
/**