← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to drizzled/sql_lex.cc

  • Committer: Djellel E. Difallah
  • Date: 2010-03-27 10:10:49 UTC
  • mto: This revision was merged to the branch mainline in revision 1429.
  • Revision ID: ded@ubuntu-20100327101049-oo3arvatjoyku124
merge my_decimal and decimal

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
 
 
 
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>
33
 
 
34
 
#include <cstdio>
 
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"
 
28
 
35
29
#include <ctype.h>
36
30
 
37
 
union ParserType;
38
 
 
39
31
using namespace std;
40
32
 
41
33
/* Stay outside of the namespace because otherwise bison goes nuts */
42
 
int base_sql_lex(ParserType *arg, drizzled::Session *yysession);
 
34
int DRIZZLElex(void *arg, void *yysession);
43
35
 
44
36
namespace drizzled
45
37
{
46
38
 
47
 
static int lex_one_token(ParserType *arg, drizzled::Session *yysession);
 
39
static int lex_one_token(void *arg, void *yysession);
48
40
 
49
41
/**
50
42
  save order by and tables in own lists.
51
43
*/
52
44
static bool add_to_list(Session *session, SQL_LIST &list, Item *item, bool asc)
53
45
{
54
 
  Order *order;
55
 
 
56
 
  if (!(order = (Order *) session->getMemRoot()->allocate(sizeof(Order))))
57
 
    return true;
58
 
 
 
46
  order_st *order;
 
47
  if (!(order = (order_st *) session->alloc(sizeof(order_st))))
 
48
    return(1);
59
49
  order->item_ptr= item;
60
50
  order->item= &order->item_ptr;
61
51
  order->asc = asc;
62
52
  order->free_me=0;
63
53
  order->used=0;
64
54
  order->counter_used= 0;
65
 
  list.link_in_list((unsigned char*) order, (unsigned char**) &order->next);
66
 
 
67
 
  return false;
 
55
  list.link_in_list((unsigned char*) order,(unsigned char**) &order->next);
 
56
  return(0);
68
57
}
69
58
 
70
59
/**
74
63
 
75
64
Lex_input_stream::Lex_input_stream(Session *session,
76
65
                                   const char* buffer,
77
 
                                   unsigned int length) :
78
 
  m_session(session),
 
66
                                   unsigned int length)
 
67
: m_session(session),
79
68
  yylineno(1),
80
69
  yytoklen(0),
81
70
  yylval(NULL),
98
87
  ignore_space(1),
99
88
  in_comment(NO_COMMENT)
100
89
{
101
 
  m_cpp_buf= (char*) session->getMemRoot()->allocate(length + 1);
 
90
  m_cpp_buf= (char*) session->alloc(length + 1);
102
91
  m_cpp_ptr= m_cpp_buf;
103
92
}
104
93
 
125
114
    (m_buf_length / default_charset_info->mbminlen) *
126
115
    my_charset_utf8_bin.mbmaxlen;
127
116
 
128
 
  m_body_utf8= (char *) session->getMemRoot()->allocate(body_utf8_length + 1);
 
117
  m_body_utf8= (char *) session->alloc(body_utf8_length + 1);
129
118
  m_body_utf8_ptr= m_body_utf8;
130
119
  *m_body_utf8_ptr= 0;
131
120
 
216
205
  Because of this, it's critical to not do too much things here.
217
206
  (We already do too much here)
218
207
*/
219
 
void LEX::start(Session *arg)
220
 
{
221
 
  lex_start(arg);
222
 
}
223
 
 
224
208
void lex_start(Session *session)
225
209
{
226
 
  LEX *lex= session->getLex();
 
210
  LEX *lex= session->lex;
227
211
 
228
212
  lex->session= lex->unit.session= session;
229
213
 
230
 
  lex->context_stack.clear();
 
214
  lex->context_stack.empty();
231
215
  lex->unit.init_query();
232
216
  lex->unit.init_select();
233
217
  /* 'parent_lex' is used in init_query() so it must be before it. */
234
218
  lex->select_lex.parent_lex= lex;
235
219
  lex->select_lex.init_query();
236
 
  lex->value_list.clear();
237
 
  lex->update_list.clear();
238
 
  lex->auxiliary_table_list.clear();
 
220
  lex->value_list.empty();
 
221
  lex->update_list.empty();
 
222
  lex->auxiliary_table_list.empty();
239
223
  lex->unit.next= lex->unit.master=
240
224
    lex->unit.link_next= lex->unit.return_to= 0;
241
225
  lex->unit.prev= lex->unit.link_prev= 0;
247
231
  lex->select_lex.link_prev= (Select_Lex_Node**)&(lex->all_selects_list);
248
232
  lex->select_lex.options= 0;
249
233
  lex->select_lex.init_order();
250
 
  lex->select_lex.group_list.clear();
 
234
  lex->select_lex.group_list.empty();
251
235
  lex->describe= 0;
252
236
  lex->derived_tables= 0;
253
237
  lex->lock_option= TL_READ;
254
238
  lex->leaf_tables_insert= 0;
255
 
  lex->var_list.clear();
256
239
  lex->select_lex.select_number= 1;
257
240
  lex->length=0;
258
241
  lex->select_lex.in_sum_expr=0;
259
 
  lex->select_lex.group_list.clear();
260
 
  lex->select_lex.order_list.clear();
 
242
  lex->select_lex.group_list.empty();
 
243
  lex->select_lex.order_list.empty();
261
244
  lex->sql_command= SQLCOM_END;
262
245
  lex->duplicates= DUP_ERROR;
263
246
  lex->ignore= 0;
272
255
  lex->nest_level=0 ;
273
256
  lex->allow_sum_func= 0;
274
257
  lex->in_sum_func= NULL;
275
 
  lex->type= 0;
276
258
 
277
259
  lex->is_lex_started= true;
278
260
  lex->statement= NULL;
279
 
  
280
 
  lex->is_cross= false;
281
 
  lex->reset();
282
261
}
283
262
 
284
 
void LEX::end()
 
263
void lex_end(LEX *lex)
285
264
{
286
 
  if (yacc_yyss)
 
265
  if (lex->yacc_yyss)
287
266
  {
288
 
    free(yacc_yyss);
289
 
    free(yacc_yyvs);
290
 
    yacc_yyss= 0;
291
 
    yacc_yyvs= 0;
 
267
    free(lex->yacc_yyss);
 
268
    free(lex->yacc_yyvs);
 
269
    lex->yacc_yyss= 0;
 
270
    lex->yacc_yyvs= 0;
292
271
  }
293
272
 
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);
 
273
  delete lex->result;
 
274
 
 
275
  lex->result= 0;
 
276
 
 
277
  if (lex->statement) 
 
278
    delete lex->statement;
303
279
}
304
280
 
