← 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-02-07 22:02:41 UTC
  • Revision ID: brian@tangent.org-20090207220241-ez3828o1246ab2sp
Removing on typedeffed class.

Show diffs side-by-side

added added

removed removed

Lines of Context:
drizzled/sql_parse.cc
792
792
 
793
793
    This function is used in the parser to convert a SHOW or DESCRIBE
794
794
    table_name command to a SELECT from INFORMATION_SCHEMA.
795
 
    It prepares a SELECT_LEX and a TableList object to represent the
 
795
    It prepares a Select_Lex and a TableList object to represent the
796
796
    given command as a SELECT parse tree.
797
797
 
798
798
  @param session              thread handle
816
816
int prepare_schema_table(Session *session, LEX *lex, Table_ident *table_ident,
817
817
                         enum enum_schema_tables schema_table_idx)
818
818
{
819
 
  SELECT_LEX *schema_select_lex= NULL;
 
819
  Select_Lex *schema_select_lex= NULL;
820
820
 
821
821
  switch (schema_table_idx) {
822
822
  case SCH_SCHEMATA:
831
831
      {
832
832
        return(1);
833
833
      }
834
 
      schema_select_lex= new SELECT_LEX();
 
834
      schema_select_lex= new Select_Lex();
835
835
      db.str= schema_select_lex->db= lex->select_lex.db;
836
836
      schema_select_lex->table_list.first= NULL;
837
837
      db.length= strlen(db.str);
848
848
  {
849
849
    assert(table_ident);
850
850
    TableList **query_tables_last= lex->query_tables_last;
851
 
    schema_select_lex= new SELECT_LEX();
 
851
    schema_select_lex= new Select_Lex();
852
852
    /* 'parent_lex' is used in init_query() so it must be before it. */
853
853
    schema_select_lex->parent_lex= lex;
854
854
    schema_select_lex->init_query();
869
869
    break;
870
870
  }
871
871
 
872
 
  SELECT_LEX *select_lex= lex->current_select;
 
872
  Select_Lex *select_lex= lex->current_select;
873
873
  assert(select_lex);
874
874
  if (make_schema_select(session, select_lex, schema_table_idx))
875
875
  {
964
964
  int res= false;
965
965
  bool need_start_waiting= false; // have protection against global read lock
966
966
  LEX  *lex= session->lex;
967
 
  /* first SELECT_LEX (have special meaning for many of non-SELECTcommands) */
968
 
  SELECT_LEX *select_lex= &lex->select_lex;
969
 
  /* first table of first SELECT_LEX */
 
967
  /* first Select_Lex (have special meaning for many of non-SELECTcommands) */
 
968
  Select_Lex *select_lex= &lex->select_lex;
 
969
  /* first table of first Select_Lex */
970
970
  TableList *first_table= (TableList*) select_lex->table_list.first;
971
971
  /* list of all tables in query */
972
972
  TableList *all_tables;
973
 
  /* most outer SELECT_LEX_UNIT of query */
974
 
  SELECT_LEX_UNIT *unit= &lex->unit;
 
973
  /* most outer Select_Lex_UNIT of query */
 
974
  Select_Lex_UNIT *unit= &lex->unit;
975
975
  /* Saved variable value */
976
976
 
977
977
  /*
978
 
    In many cases first table of main SELECT_LEX have special meaning =>
 
978
    In many cases first table of main Select_Lex have special meaning =>
979
979
    check that it is first table in global list and relink it first in
980
980
    queries_tables list if it is necessary (we need such relinking only
981
981
    for queries with subqueries in select list, in this case tables of
982
982
    subqueries will go to global list first)
983
983
 
984
 
    all_tables will differ from first_table only if most upper SELECT_LEX
 
984
    all_tables will differ from first_table only if most upper Select_Lex
985
985
    do not contain tables.
986
986
 
987
987
    Because of above in place where should be at least one table in most
988
 
    outer SELECT_LEX we have following check:
 
988
    outer Select_Lex we have following check:
989
989
    assert(first_table == all_tables);
990
990
    assert(first_table == all_tables && first_table != 0);
991
991
  */
1202
1202
                                       select_tables)))
