← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to drizzled/sql_lex.cc

  • Committer: Stewart Smith
  • Date: 2011-01-14 05:13:52 UTC
  • mto: (2086.1.3 build)
  • mto: This revision was merged to the branch mainline in revision 2087.
  • Revision ID: stewart@flamingspork.com-20110114051352-ytdw2wn6thbf4dr8
fix tpyo

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>
 
19
#include "config.h"
20
20
 
21
21
#define DRIZZLE_LEX 1
22
22
 
23
 
#include <drizzled/sql_reserved_words.h>
 
23
#include "drizzled/sql_reserved_words.h"
24
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>
 
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"
33
32
 
34
33
#include <cstdio>
35
34
#include <ctype.h>
36
35
 
37
 
union ParserType;
38
 
 
39
36
using namespace std;
40
37
 
41
38
/* Stay outside of the namespace because otherwise bison goes nuts */
42
 
int base_sql_lex(ParserType *arg, drizzled::Session *yysession);
 
39
int DRIZZLElex(void *arg, void *yysession);
43
40
 
44
41
namespace drizzled
45
42
{
46
43
 
47
 
static int lex_one_token(ParserType *arg, drizzled::Session *yysession);
 
44
static int lex_one_token(void *arg, void *yysession);
48
45
 
49
46
/**
50
47
  save order by and tables in own lists.
52
49
static bool add_to_list(Session *session, SQL_LIST &list, Item *item, bool asc)
53
50
{
54
51
  Order *order;
55
 
 
56
 
  if (!(order = (Order *) session->getMemRoot()->allocate(sizeof(Order))))
57
 
    return true;
58
 
 
 
52
  if (!(order = (Order *) session->alloc(sizeof(Order))))
 
53
    return(1);
59
54
  order->item_ptr= item;
60
55
  order->item= &order->item_ptr;
61
56
  order->asc = asc;
62
57
  order->free_me=0;
63
58
  order->used=0;
64
59
  order->counter_used= 0;
65
 
  list.link_in_list((unsigned char*) order, (unsigned char**) &order->next);
66
 
 
67
 
  return false;
 
60
  list.link_in_list((unsigned char*) order,(unsigned char**) &order->next);
 
61
  return(0);
68
62
}
69
63
 
70
64
/**
74
68
 
75
69
Lex_input_stream::Lex_input_stream(Session *session,
76
70
                                   const char* buffer,
77
 
                                   unsigned int length) :
78
 
  m_session(session),
 
71
                                   unsigned int length)
 
72
: m_session(session),
79
73
  yylineno(1),
80
74
  yytoklen(0),
81
75
  yylval(NULL),
98
92
  ignore_space(1),
99
93
  in_comment(NO_COMMENT)
100
94
{
101
 
  m_cpp_buf= (char*) session->getMemRoot()->allocate(length + 1);
 
95
  m_cpp_buf= (char*) session->alloc(length + 1);
102
96
  m_cpp_ptr= m_cpp_buf;
103
97
}
104
98
 
125
119
    (m_buf_length / default_charset_info->mbminlen) *
126
120
    my_charset_utf8_bin.mbmaxlen;
127
121
 
128
 
  m_body_utf8= (char *) session->getMemRoot()->allocate(body_utf8_length + 1);
 
122
  m_body_utf8= (char *) session->alloc(body_utf8_length + 1);
129
123
  m_body_utf8_ptr= m_body_utf8;
130
124
  *m_body_utf8_ptr= 0;
131
125
 
223
217
 
224
218
void lex_start(Session *session)
225
219
{
226
 
  LEX *lex= session->getLex();
 
220
  LEX *lex= session->lex;
227
221
 
228
222
  lex->session= lex->unit.session= session;
229
223
 
230
 
  lex->context_stack.clear();
 
224
  lex->context_stack.empty();
231
225
  lex->unit.init_query();
232
226
  lex->unit.init_select();
233
227
  /* 'parent_lex' is used in init_query() so it must be before it. */
234
228
  lex->select_lex.parent_lex= lex;
235
229
  lex->select_lex.init_query();
236
 
  lex->value_list.clear();
237
 
  lex->update_list.clear();
238
 
  lex->auxiliary_table_list.clear();
 
230
  lex->value_list.empty();
 
231
  lex->update_list.empty();
 
232
  lex->auxiliary_table_list.empty();
239
233
  lex->unit.next= lex->unit.master=
240
234
    lex->unit.link_next= lex->unit.return_to= 0;
241
235
  lex->unit.prev= lex->unit.link_prev= 0;
247
241
  lex->select_lex.link_prev= (Select_Lex_Node**)&(lex->all_selects_list);
248
242
  lex->select_lex.options= 0;
249
243
  lex->select_lex.init_order();
250
 
  lex->select_lex.group_list.clear();
 
244
  lex->select_lex.group_list.empty();
251
245
  lex->describe= 0;
252
246
  lex->derived_tables= 0;
253
247
  lex->lock_option= TL_READ;
256
250
  lex->select_lex.select_number= 1;
257
251
  lex->length=0;
258
252
  lex->select_lex.in_sum_expr=0;
259
 
  lex->select_lex.group_list.clear();
260
 
  lex->select_lex.order_list.clear();
 
253
  lex->select_lex.group_list.empty();
 
254
  lex->select_lex.order_list.empty();
261
255
  lex->sql_command= SQLCOM_END;
262
256
  lex->duplicates= DUP_ERROR;
263
257
  lex->ignore= 0;
291
285
    yacc_yyvs= 0;
292
286
  }
