← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to drizzled/sql_lex.cc

  • Committer: Jay Pipes
  • Date: 2009-09-15 21:01:42 UTC
  • mto: (1126.2.5 merge)
  • mto: This revision was merged to the branch mainline in revision 1128.
  • Revision ID: jpipes@serialcoder-20090915210142-x8mwiqn1q0vzjspp
Moves Alter_info out into its own header and source file, cleans up some related include mess in sql_lex.h, and renames Alter_info to AlterInfo.

Show diffs side-by-side

added added

removed removed

Lines of Context:
drizzled/sql_lex.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 */
 
14
   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA */
15
15
 
16
16
 
17
17
/* A lexical scanner on a temporary buffer with a yacc interface */
18
18
 
19
 
#include "config.h"
20
 
 
21
19
#define DRIZZLE_LEX 1
22
 
 
23
 
#include "drizzled/sql_reserved_words.h"
24
 
 
25
 
#include "drizzled/configmake.h"
 
20
#include "drizzled/server_includes.h"
26
21
#include "drizzled/item/num.h"
27
22
#include "drizzled/error.h"
28
23
#include "drizzled/session.h"
30
25
#include "drizzled/lookup_symbol.h"
31
26
#include "drizzled/index_hint.h"
32
27
 
33
 
#include <cstdio>
34
28
#include <ctype.h>
35
29
 
36
30
using namespace std;
37
31
 
38
 
/* Stay outside of the namespace because otherwise bison goes nuts */
 
32
static int lex_one_token(void *arg, void *yysession);
39
33
int DRIZZLElex(void *arg, void *yysession);
40
34
 
41
 
namespace drizzled
42
 
{
43
 
 
44
 
static int lex_one_token(void *arg, void *yysession);
45
 
 
46
35
/**
47
36
  save order by and tables in own lists.
48
37
*/
49
38
static bool add_to_list(Session *session, SQL_LIST &list, Item *item, bool asc)
50
39
{
51
 
  Order *order;
52
 
 
53
 
  if (!(order = (Order *) session->getMemRoot()->allocate(sizeof(Order))))
54
 
    return true;
55
 
 
 
40
  order_st *order;
 
41
  if (!(order = (order_st *) session->alloc(sizeof(order_st))))
 
42
    return(1);
56
43
  order->item_ptr= item;
57
44
  order->item= &order->item_ptr;
58
45
  order->asc = asc;
59
46
  order->free_me=0;
60
47
  order->used=0;
61
48
  order->counter_used= 0;
62
 
  list.link_in_list((unsigned char*) order, (unsigned char**) &order->next);
63
 
 
64
 
  return false;
 
49
  list.link_in_list((unsigned char*) order,(unsigned char**) &order->next);
 
50
  return(0);
65
51
}
66
52
 
 
53
 
 
54
 
 
55
/*
 
56
  We are using pointer to this variable for distinguishing between assignment
 
57
  to NEW row field (when parsing trigger definition) and structured variable.
 
58
*/
 
59
sys_var *trg_new_row_fake_var= (sys_var*) 0x01;
 
60
 
67
61
/**
68
62
  LEX_STRING constant for null-string to be used in parser and other places.
69
63
*/
71
65
 
72
66
Lex_input_stream::Lex_input_stream(Session *session,
73
67
                                   const char* buffer,
74
 
                                   unsigned int length) :
75
 
  m_session(session),
 
68
                                   unsigned int length)
 
69
: m_session(session),
76
70
  yylineno(1),
77
71
  yytoklen(0),
78
72
  yylval(NULL),
92
86
  m_body_utf8(NULL),
93
87
  m_cpp_utf8_processed_ptr(NULL),
94
88
  next_state(MY_LEX_START),
 
89
  found_semicolon(NULL),
95
90
  ignore_space(1),
96
91
  in_comment(NO_COMMENT)
97
92
{
98
 
  m_cpp_buf= (char*) session->getMemRoot()->allocate(length + 1);
 
93
  m_cpp_buf= (char*) session->alloc(length + 1);
99
94
  m_cpp_ptr= m_cpp_buf;
100
95
}
101
96
 