305
281
static int find_keyword(Lex_input_stream *lip, uint32_t len, bool function)
360
336
  char *to;
361
337
  lip->yyUnget();                       // ptr points now after last token char
362
338
  tmp.length= lip->yytoklen=length;
363
 
  tmp.str=(char*) lip->m_session->getMemRoot()->allocate(tmp.length+1);
 
339
  tmp.str=(char*) lip->m_session->alloc(tmp.length+1);
364
340
  from= lip->get_tok_start() + skip;
365
341
  to= tmp.str;
366
342
  end= to+length;
387
363
*/
388
364
static char *get_text(Lex_input_stream *lip, int pre_skip, int post_skip)
389
365
{
390
 
  unsigned char c,sep;
 
366
  register unsigned char c,sep;
391
367
  bool found_escape= false;
392
368
  const CHARSET_INFO * const cs= lip->m_session->charset();
393
369
 
436
412
      end-= post_skip;
437
413
      assert(end >= str);
438
414
 
439
 
      if (!(start= (char*) lip->m_session->getMemRoot()->allocate((uint32_t) (end-str)+1)))
 
415
      if (!(start= (char*) lip->m_session->alloc((uint32_t) (end-str)+1)))
440
416
        return (char*) "";              // memory::SqlAlloc has set error flag
441
417
 
442
418
      lip->m_cpp_text_start= lip->get_cpp_tok_start() + pre_skip;
602
578
 
603
579
} /* namespace drizzled */
604
580
/*
605
 
  base_sql_lex remember the following states from the following sql_baselex()
 
581
  DRIZZLElex remember the following states from the following DRIZZLElex()
606
582
 
607
583
  - MY_LEX_EOQ                  Found end of query
608
584
  - MY_LEX_OPERATOR_OR_IDENT    Last state was an ident, text or number
609
585
                                (which can't be followed by a signed number)
610
586
*/
611
 