293
287
 
294
 
  safe_delete(result);
295
 
  safe_delete(_create_table);
 
288
  delete result;
 
289
  delete _create_table;
296
290
  _create_table= NULL;
297
291
  _create_field= NULL;
298
292
 
299
293
  result= 0;
300
294
  setCacheable(true);
301
295
 
302
 
  safe_delete(statement);
 
296
  delete statement;
 
297
  statement= NULL;
303
298
}
304
299
 
305
300
static int find_keyword(Lex_input_stream *lip, uint32_t len, bool function)
360
355
  char *to;
361
356
  lip->yyUnget();                       // ptr points now after last token char
362
357
  tmp.length= lip->yytoklen=length;
363
 
  tmp.str=(char*) lip->m_session->getMemRoot()->allocate(tmp.length+1);
 
358
  tmp.str=(char*) lip->m_session->alloc(tmp.length+1);
364
359
  from= lip->get_tok_start() + skip;
365
360
  to= tmp.str;
366
361
  end= to+length;
387
382
*/
388
383
static char *get_text(Lex_input_stream *lip, int pre_skip, int post_skip)
389
384
{
390
 
  unsigned char c,sep;
 
385
  register unsigned char c,sep;
391
386
  bool found_escape= false;
392
387
  const CHARSET_INFO * const cs= lip->m_session->charset();
393
388
 
436
431
      end-= post_skip;
437
432
      assert(end >= str);
438
433
 
439
 
      if (!(start= (char*) lip->m_session->getMemRoot()->allocate((uint32_t) (end-str)+1)))
 
434
      if (!(start= (char*) lip->m_session->alloc((uint32_t) (end-str)+1)))
440
435
        return (char*) "";              // memory::SqlAlloc has set error flag
441
436
 
442
437
      lip->m_cpp_text_start= lip->get_cpp_tok_start() + pre_skip;
602
597
 
603
598
} /* namespace drizzled */
604
599
/*
605
 
  base_sql_lex remember the following states from the following sql_baselex()
 
600
  DRIZZLElex remember the following states from the following DRIZZLElex()
606
601
 
607
602
  - MY_LEX_EOQ                  Found end of query
608
603
  - MY_LEX_OPERATOR_OR_IDENT    Last state was an ident, text or number
609
604
                                (which can't be followed by a signed number)
610
605
*/
611
 
int base_sql_lex(union ParserType *yylval, drizzled::Session *session)
 
606
int DRIZZLElex(void *arg, void *yysession)
612
607
{
 
608
  drizzled::Session *session= (drizzled::Session *)yysession;
613
609
  drizzled::Lex_input_stream *lip= session->m_lip;
 
610
  YYSTYPE *yylval=(YYSTYPE*) arg;
614
611
  int token;
615
612
 
616
613
  if (lip->lookahead_token != END_OF_INPUT)
626
623
    return token;
627
624
  }
628
625
 
629
 
  token= drizzled::lex_one_token(yylval, session);
 
626
  token= drizzled::lex_one_token(arg, yysession);
630
627
 
