← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to drizzled/sql_lex.cc

  • Committer: Brian Aker
  • Date: 2010-10-28 01:45:34 UTC
  • mfrom: (1878.5.8 catalogs)
  • Revision ID: brian@tangent.org-20101028014534-b6qp4wp6crj60h7k
Merge in catalog tree.

Show diffs side-by-side

added added

removed removed

Lines of Context:
drizzled/sql_lex.cc
16
16
 
17
17
/* A lexical scanner on a temporary buffer with a yacc interface */
18
18
 
19
 
#include <config.h>
20
 
 
 
19
#include "config.h"
21
20
#define DRIZZLE_LEX 1
22
 
 
23
 
#include <drizzled/sql_reserved_words.h>
24
 
 
25
 
#include <drizzled/configmake.h>
26
 
#include <drizzled/item/num.h>
27
 
#include <drizzled/error.h>
28
 
#include <drizzled/session.h>
29
 
#include <drizzled/sql_base.h>
30
 
#include <drizzled/lookup_symbol.h>
31
 
#include <drizzled/index_hint.h>
32
 
#include <drizzled/select_result.h>
 
21
#include "drizzled/configmake.h"
 
22
#include "drizzled/item/num.h"
 
23
#include "drizzled/error.h"
 
24
#include "drizzled/session.h"
 
25
#include "drizzled/sql_base.h"
 
26
#include "drizzled/lookup_symbol.h"
 
27
#include "drizzled/index_hint.h"
33
28
 
34
29
#include <cstdio>
35
30
#include <ctype.h>
36
31
 
37
 
union ParserType;
38
 
 
39
32
using namespace std;
40
33
 
41
34
/* Stay outside of the namespace because otherwise bison goes nuts */
42
 
int base_sql_lex(ParserType *arg, drizzled::Session *yysession);
 
35
int DRIZZLElex(void *arg, void *yysession);
43
36
 