1203
1203
        {
1204
1204
          /*
1205
 
            CREATE from SELECT give its SELECT_LEX for SELECT,
 
1205
            CREATE from SELECT give its Select_Lex for SELECT,
1206
1206
            and item_list belong to SELECT
1207
1207
          */
1208
1208
          res= handle_select(session, lex, result, 0);
2038
2038
  bool res;
2039
2039
  /* assign global limit variable if limit is not given */
2040
2040
  {
2041
 
    SELECT_LEX *param= lex->unit.global_parameters;
 
2041
    Select_Lex *param= lex->unit.global_parameters;
2042
2042
    if (!param->explicit_limit)
2043
2043
      param->select_limit=
2044
2044
        new Item_int((uint64_t) session->variables.select_limit);
2122
2122
void
2123
2123
mysql_init_select(LEX *lex)
2124
2124
{
2125
 
  SELECT_LEX *select_lex= lex->current_select;
 
2125
  Select_Lex *select_lex= lex->current_select;
2126
2126
  select_lex->init_select();
2127
2127
  lex->wild= 0;
2128
2128
  if (select_lex == &lex->select_lex)
2136
2136
bool
2137
2137
mysql_new_select(LEX *lex, bool move_down)
2138
2138
{
2139
 
  SELECT_LEX *select_lex;
 
2139
  Select_Lex *select_lex;
2140
2140
  Session *session= lex->session;
2141
2141
 
2142
 
  if (!(select_lex= new (session->mem_root) SELECT_LEX()))
 
2142
  if (!(select_lex= new (session->mem_root) Select_Lex()))
2143
2143
    return(1);
2144
2144
  select_lex->select_number= ++session->select_number;
2145
2145
  select_lex->parent_lex= lex; /* Used in init_query. */
2154
2154
  select_lex->nest_level= lex->nest_level;
2155
2155
  if (move_down)
2156
2156
  {
2157
 
    SELECT_LEX_UNIT *unit;
 
2157
    Select_Lex_UNIT *unit;
2158
2158
    lex->subqueries= true;
2159
2159
    /* first select_lex of subselect or derived table */
2160
 
    if (!(unit= new (session->mem_root) SELECT_LEX_UNIT()))
 
2160
    if (!(unit= new (session->mem_root) Select_Lex_UNIT()))
2161
2161
      return(1);
2162
2162
 
2163
2163
    unit->init_query();
2182
2182
      return(1);
2183
2183
    }
2184
2184
    select_lex->include_neighbour(lex->current_select);
2185
 
    SELECT_LEX_UNIT *unit= select_lex->master_unit();
 
2185
    Select_Lex_UNIT *unit= select_lex->master_unit();
2186
2186
    if (!unit->fake_select_lex && unit->add_fake_select_lex(lex->session))
2187
2187
      return(1);
2188
2188
    select_lex->context.outer_context=
2190
2190
  }
2191
2191
 
2192
2192
  select_lex->master_unit()->global_parameters= select_lex;
2193
 
  select_lex->include_global((st_select_lex_node**)&lex->all_selects_list);
 
2193
  select_lex->include_global((Select_Lex_node**)&lex->all_selects_list);
2194
2194
  lex->current_select= select_lex;
2195
2195
  /*
2196
2196
    in subquery is SELECT query and we allow resolution of names in SELECT
2524
2524
    \#  Pointer to TableList element added to the total table list
2525
2525
*/
2526
2526
 
2527
 
TableList *st_select_lex::add_table_to_list(Session *session,
 
2527
TableList *Select_Lex::add_table_to_list(Session *session,
2528
2528
                                             Table_ident *table,
2529
2529
                                             LEX_STRING *alias,
2530
2530
                                             uint32_t table_options,
2672
2672
    The function initializes a structure of the TableList type
2673
2673
    for a nested join. It sets up its nested join list as empty.
2674
2674
    The created structure is added to the front of the current
2675
 
    join list in the st_select_lex object. Then the function
 
2675
    join list in the Select_Lex object. Then the function
2676
2676
    changes the current nest level for joins to refer to the newly
2677
2677
    created empty list after having saved the info on the old level
2678
2678
    in the initialized structure.
2685
2685
    1   otherwise
2686
2686
*/
2687
2687
 
2688
 
bool st_select_lex::init_nested_join(Session *session)
 
2688
bool Select_Lex::init_nested_join(Session *session)
2689
2689
{
2690
2690
  TableList *ptr;
2691
2691
  nested_join_st *nested_join;
2721
2721
    - 0, otherwise
2722
2722
*/
2723
2723
 
2724
 
TableList *st_select_lex::end_nested_join(Session *)
 
2724
TableList *Select_Lex::end_nested_join(Session *)
2725
2725
{
2726
2726
  TableList *ptr;
2727
2727
  nested_join_st *nested_join;
2762
2762
    \#  Pointer to TableList element created for the new nested join
2763
2763
*/
2764
2764
 
2765
 
TableList *st_select_lex::nest_last_join(Session *session)
 
2765
TableList *Select_Lex::nest_last_join(Session *session)
2766
2766
{
2767
2767
  TableList *ptr;
2768
2768
  nested_join_st *nested_join;
2807
2807
  Add a table to the current join list.
2808
2808
 
2809
2809
    The function puts a table in front of the current join list
2810
 
    of st_select_lex object.
 
2810
    of Select_Lex object.
2811
2811
    Thus, joined tables are put into this list in the reverse order
2812
2812
    (the most outer join operation follows first).
2813
2813
 
2817
2817
    None
2818
2818
*/
2819
2819
 
2820
 
void st_select_lex::add_joined_table(TableList *table)
 
2820
void Select_Lex::add_joined_table(TableList *table)
2821
2821
{
2822
2822
  join_list->push_front(table);
2823
2823
  table->join_list= join_list;
2857
2857
    - 0, otherwise
2858
2858
*/
2859
2859
 
2860
 
TableList *st_select_lex::convert_right_join()
 
2860
TableList *Select_Lex::convert_right_join()
2861
2861
{
2862
2862
  TableList *tab2= join_list->pop();
2863
2863
  TableList *tab1= join_list->pop();
2880
2880
    query
2881
2881
*/
2882
2882
 
2883
 
void st_select_lex::set_lock_for_tables(thr_lock_type lock_type)
 
2883
void Select_Lex::set_lock_for_tables(thr_lock_type lock_type)
2884
2884
{
2885
2885
  bool for_update= lock_type >= TL_READ_NO_INSERT;
2886
2886
 
2896
2896
 
2897
2897
 
2898
2898
/**
2899
 
  Create a fake SELECT_LEX for a unit.
 
2899
  Create a fake Select_Lex for a unit.
2900
2900
 
2901
 
    The method create a fake SELECT_LEX object for a unit.
 
2901
    The method create a fake Select_Lex object for a unit.
2902
2902
    This object is created for any union construct containing a union
2903
2903
    operation and also for any single select union construct of the form
2904
2904
    @verbatim
2921
2921
    0     on success
2922
2922
*/
2923
2923
 
2924
 
bool st_select_lex_unit::add_fake_select_lex(Session *session_arg)
 
2924
bool Select_Lex_unit::add_fake_select_lex(Session *session_arg)
2925
2925
{
2926
 
  SELECT_LEX *first_sl= first_select();
 
2926
  Select_Lex *first_sl= first_select();
2927
2927
  assert(!fake_select_lex);
2928
2928
 
2929
 
  if (!(fake_select_lex= new (session_arg->mem_root) SELECT_LEX()))
 
2929
  if (!(fake_select_lex= new (session_arg->mem_root) Select_Lex()))
2930
2930
      return(1);
2931
2931
  fake_select_lex->include_standalone(this,
2932
 
                                      (SELECT_LEX_NODE**)&fake_select_lex);
 
2932
                                      (Select_Lex_NODE**)&fake_select_lex);
2933
2933
  fake_select_lex->select_number= INT_MAX;
2934
2934
  fake_select_lex->parent_lex= session_arg->lex; /* Used in init_query. */
2935
2935
  fake_select_lex->make_empty_select();
3061
3061
*/
3062
3062
 
3063
3063
void add_join_natural(TableList *a, TableList *b, List<String> *using_fields,
3064
 
                      SELECT_LEX *lex)
 
3064
                      Select_Lex *lex)
3065
3065
{
3066
3066
  b->natural_join= a;
3067
3067
  lex->prev_join_using= using_fields;
3294
3294
Item * all_any_subquery_creator(Item *left_expr,
3295
3295
                                chooser_compare_func_creator cmp,
3296
3296
                                bool all,
3297
 
                                SELECT_LEX *select_lex)
 
3297
                                Select_Lex *select_lex)
3298
3298
{
3299
3299
  if ((cmp == &comp_eq_creator) && !all)       //  = ANY <=> IN
3300
3300
    return new Item_in_subselect(left_expr, select_lex);
3327
3327
{
3328
3328
  const char *msg= 0;
3329
3329
  LEX *lex= session->lex;
3330
 
  SELECT_LEX *select_lex= &lex->select_lex;
 
3330
  Select_Lex *select_lex= &lex->select_lex;
3331
3331
 
3332
3332
  if (session->lex->select_lex.item_list.elements != session->lex->value_list.elements)
3333
3333
  {
3364
3364
 
3365
3365
bool multi_delete_precheck(Session *session, TableList *)
3366
3366
{
3367
 
  SELECT_LEX *select_lex= &session->lex->select_lex;
 
3367
  Select_Lex *select_lex= &session->lex->select_lex;
3368
3368
  TableList **save_query_tables_own_last= session->lex->query_tables_own_last;
3369
3369
 
3370
3370
  session->lex->query_tables_own_last= 0;