int base_sql_lex(union ParserType *yylval, drizzled::Session *session)
 
587
int DRIZZLElex(void *arg, void *yysession)
612
588
{
 
589
  drizzled::Session *session= (drizzled::Session *)yysession;
613
590
  drizzled::Lex_input_stream *lip= session->m_lip;
 
591
  YYSTYPE *yylval=(YYSTYPE*) arg;
614
592
  int token;
615
593
 
616
594
  if (lip->lookahead_token != END_OF_INPUT)
626
604
    return token;
627
605
  }
628
606
 
629
 
  token= drizzled::lex_one_token(yylval, session);
 
607
  token= drizzled::lex_one_token(arg, yysession);
630
608
 
631
609
  switch(token) {
632
610
  case WITH:
637
615
      to transform the grammar into a LALR(1) grammar,
638
616
      which sql_yacc.yy can process.
639
617
    */
640
 
    token= drizzled::lex_one_token(yylval, session);
 
618
    token= drizzled::lex_one_token(arg, yysession);
641
619
    if (token == ROLLUP_SYM)
642
620
    {
643
621
      return WITH_ROLLUP_SYM;
662
640
namespace drizzled
663
641
{
664
642
 
665
 
int lex_one_token(ParserType *yylval, drizzled::Session *session)
 
643
int lex_one_token(void *arg, void *yysession)
666
644
{
667
 
  unsigned char c= 0; /* Just set to shutup GCC */
 
645
  register unsigned char c= 0; /* Just set to shutup GCC */
668
646
  bool comment_closed;
669
647
  int   tokval, result_state;
670
648
  unsigned int length;
671
649
  enum my_lex_states state;
 
650
  Session *session= (Session *)yysession;
672
651
  Lex_input_stream *lip= session->m_lip;
673
 
  LEX *lex= session->getLex();
 
652
  LEX *lex= session->lex;
 
653
  YYSTYPE *yylval=(YYSTYPE*) arg;
674
654
  const CHARSET_INFO * const cs= session->charset();
675
655
  unsigned char *state_map= cs->state_map;
676
656
  unsigned char *ident_map= cs->ident_map;
1313
1293
  options= 0;
1314
1294
  linkage= UNSPECIFIED_TYPE;
1315
1295
  no_error= no_table_names_allowed= 0;
1316
 
  uncacheable.reset();
 
1296
  uncacheable= 0;
1317
1297
}
1318
1298
 
1319
1299
void Select_Lex_Node::init_select()
1334
1314
  table= 0;
1335
1315
  fake_select_lex= 0;
1336
1316
  cleaned= 0;
1337
 
  item_list.clear();
 
1317
  item_list.empty();
1338
1318
  describe= 0;
1339
1319
  found_rows_for_union= 0;
1340
1320
}
1342
1322
void Select_Lex::init_query()
1343
1323
{
1344
1324
  Select_Lex_Node::init_query();
1345
 
  table_list.clear();
1346
 
  top_join_list.clear();
 
1325
  table_list.empty();
 
1326
  top_join_list.empty();
1347
1327
  join_list= &top_join_list;
1348
1328
  embedding= leaf_tables= 0;
1349
 
  item_list.clear();
 
1329
  item_list.empty();
1350
1330
  join= 0;
1351
1331
  having= where= 0;
1352
1332
  olap= UNSPECIFIED_OLAP_TYPE;
1378
1358
 
1379
1359
void Select_Lex::init_select()
1380
1360
{
1381
 
  sj_nests.clear();
1382
 
  group_list.clear();
 
1361
  sj_nests.empty();
 
1362
  group_list.empty();
1383
1363
  db= 0;
1384
1364
  having= 0;
 
1365
  table_join_options= 0;
1385
1366
  in_sum_expr= with_wild= 0;
1386
1367
  options= 0;
1387
1368
  braces= 0;
1388
 
  interval_list.clear();
 
1369
  interval_list.empty();
1389
1370
  inner_sum_func_list= 0;
1390
1371
  linkage= UNSPECIFIED_TYPE;
1391
1372
  order_list.elements= 0;
1395
1376
  select_limit= 0;      /* denotes the default limit = HA_POS_ERROR */
1396
1377
  offset_limit= 0;      /* denotes the default offset = 0 */
1397
1378
  with_sum_func= 0;
1398
 
  is_cross= false;
1399
1379
  is_correlated= 0;
1400
1380
  cur_pos_in_select_list= UNDEF_POS;
1401
 
  non_agg_fields.clear();
 
1381
  non_agg_fields.empty();
1402
1382
  cond_value= having_value= Item::COND_UNDEF;
1403
 
  inner_refs_list.clear();
 
1383
  inner_refs_list.empty();
1404
1384
  full_group_by_flag.reset();
1405
1385
}
1406
1386
 
1579
1559
       s && s != last;
1580
1560
       s= s->outer_select())
1581
1561
  {
1582
 
    if (! (s->uncacheable.test(UNCACHEABLE_DEPENDENT)))
 
1562
    if (!(s->uncacheable & UNCACHEABLE_DEPENDENT))
1583
1563
    {
1584
1564
      // Select is dependent of outer select
1585
 
      s->uncacheable.set(UNCACHEABLE_DEPENDENT);
1586
 
      s->uncacheable.set(UNCACHEABLE_UNITED);
 
1565
      s->uncacheable= (s->uncacheable & ~UNCACHEABLE_UNITED) |
 
1566
                       UNCACHEABLE_DEPENDENT;
1587
1567
      Select_Lex_Unit *munit= s->master_unit();
1588
 
      munit->uncacheable.set(UNCACHEABLE_UNITED);
1589
 
      munit->uncacheable.set(UNCACHEABLE_DEPENDENT);
 
1568
      munit->uncacheable= (munit->uncacheable & ~UNCACHEABLE_UNITED) |
 
1569
                       UNCACHEABLE_DEPENDENT;
1590
1570
      for (Select_Lex *sl= munit->first_select(); sl ; sl= sl->next_select())
1591
1571
      {
1592
1572
        if (sl != s &&
1593
 
            ! (sl->uncacheable.test(UNCACHEABLE_DEPENDENT) && sl->uncacheable.test(UNCACHEABLE_UNITED)))
1594
 
          sl->uncacheable.set(UNCACHEABLE_UNITED);
 
1573
            !(sl->uncacheable & (UNCACHEABLE_DEPENDENT | UNCACHEABLE_UNITED)))
 
1574
          sl->uncacheable|= UNCACHEABLE_UNITED;
1595
1575
      }
1596
1576
    }
1597
1577
    s->is_correlated= true;
1616
1596
List<Item>* Select_Lex_Node::get_item_list()
1617
1597
{ return NULL; }
1618
1598
 
1619
 
TableList *Select_Lex_Node::add_table_to_list(Session *, 
1620
 
                                              Table_ident *, 
1621
 
                                              LEX_STRING *, 
1622
 
                                              const bitset<NUM_OF_TABLE_OPTIONS>&,
1623
 
                                              thr_lock_type, 
1624
 
                                              List<Index_hint> *, 
1625
 
                                              LEX_STRING *)
 
1599
TableList *Select_Lex_Node::add_table_to_list (Session *, Table_ident *, LEX_STRING *, uint32_t,
 
1600
                                                  thr_lock_type, List<Index_hint> *, LEX_STRING *)
1626
1601
{
1627
1602
  return 0;
1628
1603
}
1629
1604
 
 
1605
uint32_t Select_Lex_Node::get_table_join_options()
 
1606
{
 
1607
  return 0;
 
1608
}
1630
1609
 
1631
1610
/*
1632
1611
  prohibit using LIMIT clause
1704
1683
  return &item_list;
1705
1684
}
1706
1685
 
 
1686
uint32_t Select_Lex::get_table_join_options()
 
1687
{
 
1688
  return table_join_options;
 
1689
}
1707
1690
 
1708
1691
bool Select_Lex::setup_ref_array(Session *session, uint32_t order_group_num)
1709
1692
{
1711
1694
    return false;
1712
1695
 
1713
1696
  return (ref_pointer_array=
1714
 
          (Item **)session->getMemRoot()->allocate(sizeof(Item*) * (n_child_sum_items +
 
1697
          (Item **)session->alloc(sizeof(Item*) * (n_child_sum_items +
1715
1698
                                                 item_list.elements +
1716
1699
                                                 select_n_having_items +
1717
1700
                                                 select_n_where_fields +
1744
1727
      str->append(STRING_WITH_LEN(" order by "));
1745
1728
      fake_select_lex->print_order(
1746
1729
        str,
1747
 
        (Order *) fake_select_lex->order_list.first,
 
1730
        (order_st *) fake_select_lex->order_list.first,
1748
1731
        query_type);
1749
1732
    }
1750
1733
    fake_select_lex->print_limit(session, str, query_type);
1752
1735
}
1753
1736
 
1754
1737
void Select_Lex::print_order(String *str,
1755
 
                                Order *order,
 
1738
                                order_st *order,
1756
1739
                                enum_query_type query_type)
1757
1740
{
1758
1741
  for (; order; order= order->next)
1811
1794
  }
1812
1795
}
1813
1796
 
1814
 
LEX::~LEX()
 
1797
/**
 
1798
  @brief Restore the LEX and Session in case of a parse error.
 
1799
 
 
1800
  This is a clean up call that is invoked by the Bison generated
 
1801
  parser before returning an error from DRIZZLEparse. If your
 
1802
  semantic actions manipulate with the global thread state (which
 
1803
  is a very bad practice and should not normally be employed) and
 
1804
  need a clean-up in case of error, and you can not use %destructor
 
1805
  rule in the grammar file itself, this function should be used
 
1806
  to implement the clean up.
 
1807
*/
 
1808
void LEX::cleanup_lex_after_parse_error(Session *)
1815
1809
{
1816
 
  delete _create_table;
1817
1810
}
1818
1811
 
1819
1812
/*
1863
1856
    statement parsing. On should use lex_start() function to prepare LEX
1864
1857
    for this.
1865
1858
*/
1866
 
LEX::LEX() :
1867
 
    result(0), 
1868
 
    yacc_yyss(0), 
1869
 
    yacc_yyvs(0),
1870
 
    session(NULL),
1871
 
    charset(NULL),
1872
 
    var_list(),
1873
 
    sql_command(SQLCOM_END), 
1874
 
    statement(NULL),
1875
 
    option_type(OPT_DEFAULT), 
1876
 
    is_lex_started(0),
1877
 
    cacheable(true),
1878
 
    sum_expr_used(false),
1879
 
    _create_table(NULL),
1880
 
    _create_field(NULL),
1881
 
    _exists(false)
 
1859
LEX::LEX()
 
1860
  :result(0), yacc_yyss(0), yacc_yyvs(0),
 
1861
   sql_command(SQLCOM_END), option_type(OPT_DEFAULT), is_lex_started(0)
1882
1862
{
1883
1863
  reset_query_tables_list(true);
 
1864
  statement= NULL;
 
1865
}
 
1866
 
 
1867
/*
 
1868
  Detect that we need only table structure of derived table/view
 
1869
 
 
1870
  SYNOPSIS
 
1871
    only_view_structure()
 
1872
 
 
1873
  RETURN
 
1874
    true yes, we need only structure
 
1875
    false no, we need data
 
1876
*/
 
1877
bool LEX::only_view_structure()
 
1878
{
 
1879
  if (sql_command == SQLCOM_SHOW_CREATE)
 
1880
    return true;
 
1881
 
 
1882
  return false;
 
1883
}
 
1884
 
 
1885
/*
 
1886
  Should Items_ident be printed correctly
 
1887
 
 
1888
  SYNOPSIS
 
1889
    need_correct_ident()
 
1890
 
 
1891
  RETURN
 
1892
    true yes, we need only structure
 
1893
    false no, we need data
 
1894
*/
 
1895
bool LEX::need_correct_ident()
 
1896
{
 
1897
  if (sql_command== SQLCOM_SHOW_CREATE)
 
1898
    return true;
 
1899
 
 
1900
  return false;
1884
1901
}
1885
1902
 
1886
1903
/**
2068
2085
void LEX::cleanup_after_one_table_open()
2069
2086
{
2070
2087
  /*
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
 
2088
    session->lex->derived_tables & additional units may be set if we open
 
2089
    a view. It is necessary to clear session->lex->derived_tables flag
2073
2090
    to prevent processing of derived tables during next openTablesLock
2074
2091
    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
 
2092
    NOTE: all units will be connected to session->lex->select_lex, because we
2076
2093
    have not UNION on most upper level.
2077
2094
    */
2078
2095
  if (all_selects_list != &select_lex)
2156
2173
                                            str, length));
2157
2174
}
2158
2175
 
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
2176
} /* namespace drizzled */