← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to drizzled/sql_lex.cc

  • Committer: Lee Bieber
  • Date: 2011-02-19 18:28:30 UTC
  • mfrom: (1994.4.78 drizzle)
  • mto: This revision was merged to the branch mainline in revision 2185.
  • Revision ID: kalebral@gmail.com-20110219182830-kb8m3ali4yjmcg0s
Merge Marisa - adds logo references to the include file

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"
 
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>
32
33
 
33
34
#include <cstdio>
34
35
#include <ctype.h>
35
36
 
 
37
union ParserType;
 
38
 
36
39
using namespace std;
37
40
 
38
41
/* Stay outside of the namespace because otherwise bison goes nuts */
39
 
int DRIZZLElex(void *arg, void *yysession);
 
42
int base_sql_lex(ParserType *arg, drizzled::Session *yysession);
40
43
 
41
44
namespace drizzled
42
45
{
43
46
 
44
 
static int lex_one_token(void *arg, void *yysession);
 
47
static int lex_one_token(ParserType *arg, drizzled::Session *yysession);
45
48
 
46
49
/**
47
50
  save order by and tables in own lists.
224
227
 
225
228
  lex->session= lex->unit.session= session;
226
229
 
227
 
  lex->context_stack.empty();
 
230
  lex->context_stack.clear();
228
231
  lex->unit.init_query();
229
232
  lex->unit.init_select();
230
233
  /* 'parent_lex' is used in init_query() so it must be before it. */
231
234
  lex->select_lex.parent_lex= lex;
232
235
  lex->select_lex.init_query();
233
 
  lex->value_list.empty();
234
 
  lex->update_list.empty();
235
 
  lex->auxiliary_table_list.empty();
 
236
  lex->value_list.clear();
 
237
  lex->update_list.clear();
 
238
  lex->auxiliary_table_list.clear();
236
239
  lex->unit.next= lex->unit.master=
237
240
    lex->unit.link_next= lex->unit.return_to= 0;
238
241
  lex->unit.prev= lex->unit.link_prev= 0;
244
247
  lex->select_lex.link_prev= (Select_Lex_Node**)&(lex->all_selects_list);
245
248
  lex->select_lex.options= 0;
246
249
  lex->select_lex.init_order();
247
 
  lex->select_lex.group_list.empty();
 
250
  lex->select_lex.group_list.clear();
248
251
  lex->describe= 0;
249
252
  lex->derived_tables= 0;
250
253
  lex->lock_option= TL_READ;
253
256
  lex->select_lex.select_number= 1;
254
257
  lex->length=0;
255
258
  lex->select_lex.in_sum_expr=0;
256
 
  lex->select_lex.group_list.empty();
257
 
  lex->select_lex.order_list.empty();
 
259
  lex->select_lex.group_list.clear();
 
260
  lex->select_lex.order_list.clear();
258
261
  lex->sql_command= SQLCOM_END;
259
262
  lex->duplicates= DUP_ERROR;
260
263
  lex->ignore= 0;
288
291
    yacc_yyvs= 0;
289
292
  }
290
293
 
291
 
  delete result;
292
 
  delete _create_table;
 
294
  safe_delete(result);
 
295
  safe_delete(_create_table);
293
296
  _create_table= NULL;
294
297
  _create_field= NULL;
295
298
 
296
299
  result= 0;
297
300
  setCacheable(true);
298
301
 
299
 
  delete statement;
300
 
  statement= NULL;
 
302
  safe_delete(statement);
301
303
}
302
304
 
303
305
static int find_keyword(Lex_input_stream *lip, uint32_t len, bool function)
385
387
*/
386
388
static char *get_text(Lex_input_stream *lip, int pre_skip, int post_skip)
387
389
{
388
 
  register unsigned char c,sep;
 
390
  unsigned char c,sep;
389
391
  bool found_escape= false;
390
392
  const CHARSET_INFO * const cs= lip->m_session->charset();
391
393
 
600
602
 
601
603
} /* namespace drizzled */
602
604
/*
603
 
  DRIZZLElex remember the following states from the following DRIZZLElex()
 
605
  base_sql_lex remember the following states from the following sql_baselex()
604
606
 
605
607
  - MY_LEX_EOQ                  Found end of query
606
608
  - MY_LEX_OPERATOR_OR_IDENT    Last state was an ident, text or number
607
609
                                (which can't be followed by a signed number)
608
610
*/
609
 