631
628
  switch(token) {
632
629
  case WITH:
637
634
      to transform the grammar into a LALR(1) grammar,
638
635
      which sql_yacc.yy can process.
639
636
    */
640
 
    token= drizzled::lex_one_token(yylval, session);
 
637
    token= drizzled::lex_one_token(arg, yysession);
641
638
    if (token == ROLLUP_SYM)
642
639
    {
643
640
      return WITH_ROLLUP_SYM;
662
659
namespace drizzled
663
660
{
664
661
 
665
 
int lex_one_token(ParserType *yylval, drizzled::Session *session)
 
662
int lex_one_token(void *arg, void *yysession)
666
663
{
667
 
  unsigned char c= 0; /* Just set to shutup GCC */
 
664
  register unsigned char c= 0; /* Just set to shutup GCC */
668
665
  bool comment_closed;
669
666
  int   tokval, result_state;
670
667
  unsigned int length;
671
668
  enum my_lex_states state;
 
669
  Session *session= (Session *)yysession;
672
670
  Lex_input_stream *lip= session->m_lip;
673
 
  LEX *lex= session->getLex();
 
671
  LEX *lex= session->lex;
 
672
  YYSTYPE *yylval=(YYSTYPE*) arg;
674
673
  const CHARSET_INFO * const cs= session->charset();
675
674
  unsigned char *state_map= cs->state_map;
676
675
  unsigned char *ident_map= cs->ident_map;
1334
1333
  table= 0;
1335
1334
  fake_select_lex= 0;
1336
1335
  cleaned= 0;
1337
 
  item_list.clear();
 
1336
  item_list.empty();
1338
1337
  describe= 0;
1339
1338
  found_rows_for_union= 0;
1340
1339
}
1342
1341
void Select_Lex::init_query()
1343
1342
{
1344
1343
  Select_Lex_Node::init_query();
1345
 
  table_list.clear();
1346
 
  top_join_list.clear();
 
1344
  table_list.empty();
 
1345
  top_join_list.empty();
1347
1346
  join_list= &top_join_list;
1348
1347
  embedding= leaf_tables= 0;
1349
 
  item_list.clear();
 
1348
  item_list.empty();
1350
1349
  join= 0;
1351
1350
  having= where= 0;
1352
1351
  olap= UNSPECIFIED_OLAP_TYPE;
1378
1377
 
1379
1378
void Select_Lex::init_select()
1380
1379
{
1381
 
  sj_nests.clear();
1382
 
  group_list.clear();
 
1380
  sj_nests.empty();
 
1381
  group_list.empty();
1383
1382
  db= 0;
1384
1383
  having= 0;
1385
1384
  in_sum_expr= with_wild= 0;
1386
1385
  options= 0;
1387
1386
  braces= 0;
1388
 
  interval_list.clear();
 
1387
  interval_list.empty();
1389
1388
  inner_sum_func_list= 0;
1390
1389
  linkage= UNSPECIFIED_TYPE;
1391
1390
  order_list.elements= 0;
1395
1394
  select_limit= 0;      /* denotes the default limit = HA_POS_ERROR */
1396
1395
  offset_limit= 0;      /* denotes the default offset = 0 */
1397
1396
  with_sum_func= 0;
1398
 
  is_cross= false;
1399
1397
  is_correlated= 0;
1400
1398
  cur_pos_in_select_list= UNDEF_POS;
1401
 
  non_agg_fields.clear();
 
1399
  non_agg_fields.empty();
1402
1400
  cond_value= having_value= Item::COND_UNDEF;
1403
 
  inner_refs_list.clear();
 
1401
  inner_refs_list.empty();
1404
1402
  full_group_by_flag.reset();
1405
1403
}
1406
1404
 
1711
1709
    return false;
1712
1710
 
1713
1711
  return (ref_pointer_array=
1714
 
          (Item **)session->getMemRoot()->allocate(sizeof(Item*) * (n_child_sum_items +
 
1712
          (Item **)session->alloc(sizeof(Item*) * (n_child_sum_items +
1715
1713
                                                 item_list.elements +
1716
1714
                                                 select_n_having_items +
1717
1715
                                                 select_n_where_fields +
1816
1814
  delete _create_table;
1817
1815
}
1818
1816
 
 
1817
/**
 
1818
  @brief Restore the LEX and Session in case of a parse error.
 
1819
 
 
1820
  This is a clean up call that is invoked by the Bison generated
 
1821
  parser before returning an error from DRIZZLEparse. If your
 
1822
  semantic actions manipulate with the global thread state (which
 
1823
  is a very bad practice and should not normally be employed) and
 
1824
  need a clean-up in case of error, and you can not use %destructor
 
1825
  rule in the grammar file itself, this function should be used
 
1826
  to implement the clean up.
 
1827
*/
 
1828
void LEX::cleanup_lex_after_parse_error(Session *)
 
1829
{
 
1830
}
 
1831
 
1819
1832
/*
1820
1833
  Initialize (or reset) Query_tables_list object.
1821
1834
 
2068
2081
void LEX::cleanup_after_one_table_open()
2069
2082
{
2070
2083
  /*
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
 
2084
    session->lex->derived_tables & additional units may be set if we open
 
2085
    a view. It is necessary to clear session->lex->derived_tables flag
2073
2086
    to prevent processing of derived tables during next openTablesLock
2074
2087
    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
 
2088
    NOTE: all units will be connected to session->lex->select_lex, because we
2076
2089
    have not UNION on most upper level.
2077
2090
    */
2078
2091
  if (all_selects_list != &select_lex)
2156
2169
                                            str, length));
2157
2170
}
2158
2171
 
2159
 
bool check_for_sql_keyword(drizzled::lex_string_t const& string)
 
2172
bool check_for_sql_keyword(drizzled::drizzle_lex_string const& string)
2160
2173
{
2161
2174
  if (sql_reserved_words::in_word_set(string.str, string.length))
2162
2175
      return true;