44
37
namespace drizzled
45
38
{
46
39
 
47
 
static int lex_one_token(ParserType *arg, drizzled::Session *yysession);
 
40
static int lex_one_token(void *arg, void *yysession);
48
41
 
49
42
/**
50
43
  save order by and tables in own lists.
51
44
*/
52
45
static bool add_to_list(Session *session, SQL_LIST &list, Item *item, bool asc)
53
46
{
54
 
  Order *order;
55
 
 
56
 
  if (!(order = (Order *) session->getMemRoot()->allocate(sizeof(Order))))
57
 
    return true;
58
 
 
 
47
  order_st *order;
 
48
  if (!(order = (order_st *) session->alloc(sizeof(order_st))))
 
49
    return(1);
59
50
  order->item_ptr= item;
60
51
  order->item= &order->item_ptr;
61
52
  order->asc = asc;
62
53
  order->free_me=0;
63
54
  order->used=0;
64
55
  order->counter_used= 0;
65
 
  list.link_in_list((unsigned char*) order, (unsigned char**) &order->next);
66
 
 
67
 
  return false;
 
56
  list.link_in_list((unsigned char*) order,(unsigned char**) &order->next);
 
57
  return(0);
68
58
}
69
59
 
70
60
/**
74
64
 
75
65
Lex_input_stream::Lex_input_stream(Session *session,
76
66
                                   const char* buffer,
77
 
                                   unsigned int length) :
78
 
  m_session(session),
 
67
                                   unsigned int length)
 
68
: m_session(session),
79
69
  yylineno(1),
80
70
  yytoklen(0),
81
71
  yylval(NULL),
98
88
  ignore_space(1),
99
89
  in_comment(NO_COMMENT)
100
90
{
101
 
  m_cpp_buf= (char*) session->getMemRoot()->allocate(length + 1);
 
91
  m_cpp_buf= (char*) session->alloc(length + 1);
102
92
  m_cpp_ptr= m_cpp_buf;
103
93
}
104
94
 
125
115
    (m_buf_length / default_charset_info->mbminlen) *
126
116
    my_charset_utf8_bin.mbmaxlen;
127
117
 
128
 
  m_body_utf8= (char *) session->getMemRoot()->allocate(body_utf8_length + 1);
 
118
  m_body_utf8= (char *) session->alloc(body_utf8_length + 1);
129
119
  m_body_utf8_ptr= m_body_utf8;
130
120
  *m_body_utf8_ptr= 0;
131
121
 
216
206
  Because of this, it's critical to not do too much things here.
217
207
  (We already do too much here)
218
208
*/
219
 
void LEX::start(Session *arg)
220
 
{
221
 
  lex_start(arg);
222
 
}
223
 
 
224
209
void lex_start(Session *session)
225
210
{
226
 
  LEX *lex= session->getLex();
 
211
  LEX *lex= session->lex;
227
212
 
228
213
  lex->session= lex->unit.session= session;
229
214
 
230
 
  lex->context_stack.clear();
 
215
  lex->context_stack.empty();
231
216
  lex->unit.init_query();
232
217
  lex->unit.init_select();
233
218
  /* 'parent_lex' is used in init_query() so it must be before it. */
234
219
  lex->select_lex.parent_lex= lex;
235
220
  lex->select_lex.init_query();
236
 
  lex->value_list.clear();
237
 
  lex->update_list.clear();
238
 
  lex->auxiliary_table_list.clear();
 
221
  lex->value_list.empty();
 
222
  lex->update_list.empty();
 
223
  lex->auxiliary_table_list.empty();
239
224
  lex->unit.next= lex->unit.master=
240
225
    lex->unit.link_next= lex->unit.return_to= 0;
241
226
  lex->unit.prev= lex->unit.link_prev= 0;
247
232
  lex->select_lex.link_prev= (Select_Lex_Node**)&(lex->all_selects_list);
248
233
  lex->select_lex.options= 0;
249
234
  lex->select_lex.init_order();
250
 
  lex->select_lex.group_list.clear();
 
235
  lex->select_lex.group_list.empty();
251
236
  lex->describe= 0;
252
237
  lex->derived_tables= 0;
253
238
  lex->lock_option= TL_READ;
254
239
  lex->leaf_tables_insert= 0;
255
 
  lex->var_list.clear();
256
240
  lex->select_lex.select_number= 1;
257
241
  lex->length=0;
258
242
  lex->select_lex.in_sum_expr=0;
259
 
  lex->select_lex.group_list.clear();
260
 
  lex->select_lex.order_list.clear();
 
243
  lex->select_lex.group_list.empty();
 
244
  lex->select_lex.order_list.empty();
261
245
  lex->sql_command= SQLCOM_END;
262
246
  lex->duplicates= DUP_ERROR;
263
247
  lex->ignore= 0;
272
256
  lex->nest_level=0 ;
273
257
  lex->allow_sum_func= 0;
274
258
  lex->in_sum_func= NULL;
275
 
  lex->type= 0;
276
259
 
277
260
  lex->is_lex_started= true;
278
261
  lex->statement= NULL;
279
262
  
280
263
  lex->is_cross= false;
 
264
 
281
265
  lex->reset();
282
266
}
283
267
 
284
 
void LEX::end()
 
268
void lex_end(LEX *lex)
285
269
{
286
 
  if (yacc_yyss)
287
 
  {
288
 
    free(yacc_yyss);
289
 
    free(yacc_yyvs);
290
 
    yacc_yyss= 0;
291
 
    yacc_yyvs= 0;
292
 
  }
293
 
 
294
 
  safe_delete(result);
295
 
  safe_delete(_create_table);
296
 
  _create_table= NULL;
297
 
  _create_field= NULL;
298
 
 
299
 
  result= 0;
300
 
  setCacheable(true);
301
 
 
302
 
  safe_delete(statement);
 
270
  if (lex->yacc_yyss)
 
271
  {
 
272
    free(lex->yacc_yyss);
 
273
    free(lex->yacc_yyvs);
 
274
    lex->yacc_yyss= 0;
 
275
    lex->yacc_yyvs= 0;
 
276
  }
 
277
 
 
278
  delete lex->result;
 
279
 
 
280
  lex->result= 0;
 
281
  lex->setCacheable(true);
 
282
 
 
283
  if (lex->statement) 
 
284
  {
 
285
    delete lex->statement;
 
286
    lex->statement= NULL;
 
287
  }
303
288
}
304
289
 
305
290
static int find_keyword(Lex_input_stream *lip, uint32_t len, bool function)
360
345
  char *to;
361
346
  lip->yyUnget();                       // ptr points now after last token char
362
347
  tmp.length= lip->yytoklen=length;
363
 
  tmp.str=(char*) lip->m_session->getMemRoot()->allocate(tmp.length+1);
 
348
  tmp.str=(char*) lip->m_session->alloc(tmp.length+1);
364
349
  from= lip->get_tok_start() + skip;
365
350
  to= tmp.str;
366
351
  end= to+length;
387
372
*/
388
373
static char *get_text(Lex_input_stream *lip, int pre_skip, int post_skip)
389
374
{
390
 
  unsigned char c,sep;
 
375
  register unsigned char c,sep;
391
376
  bool found_escape= false;
392
377
  const CHARSET_INFO * const cs= lip->m_session->charset();
393
378
 
436
421
      end-= post_skip;
437
422
      assert(end >= str);
438
423
 
439
 
      if (!(start= (char*) lip->m_session->getMemRoot()->allocate((uint32_t) (end-str)+1)))
 
424
      if (!(start= (char*) lip->m_session->alloc((uint32_t) (end-str)+1)))
440
425
        return (char*) "";              // memory::SqlAlloc has set error flag
441
426
 
442
427
      lip->m_cpp_text_start= lip->get_cpp_tok_start() + pre_skip;
602
587
 
603
588
} /* namespace drizzled */
604
589
/*
605
 
  base_sql_lex remember the following states from the following sql_baselex()
 
590
  DRIZZLElex remember the following states from the following DRIZZLElex()
606
591
 
607
592
  - MY_LEX_EOQ                  Found end of query
608
593
  - MY_LEX_OPERATOR_OR_IDENT    Last state was an ident, text or number
609
594
                                (which can't be followed by a signed number)
610
595
*/
611
 
int base_sql_lex(union ParserType *yylval, drizzled::Session *session)
 
596
int DRIZZLElex(void *arg, void *yysession)
612
597
{
 
598
  drizzled::Session *session= (drizzled::Session *)yysession;
613
599
  drizzled::Lex_input_stream *lip= session->m_lip;
 
600
  YYSTYPE *yylval=(YYSTYPE*) arg;
614
601
  int token;
615
602
 
616
603
  if (lip->lookahead_token != END_OF_INPUT)
626
613
    return token;
627
614
  }
628
615
 
629
 
  token= drizzled::lex_one_token(yylval, session);
 
616
  token= drizzled::lex_one_token(arg, yysession);
630
617
 
631
618
  switch(token) {
632
619
  case WITH:
637
624
      to transform the grammar into a LALR(1) grammar,
638
625
      which sql_yacc.yy can process.
639
626
    */
640
 
    token= drizzled::lex_one_token(yylval, session);
 
627
    token= drizzled::lex_one_token(arg, yysession);
641
628
    if (token == ROLLUP_SYM)
642
629
    {
643
630
      return WITH_ROLLUP_SYM;
662
649
namespace drizzled
663
650
{
664
651
 
665
 
int lex_one_token(ParserType *yylval, drizzled::Session *session)
 
652
int lex_one_token(void *arg, void *yysession)
666
653
{
667
 
  unsigned char c= 0; /* Just set to shutup GCC */
 
654
  register unsigned char c= 0; /* Just set to shutup GCC */
668
655
  bool comment_closed;
669
656
  int   tokval, result_state;
670
657
  unsigned int length;
671
658
  enum my_lex_states state;
 
659
  Session *session= (Session *)yysession;
672
660
  Lex_input_stream *lip= session->m_lip;
673
 
  LEX *lex= session->getLex();
 
661
  LEX *lex= session->lex;
 
662
  YYSTYPE *yylval=(YYSTYPE*) arg;
674
663
  const CHARSET_INFO * const cs= session->charset();
675
664
  unsigned char *state_map= cs->state_map;
676
665
  unsigned char *ident_map= cs->ident_map;
1334
1323
  table= 0;
1335
1324
  fake_select_lex= 0;
1336
1325
  cleaned= 0;
1337
 
  item_list.clear();
 
1326
  item_list.empty();
1338
1327
  describe= 0;
1339
1328
  found_rows_for_union= 0;
1340
1329
}
1342
1331
void Select_Lex::init_query()
1343
1332
{
1344
1333
  Select_Lex_Node::init_query();
1345
 
  table_list.clear();
1346
 
  top_join_list.clear();
 
1334
  table_list.empty();
 
1335
  top_join_list.empty();
1347
1336
  join_list= &top_join_list;
1348
1337
  embedding= leaf_tables= 0;
1349
 
  item_list.clear();
 
1338
  item_list.empty();
1350
1339
  join= 0;
1351
1340
  having= where= 0;
1352
1341
  olap= UNSPECIFIED_OLAP_TYPE;
1378
1367
 
1379
1368
void Select_Lex::init_select()
1380
1369
{
1381
 
  sj_nests.clear();
1382
 
  group_list.clear();
 
1370
  sj_nests.empty();
 
1371
  group_list.empty();
1383
1372
  db= 0;
1384
1373
  having= 0;
1385
1374
  in_sum_expr= with_wild= 0;
1386
1375
  options= 0;
1387
1376
  braces= 0;
1388
 
  interval_list.clear();
 
1377
  interval_list.empty();
1389
1378
  inner_sum_func_list= 0;
1390
1379
  linkage= UNSPECIFIED_TYPE;
1391
1380
  order_list.elements= 0;
1395
1384
  select_limit= 0;      /* denotes the default limit = HA_POS_ERROR */
1396
1385
  offset_limit= 0;      /* denotes the default offset = 0 */
1397
1386
  with_sum_func= 0;
1398
 
  is_cross= false;
1399
1387
  is_correlated= 0;
1400
1388
  cur_pos_in_select_list= UNDEF_POS;
1401
 
  non_agg_fields.clear();
 
1389
  non_agg_fields.empty();
1402
1390
  cond_value= having_value= Item::COND_UNDEF;
1403
 
  inner_refs_list.clear();
 
1391
  inner_refs_list.empty();
1404
1392
  full_group_by_flag.reset();
1405
1393
}
1406
1394
 
1711
1699
    return false;
1712
1700
 
1713
1701
  return (ref_pointer_array=
1714
 
          (Item **)session->getMemRoot()->allocate(sizeof(Item*) * (n_child_sum_items +
 
1702
          (Item **)session->alloc(sizeof(Item*) * (n_child_sum_items +
1715
1703
                                                 item_list.elements +
1716
1704
                                                 select_n_having_items +
1717
1705
                                                 select_n_where_fields +
1744
1732
      str->append(STRING_WITH_LEN(" order by "));
1745
1733
      fake_select_lex->print_order(
1746
1734
        str,
1747
 
        (Order *) fake_select_lex->order_list.first,
 
1735
        (order_st *) fake_select_lex->order_list.first,
1748
1736
        query_type);
1749
1737
    }
1750
1738
    fake_select_lex->print_limit(session, str, query_type);
1752
1740
}
1753
1741
 
1754
1742
void Select_Lex::print_order(String *str,
1755
 
                                Order *order,
 
1743
                                order_st *order,
1756
1744
                                enum_query_type query_type)
1757
1745
{
1758
1746
  for (; order; order= order->next)
1811
1799
  }
1812
1800
}
1813
1801
 
1814
 
LEX::~LEX()
 
1802
/**
 
1803
  @brief Restore the LEX and Session in case of a parse error.
 
1804
 
 
1805
  This is a clean up call that is invoked by the Bison generated
 
1806
  parser before returning an error from DRIZZLEparse. If your
 
1807
  semantic actions manipulate with the global thread state (which
 
1808
  is a very bad practice and should not normally be employed) and
 
1809
  need a clean-up in case of error, and you can not use %destructor
 
1810
  rule in the grammar file itself, this function should be used
 
1811
  to implement the clean up.
 
1812
*/
 
1813
void LEX::cleanup_lex_after_parse_error(Session *)
1815
1814
{
1816
 
  delete _create_table;
1817
1815
}
1818
1816
 
1819
1817
/*
1863
1861
    statement parsing. On should use lex_start() function to prepare LEX
1864
1862
    for this.
1865
1863
*/
1866
 
LEX::LEX() :
 
1864
LEX::LEX()
 
1865
  :
1867
1866
    result(0), 
1868
1867
    yacc_yyss(0), 
1869
1868
    yacc_yyvs(0),
1870
 
    session(NULL),
1871
1869
    charset(NULL),
1872
 
    var_list(),
1873
1870
    sql_command(SQLCOM_END), 
1874
 
    statement(NULL),
1875
1871
    option_type(OPT_DEFAULT), 
1876
1872
    is_lex_started(0),
1877
1873
    cacheable(true),
1878
 
    sum_expr_used(false),
1879
 
    _create_table(NULL),
1880
 
    _create_field(NULL),
1881
 
    _exists(false)
 
1874
    sum_expr_used(false)
1882
1875
{
1883
1876
  reset_query_tables_list(true);
 
1877
  statement= NULL;
1884
1878
}
1885
1879
 
1886
1880
/**
2068
2062
void LEX::cleanup_after_one_table_open()
2069
2063
{
2070
2064
  /*
2071
 
    session->getLex()->derived_tables & additional units may be set if we open
2072
 
    a view. It is necessary to clear session->getLex()->derived_tables flag
 
2065
    session->lex->derived_tables & additional units may be set if we open
 
2066
    a view. It is necessary to clear session->lex->derived_tables flag
2073
2067
    to prevent processing of derived tables during next openTablesLock
2074
2068
    if next table is a real table and cleanup & remove underlying units
2075
 
    NOTE: all units will be connected to session->getLex()->select_lex, because we
 
2069
    NOTE: all units will be connected to session->lex->select_lex, because we
2076
2070
    have not UNION on most upper level.
2077
2071
    */
2078
2072
  if (all_selects_list != &select_lex)
2156
2150
                                            str, length));
2157
2151
}
2158
2152
 
2159
 
bool check_for_sql_keyword(drizzled::lex_string_t const& string)
2160
 
{
2161
 
  if (sql_reserved_words::in_word_set(string.str, string.length))
2162
 
      return true;
2163
 
 
2164
 
  return false;
2165
 
}
2166
 
 
2167
 
bool check_for_sql_keyword(drizzled::st_lex_symbol const& string)
2168
 
{
2169
 
  if (sql_reserved_words::in_word_set(string.str, string.length))
2170
 
      return true;
2171
 
 
2172
 
  return false;
2173
 
}
2174
 
 
2175
 
 
2176
2153
} /* namespace drizzled */