int DRIZZLElex(void *arg, void *yysession)
 
611
int base_sql_lex(union ParserType *yylval, drizzled::Session *session)
610
612
{
611
 
  drizzled::Session *session= (drizzled::Session *)yysession;
612
613
  drizzled::Lex_input_stream *lip= session->m_lip;
613
 
  YYSTYPE *yylval=(YYSTYPE*) arg;
614
614
  int token;
615
615
 
616
616
  if (lip->lookahead_token != END_OF_INPUT)
626
626
    return token;
627
627
  }
628
628
 
629
 
  token= drizzled::lex_one_token(arg, yysession);
 
629
  token= drizzled::lex_one_token(yylval, session);
630
630
 
631
631
  switch(token) {
632
632
  case WITH:
637
637
      to transform the grammar into a LALR(1) grammar,
638
638
      which sql_yacc.yy can process.
639
639
    */
640
 
    token= drizzled::lex_one_token(arg, yysession);
 
640
    token= drizzled::lex_one_token(yylval, session);
641
641
    if (token == ROLLUP_SYM)
642
642
    {
643
643
      return WITH_ROLLUP_SYM;
662
662
namespace drizzled
663
663
{
664
664
 
665
 
int lex_one_token(void *arg, void *yysession)
 
665
int lex_one_token(ParserType *yylval, drizzled::Session *session)
666
666
{
667
 
  register unsigned char c= 0; /* Just set to shutup GCC */
 
667
  unsigned char c= 0; /* Just set to shutup GCC */
668
668
  bool comment_closed;
669
669
  int   tokval, result_state;
670
670
  unsigned int length;
671
671
  enum my_lex_states state;
672
 
  Session *session= (Session *)yysession;
673
672
  Lex_input_stream *lip= session->m_lip;
674
673
  LEX *lex= session->lex;
675
 
  YYSTYPE *yylval=(YYSTYPE*) arg;
676
674
  const CHARSET_INFO * const cs= session->charset();
677
675
  unsigned char *state_map= cs->state_map;
678
676
  unsigned char *ident_map= cs->ident_map;
1336
1334
  table= 0;
1337
1335
  fake_select_lex= 0;
1338
1336
  cleaned= 0;
1339
 
  item_list.empty();
 
1337
  item_list.clear();
1340
1338
  describe= 0;
1341
1339
  found_rows_for_union= 0;
1342
1340
}
1344
1342
void Select_Lex::init_query()
1345
1343
{
1346
1344
  Select_Lex_Node::init_query();
1347
 
  table_list.empty();
1348
 
  top_join_list.empty();
 
1345
  table_list.clear();
 
1346
  top_join_list.clear();
1349
1347
  join_list= &top_join_list;
1350
1348
  embedding= leaf_tables= 0;
1351
 
  item_list.empty();
 
1349
  item_list.clear();
1352
1350
  join= 0;
1353
1351
  having= where= 0;
1354
1352
  olap= UNSPECIFIED_OLAP_TYPE;
1380
1378
 
1381
1379
void Select_Lex::init_select()
1382
1380
{
1383
 
  sj_nests.empty();
1384
 
  group_list.empty();
 
1381
  sj_nests.clear();
 
1382
  group_list.clear();
1385
1383
  db= 0;
1386
1384
  having= 0;
1387
1385
  in_sum_expr= with_wild= 0;
1388
1386
  options= 0;
1389
1387
  braces= 0;
1390
 
  interval_list.empty();
 
1388
  interval_list.clear();
1391
1389
  inner_sum_func_list= 0;
1392
1390
  linkage= UNSPECIFIED_TYPE;
1393
1391
  order_list.elements= 0;
1400
1398
  is_cross= false;
1401
1399
  is_correlated= 0;
1402
1400
  cur_pos_in_select_list= UNDEF_POS;
1403
 
  non_agg_fields.empty();
 
1401
  non_agg_fields.clear();
1404
1402
  cond_value= having_value= Item::COND_UNDEF;
1405
 
  inner_refs_list.empty();
 
1403
  inner_refs_list.clear();
1406
1404
  full_group_by_flag.reset();
1407
1405
}
1408
1406