122
117
    (m_buf_length / default_charset_info->mbminlen) *
123
118
    my_charset_utf8_bin.mbmaxlen;
124
119
 
125
 
  m_body_utf8= (char *) session->getMemRoot()->allocate(body_utf8_length + 1);
 
120
  m_body_utf8= (char *) session->alloc(body_utf8_length + 1);
126
121
  m_body_utf8_ptr= m_body_utf8;
127
122
  *m_body_utf8_ptr= 0;
128
123
 
213
208
  Because of this, it's critical to not do too much things here.
214
209
  (We already do too much here)
215
210
*/
216
 
void LEX::start(Session *arg)
217
 
{
218
 
  lex_start(arg);
219
 
}
220
 
 
221
211
void lex_start(Session *session)
222
212
{
223
213
  LEX *lex= session->lex;
232
222
  lex->select_lex.init_query();
233
223
  lex->value_list.empty();
234
224
  lex->update_list.empty();
 
225
  lex->param_list.empty();
235
226
  lex->auxiliary_table_list.empty();
236
227
  lex->unit.next= lex->unit.master=
237
228
    lex->unit.link_next= lex->unit.return_to= 0;
249
240
  lex->derived_tables= 0;
250
241
  lex->lock_option= TL_READ;
251
242
  lex->leaf_tables_insert= 0;
252
 
  lex->var_list.clear();
253
243
  lex->select_lex.select_number= 1;
254
244
  lex->length=0;
255
245
  lex->select_lex.in_sum_expr=0;
269
259
  lex->nest_level=0 ;
270
260
  lex->allow_sum_func= 0;
271
261
  lex->in_sum_func= NULL;
272
 
  lex->type= 0;
273
262
 
274
263
  lex->is_lex_started= true;
 
264
  lex->create_table_proto= NULL;
275
265
  lex->statement= NULL;
276
 
  
277
 
  lex->is_cross= false;
278
 
  lex->reset();
279
266
}
280
267
 
281
 
void LEX::end()
 
268
void lex_end(LEX *lex)
282
269
{
283
 
  if (yacc_yyss)
 
270
  if (lex->yacc_yyss)
284
271
  {
285
 
    free(yacc_yyss);
286
 
    free(yacc_yyvs);
287
 
    yacc_yyss= 0;
288
 
    yacc_yyvs= 0;
 
272
    free(lex->yacc_yyss);
 
273
    free(lex->yacc_yyvs);
 
274
    lex->yacc_yyss= 0;
 
275
    lex->yacc_yyvs= 0;
289
276
  }
290
277
 
291
 
  delete result;
292
 
  delete _create_table;
293
 
  _create_table= NULL;
294
 
  _create_field= NULL;
295
 
 
296
 
  result= 0;
297
 
  setCacheable(true);
298
 
 
299
 
  delete statement;
300
 
  statement= NULL;
 
278
  delete lex->result;
 
279
 
 
280
  if(lex->create_table_proto)
 
281
    delete lex->create_table_proto;
 
282
  lex->result= 0;
 
283
 
 
284
  if (lex->statement) 
 
285
    delete lex->statement;
301
286
}
302
287
 
303
288
static int find_keyword(Lex_input_stream *lip, uint32_t len, bool function)
358
343
  char *to;
359
344
  lip->yyUnget();                       // ptr points now after last token char
360
345
  tmp.length= lip->yytoklen=length;
361
 
  tmp.str=(char*) lip->m_session->getMemRoot()->allocate(tmp.length+1);
 
346
  tmp.str=(char*) lip->m_session->alloc(tmp.length+1);
362
347
  from= lip->get_tok_start() + skip;
363
348
  to= tmp.str;
364
349
  end= to+length;
434
419
      end-= post_skip;
435
420
      assert(end >= str);
436
421
 
437
 
      if (!(start= (char*) lip->m_session->getMemRoot()->allocate((uint32_t) (end-str)+1)))
