← 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-04-05 23:46:43 UTC
  • Revision ID: brian@gaz-20100405234643-0he3xnj902rc70r8
Fixing tests to work with PBXT.

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
20
#define DRIZZLE_LEX 1
20
 
#include "drizzled/server_includes.h"
 
21
#include "drizzled/configmake.h"
21
22
#include "drizzled/item/num.h"
22
23
#include "drizzled/error.h"
23
24
#include "drizzled/session.h"
29
30
 
30
31
using namespace std;
31
32
 
 
33
/* Stay outside of the namespace because otherwise bison goes nuts */
 
34
int DRIZZLElex(void *arg, void *yysession);
 
35
 
 
36
namespace drizzled
 
37
{
 
38
 
32
39
static int lex_one_token(void *arg, void *yysession);
33
 
int DRIZZLElex(void *arg, void *yysession);
34
40
 
35
41
/**
36
42
  save order by and tables in own lists.
50
56
  return(0);
51
57
}
52
58
 
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
 
 
61
59
/**
62
60
  LEX_STRING constant for null-string to be used in parser and other places.
63
61
*/
86
84
  m_body_utf8(NULL),
87
85
  m_cpp_utf8_processed_ptr(NULL),
88
86
  next_state(MY_LEX_START),
89
 
  found_semicolon(NULL),
90
87
  ignore_space(1),
91
88
  in_comment(NO_COMMENT)
92
89
{
222
219
  lex->select_lex.init_query();
223
220
  lex->value_list.empty();
224
221
  lex->update_list.empty();
225
 
  lex->param_list.empty();
226
222
  lex->auxiliary_table_list.empty();
227
223
  lex->unit.next= lex->unit.master=
228
224
    lex->unit.link_next= lex->unit.return_to= 0;
261
257
  lex->in_sum_func= NULL;
262
258
 
263
259
  lex->is_lex_started= true;
264
 
  lex->create_table_proto= NULL;
265
260
  lex->statement= NULL;
266
261
}
267
262
 
277
272
 
278
273
  delete lex->result;
279
274
 
280
 
  if(lex->create_table_proto)
281
 
    delete lex->create_table_proto;
282
275
  lex->result= 0;
283
276
 
284
277
  if (lex->statement) 
420
413
      assert(end >= str);
421
414
 
422
415
      if (!(start= (char*) lip->m_session->alloc((uint32_t) (end-str)+1)))
423
 
        return (char*) "";              // Sql_alloc has set error flag
 
416
        return (char*) "";              // memory::SqlAlloc has set error flag
424
417
 
425
418
      lip->m_cpp_text_start= lip->get_cpp_tok_start() + pre_skip;
426
419
      lip->m_cpp_text_end= lip->get_cpp_ptr() - post_skip;
583
576
  return ((unsigned char) str[-1] <= (unsigned char) cmp[-1]) ? smaller : bigger;
584
577
}
585
578
 
 
579
} /* namespace drizzled */
586
580
/*
587
581
  DRIZZLElex remember the following states from the following DRIZZLElex()
588
582
 
592
586
*/
593
587
int DRIZZLElex(void *arg, void *yysession)
594
588
{
595
 
  Session *session= (Session *)yysession;
596
 
  Lex_input_stream *lip= session->m_lip;
 
589
  drizzled::Session *session= (drizzled::Session *)yysession;
 
590
  drizzled::Lex_input_stream *lip= session->m_lip;
597
591
  YYSTYPE *yylval=(YYSTYPE*) arg;
598
592
  int token;
599
593
 
610
604
    return token;
611
605
  }
612
606
 
613
 
  token= lex_one_token(arg, yysession);
 
607
  token= drizzled::lex_one_token(arg, yysession);
614
608
 