438
 
        return (char*) "";              // memory::SqlAlloc has set error flag
 
422
      if (!(start= (char*) lip->m_session->alloc((uint32_t) (end-str)+1)))
 
423
        return (char*) "";              // Sql_alloc has set error flag
439
424
 
440
425
      lip->m_cpp_text_start= lip->get_cpp_tok_start() + pre_skip;
441
426
      lip->m_cpp_text_end= lip->get_cpp_ptr() - post_skip;
598
583
  return ((unsigned char) str[-1] <= (unsigned char) cmp[-1]) ? smaller : bigger;
599
584
}
600
585
 
601
 
} /* namespace drizzled */
602
586
/*
603
587
  DRIZZLElex remember the following states from the following DRIZZLElex()
604
588
 
608
592
*/
609
593
int DRIZZLElex(void *arg, void *yysession)
610
594
{
611
 
  drizzled::Session *session= (drizzled::Session *)yysession;
612
 
  drizzled::Lex_input_stream *lip= session->m_lip;
 
595
  Session *session= (Session *)yysession;
 
596
  Lex_input_stream *lip= session->m_lip;
613
597
  YYSTYPE *yylval=(YYSTYPE*) arg;
614
598
  int token;
615
599
 
626
610
    return token;
627
611
  }
628
612
 
629
 
  token= drizzled::lex_one_token(arg, yysession);
 
613
  token= lex_one_token(arg, yysession);
630
614
 
631
615
  switch(token) {
632
616
  case WITH:
637
621
      to transform the grammar into a LALR(1) grammar,
638
622
      which sql_yacc.yy can process.
639
623
    */
640
 
    token= drizzled::lex_one_token(arg, yysession);
 
624
    token= lex_one_token(arg, yysession);
641
625
    if (token == ROLLUP_SYM)
642
626
    {
643
627
      return WITH_ROLLUP_SYM;
659
643
  return token;
660
644
}
661
645
 
662
 
namespace drizzled
663
 
{
664
 
 
665
646
int lex_one_token(void *arg, void *yysession)
666
647
{
667
648
  register unsigned char c= 0; /* Just set to shutup GCC */
1315
1296
  options= 0;
1316
1297
  linkage= UNSPECIFIED_TYPE;
1317
1298
  no_error= no_table_names_allowed= 0;
1318
 
  uncacheable.reset();
 
1299
  uncacheable= 0;
1319
1300
}
1320
1301
 
1321
1302
void Select_Lex_Node::init_select()
1382
1363
{
1383
1364
  sj_nests.empty();
1384
1365
  group_list.empty();
1385
 
  db= 0;
 
1366
  type= db= 0;
1386
1367
  having= 0;
 
1368
  table_join_options= 0;
1387
1369
  in_sum_expr= with_wild= 0;
1388
1370
  options= 0;
1389
1371
  braces= 0;
1397
1379
  select_limit= 0;      /* denotes the default limit = HA_POS_ERROR */
1398
1380
  offset_limit= 0;      /* denotes the default offset = 0 */
1399
1381
  with_sum_func= 0;
1400
 
  is_cross= false;
1401
1382
  is_correlated= 0;
1402
1383
  cur_pos_in_select_list= UNDEF_POS;
1403
1384
  non_agg_fields.empty();
1581
1562
       s && s != last;
1582
1563
       s= s->outer_select())
1583
1564
  {
1584
 
    if (! (s->uncacheable.test(UNCACHEABLE_DEPENDENT)))
 
1565
    if (!(s->uncacheable & UNCACHEABLE_DEPENDENT))
1585
1566
    {
1586
1567
      // Select is dependent of outer select
1587
 
      s->uncacheable.set(UNCACHEABLE_DEPENDENT);
1588
 
      s->uncacheable.set(UNCACHEABLE_UNITED);
 
1568
      s->uncacheable= (s->uncacheable & ~UNCACHEABLE_UNITED) |
 
1569
                       UNCACHEABLE_DEPENDENT;
1589
1570
      Select_Lex_Unit *munit= s->master_unit();
1590
 
      munit->uncacheable.set(UNCACHEABLE_UNITED);
1591
 
      munit->uncacheable.set(UNCACHEABLE_DEPENDENT);
 
1571
      munit->uncacheable= (munit->uncacheable & ~UNCACHEABLE_UNITED) |
 
1572
                       UNCACHEABLE_DEPENDENT;
1592
1573
      for (Select_Lex *sl= munit->first_select(); sl ; sl= sl->next_select())
1593
1574
      {
1594
1575
        if (sl != s &&
1595
 
            ! (sl->uncacheable.test(UNCACHEABLE_DEPENDENT) && sl->uncacheable.test(UNCACHEABLE_UNITED)))
1596
 
          sl->uncacheable.set(UNCACHEABLE_UNITED);
 
1576
            !(sl->uncacheable & (UNCACHEABLE_DEPENDENT | UNCACHEABLE_UNITED)))
 
1577
          sl->uncacheable|= UNCACHEABLE_UNITED;
1597
1578
      }
1598
1579
    }
1599
1580
    s->is_correlated= true;
1618
1599
List<Item>* Select_Lex_Node::get_item_list()
1619
1600
{ return NULL; }
1620
1601
 
1621
 
TableList *Select_Lex_Node::add_table_to_list(Session *, 
1622
 
                                              Table_ident *, 
1623
 
                                              LEX_STRING *, 
1624
 
                                              const bitset<NUM_OF_TABLE_OPTIONS>&,
1625
 
                                              thr_lock_type, 
1626
 
                                              List<Index_hint> *, 
1627
 
                                              LEX_STRING *)
 
1602
TableList *Select_Lex_Node::add_table_to_list (Session *, Table_ident *, LEX_STRING *, uint32_t,
 
1603
                                                  thr_lock_type, List<Index_hint> *, LEX_STRING *)
1628
1604
{
1629
1605
  return 0;
1630
1606
}
1631
1607
 
 
1608
uint32_t Select_Lex_Node::get_table_join_options()
 
1609
{
 
1610
  return 0;
 
1611
}
1632
1612
 
1633
1613
/*
1634
1614
  prohibit using LIMIT clause
1706
1686
  return &item_list;
1707
1687
}
1708
1688
 
 
1689
uint32_t Select_Lex::get_table_join_options()
 
1690
{
 
1691
  return table_join_options;
 
1692
}
1709
1693
 
1710
1694
bool Select_Lex::setup_ref_array(Session *session, uint32_t order_group_num)
1711
1695
{
1713
1697
    return false;
1714
1698
 
1715
1699
  return (ref_pointer_array=
1716
 
          (Item **)session->getMemRoot()->allocate(sizeof(Item*) * (n_child_sum_items +
 
1700
          (Item **)session->alloc(sizeof(Item*) * (n_child_sum_items +
1717
1701
                                                 item_list.elements +
1718
1702
                                                 select_n_having_items +
1719
1703
                                                 select_n_where_fields +
1746
1730
      str->append(STRING_WITH_LEN(" order by "));
1747
1731
      fake_select_lex->print_order(
1748
1732
        str,
1749
 
        (Order *) fake_select_lex->order_list.first,
 
1733
        (order_st *) fake_select_lex->order_list.first,
1750
1734
        query_type);
1751
1735
    }
1752
1736
    fake_select_lex->print_limit(session, str, query_type);
1754
1738
}
1755
1739
 
1756
1740
void Select_Lex::print_order(String *str,
1757
 
                                Order *order,
 
1741
                                order_st *order,
1758
1742
                                enum_query_type query_type)
1759
1743
{
1760
1744
  for (; order; order= order->next)
1813
1797
  }
1814
1798
}
1815
1799
 
1816
 
LEX::~LEX()
 
1800
/**
 
1801
  @brief Restore the LEX and Session in case of a parse error.
 
1802
 
 
1803
  This is a clean up call that is invoked by the Bison generated
 
1804
  parser before returning an error from DRIZZLEparse. If your
 
1805
  semantic actions manipulate with the global thread state (which
 
1806
  is a very bad practice and should not normally be employed) and
 
1807
  need a clean-up in case of error, and you can not use %destructor
 
1808
  rule in the grammar file itself, this function should be used
 
1809
  to implement the clean up.
 
1810
*/
 
1811
void LEX::cleanup_lex_after_parse_error(Session *)
1817
1812
{
1818
 
  delete _create_table;
1819
1813
}
1820
1814
 
1821
1815
/*
1865
1859
    statement parsing. On should use lex_start() function to prepare LEX
1866
1860
    for this.
1867
1861
*/
1868
 
LEX::LEX() :
1869
 
    result(0), 
1870
 
    yacc_yyss(0), 
1871
 
    yacc_yyvs(0),
1872
 
    session(NULL),
1873
 
    charset(NULL),
1874
 
    var_list(),
1875
 
    sql_command(SQLCOM_END), 
1876
 
    statement(NULL),
1877
 
    option_type(OPT_DEFAULT), 
1878
 
    is_lex_started(0),
1879
 
    cacheable(true),
1880
 
    sum_expr_used(false),
1881
 
    _create_table(NULL),
1882
 
    _create_field(NULL),
1883
 
    _exists(false)
 
1862
LEX::LEX()
 
1863
  :result(0), yacc_yyss(0), yacc_yyvs(0),
 
1864
   sql_command(SQLCOM_END), option_type(OPT_DEFAULT), is_lex_started(0)
1884
1865
{
1885
1866
  reset_query_tables_list(true);
 
1867
  create_table_proto= NULL;
 
1868
  statement= NULL;
 
1869
}
 
1870
 
 
1871
/*
 
1872
  Detect that we need only table structure of derived table/view
 
1873
 
 
1874
  SYNOPSIS
 
1875
    only_view_structure()
 
1876
 
 
1877
  RETURN
 
1878
    true yes, we need only structure
 
1879
    false no, we need data
 
1880
*/
 
1881
bool LEX::only_view_structure()
 
1882
{
 
1883
  switch (sql_command) {
 
1884
  case SQLCOM_SHOW_CREATE:
 
1885
  case SQLCOM_SHOW_TABLES:
 
1886
  case SQLCOM_SHOW_FIELDS:
 
1887
    return true;
 
1888
  default:
 
1889
    return false;
 
1890
  }
 
1891
}
 
1892
 
 
1893
/*
 
1894
  Should Items_ident be printed correctly
 
1895
 
 
1896
  SYNOPSIS
 
1897
    need_correct_ident()
 
1898
 
 
1899
  RETURN
 
1900
    true yes, we need only structure
 
1901
    false no, we need data
 
1902
*/
 
1903
bool LEX::need_correct_ident()
 
1904
{
 
1905
  switch(sql_command)
 
1906
  {
 
1907
  case SQLCOM_SHOW_CREATE:
 
1908
  case SQLCOM_SHOW_TABLES:
 
1909
    return true;
 
1910
  default:
 
1911
    return false;
 
1912
  }
1886
1913
}
1887
1914
 
1888
1915
/**
2157
2184
                                            current_index_hint_clause,
2158
2185
                                            str, length));
2159
2186
}
2160
 
 
2161
 
bool check_for_sql_keyword(drizzled::lex_string_t const& string)
2162
 
{
2163
 
  if (sql_reserved_words::in_word_set(string.str, string.length))
2164
 
      return true;
2165
 
 
2166
 
  return false;
2167
 
}
2168
 
 
2169
 
bool check_for_sql_keyword(drizzled::st_lex_symbol const& string)
2170
 
{
2171
 
  if (sql_reserved_words::in_word_set(string.str, string.length))
2172
 
      return true;
2173
 
 
2174
 
  return false;
2175
 
}
2176
 
 
2177
 
 
2178
 
} /* namespace drizzled */