615
609
  switch(token) {
616
610
  case WITH:
621
615
      to transform the grammar into a LALR(1) grammar,
622
616
      which sql_yacc.yy can process.
623
617
    */
624
 
    token= lex_one_token(arg, yysession);
 
618
    token= drizzled::lex_one_token(arg, yysession);
625
619
    if (token == ROLLUP_SYM)
626
620
    {
627
621
      return WITH_ROLLUP_SYM;
643
637
  return token;
644
638
}
645
639
 
 
640
namespace drizzled
 
641
{
 
642
 
646
643
int lex_one_token(void *arg, void *yysession)
647
644
{
648
645
  register unsigned char c= 0; /* Just set to shutup GCC */
1265
1262
  }
1266
1263
}
1267
1264
 
1268
 
/**
1269
 
  Construct a copy of this object to be used for mysql_alter_table
1270
 
  and mysql_create_table.
1271
 
 
1272
 
  Historically, these two functions modify their Alter_info
1273
 
  arguments. This behaviour breaks re-execution of prepared
1274
 
  statements and stored procedures and is compensated by always
1275
 
  supplying a copy of Alter_info to these functions.
1276
 
 
1277
 
  @return You need to use check the error in Session for out
1278
 
  of memory condition after calling this function.
1279
 
*/
1280
 
Alter_info::Alter_info(const Alter_info &rhs, MEM_ROOT *mem_root)
1281
 
  :drop_list(rhs.drop_list, mem_root),
1282
 
  alter_list(rhs.alter_list, mem_root),
1283
 
  key_list(rhs.key_list, mem_root),
1284
 
  create_list(rhs.create_list, mem_root),
1285
 
  flags(rhs.flags),
1286
 
  keys_onoff(rhs.keys_onoff),
1287
 
  tablespace_op(rhs.tablespace_op),
1288
 
  no_parts(rhs.no_parts),
1289
 
  build_method(rhs.build_method),
1290
 
  datetime_field(rhs.datetime_field),
1291
 
  error_if_not_empty(rhs.error_if_not_empty)
1292
 
{
1293
 
  /*
1294
 
    Make deep copies of used objects.
1295
 
    This is not a fully deep copy - clone() implementations
1296
 
    of Alter_drop, Alter_column, Key, foreign_key, Key_part_spec
1297
 
    do not copy string constants. At the same length the only
1298
 
    reason we make a copy currently is that ALTER/CREATE TABLE
1299
 
    code changes input Alter_info definitions, but string
1300
 
    constants never change.
1301
 
  */
1302
 
  list_copy_and_replace_each_value(drop_list, mem_root);
1303
 
  list_copy_and_replace_each_value(alter_list, mem_root);
1304
 
  list_copy_and_replace_each_value(key_list, mem_root);
1305
 
  list_copy_and_replace_each_value(create_list, mem_root);
1306
 
}
1307
 
 
1308
1265
void trim_whitespace(const CHARSET_INFO * const cs, LEX_STRING *str)
1309
1266
{
1310
1267
  /*
1403
1360
{
1404
1361
  sj_nests.empty();
1405
1362
  group_list.empty();
1406
 
  type= db= 0;
 
1363
  db= 0;
1407
1364
  having= 0;
1408
1365
  table_join_options= 0;
1409
1366
  in_sum_expr= with_wild= 0;
1904
1861
   sql_command(SQLCOM_END), option_type(OPT_DEFAULT), is_lex_started(0)
1905
1862
{
1906
1863
  reset_query_tables_list(true);
1907
 
  create_table_proto= NULL;
1908
1864
  statement= NULL;
1909
1865
}
1910
1866
 
1920
1876
*/
1921
1877
bool LEX::only_view_structure()
1922
1878
{
1923
 
  switch (sql_command) {
1924
 
  case SQLCOM_SHOW_CREATE:
1925
 
  case SQLCOM_SHOW_TABLES:
1926
 
  case SQLCOM_SHOW_FIELDS:
 
1879
  if (sql_command == SQLCOM_SHOW_CREATE)
1927
1880
    return true;
1928
 
  default:
1929
 
    return false;
1930
 
  }
 
1881
 
 
1882
  return false;
1931
1883
}
1932
1884
 
1933
1885
/*
1942
1894
*/
1943
1895
bool LEX::need_correct_ident()
1944
1896
{
1945
 
  switch(sql_command)
1946
 
  {
1947
 
  case SQLCOM_SHOW_CREATE:
1948
 
  case SQLCOM_SHOW_TABLES:
 
1897
  if (sql_command== SQLCOM_SHOW_CREATE)
1949
1898
    return true;
1950
 
  default:
1951
 
    return false;
1952
 
  }
 
1899
 
 
1900
  return false;
1953
1901
}
1954
1902
 
1955
1903
/**
2224
2172
                                            current_index_hint_clause,
2225
2173
                                            str, length));
2226
2174
}
 
2175
 
 
2176
} /* namespace drizzled */