← 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 17:12:01 UTC
  • mfrom: (1887.1.3 merge)
  • Revision ID: brian@tangent.org-20101028171201-baj6l1bnntn1s4ad
Merge in POTFILES changes.

Show diffs side-by-side

added added

removed removed

Lines of Context:
drizzled/sql_lex.cc
17
17
/* A lexical scanner on a temporary buffer with a yacc interface */
18
18
 
19
19
#include "config.h"
20
 
 
21
20
#define DRIZZLE_LEX 1
22
 
 
23
 
#include "drizzled/sql_reserved_words.h"
24
 
 
25
21
#include "drizzled/configmake.h"
26
22
#include "drizzled/item/num.h"
27
23
#include "drizzled/error.h"
48
44
*/
49
45
static bool add_to_list(Session *session, SQL_LIST &list, Item *item, bool asc)
50
46
{
51
 
  Order *order;
52
 
 
53
 
  if (!(order = (Order *) session->getMemRoot()->allocate(sizeof(Order))))
54
 
    return true;
55
 
 
 
47
  order_st *order;
 
48
  if (!(order = (order_st *) session->alloc(sizeof(order_st))))
 
49
    return(1);
56
50
  order->item_ptr= item;
57
51
  order->item= &order->item_ptr;
58
52
  order->asc = asc;
59
53
  order->free_me=0;
60
54
  order->used=0;
61
55
  order->counter_used= 0;
62
 
  list.link_in_list((unsigned char*) order, (unsigned char**) &order->next);
63
 
 
64
 
  return false;
 
56
  list.link_in_list((unsigned char*) order,(unsigned char**) &order->next);
 
57
  return(0);
65
58
}
66
59
 
67
60
/**
71
64
 
72
65
Lex_input_stream::Lex_input_stream(Session *session,
73
66
                                   const char* buffer,
74
 
                                   unsigned int length) :
75
 
  m_session(session),
 
67
                                   unsigned int length)
 
68
: m_session(session),
76
69
  yylineno(1),
77
70
  yytoklen(0),
78
71
  yylval(NULL),
95
88
  ignore_space(1),
96
89
  in_comment(NO_COMMENT)
97
90
{
98
 
  m_cpp_buf= (char*) session->getMemRoot()->allocate(length + 1);
 
91
  m_cpp_buf= (char*) session->alloc(length + 1);
99
92
  m_cpp_ptr= m_cpp_buf;
100
93
}
101
94
 
122
115
    (m_buf_length / default_charset_info->mbminlen) *
123
116
    my_charset_utf8_bin.mbmaxlen;
124
117
 
125
 
  m_body_utf8= (char *) session->getMemRoot()->allocate(body_utf8_length + 1);
 
118
  m_body_utf8= (char *) session->alloc(body_utf8_length + 1);
126
119
  m_body_utf8_ptr= m_body_utf8;
127
120
  *m_body_utf8_ptr= 0;
128
121
 
213
206
  Because of this, it's critical to not do too much things here.
214
207
  (We already do too much here)
215
208
*/
216
 
void LEX::start(Session *arg)
217
 
{
218
 
  lex_start(arg);
219
 
}
220
 
 
221
209
void lex_start(Session *session)
222
210
{
223
211
  LEX *lex= session->lex;
249
237
  lex->derived_tables= 0;
250
238
  lex->lock_option= TL_READ;
251
239
  lex->leaf_tables_insert= 0;
252
 
  lex->var_list.clear();
253
240
  lex->select_lex.select_number= 1;
254
241
  lex->length=0;
255
242
  lex->select_lex.in_sum_expr=0;
269
256
  lex->nest_level=0 ;
270
257
  lex->allow_sum_func= 0;
271
258
  lex->in_sum_func= NULL;
272
 
  lex->type= 0;
273
259
 
274
260
  lex->is_lex_started= true;
275
261
  lex->statement= NULL;
276
262
  
277
263
  lex->is_cross= false;
 
264
 
278
265
  lex->reset();
279
266
}
280
267
 
281
 
void LEX::end()
 
268
void lex_end(LEX *lex)
282
269
{
283
 
  if (yacc_yyss)
284
 
  {
285
 
    free(yacc_yyss);
286
 
    free(yacc_yyvs);
287
 
    yacc_yyss= 0;
288
 
    yacc_yyvs= 0;
289
 
  }
290
 
 
291
 
  delete result;
292
 
  delete _create_table;
293
 
  _create_table= NULL;
294
 
  _create_field= NULL;
295
 
 
296
 
  result= 0;
297
 
  setCacheable(true);
298
 
 
299
 
  delete statement;
300
 
  statement= NULL;
 
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
  }
301
288
}
302
289
 
303
290
static int find_keyword(Lex_input_stream *lip, uint32_t len, bool function)
358
345
  char *to;
359
346
  lip->yyUnget();                       // ptr points now after last token char
360
347
  tmp.length= lip->yytoklen=length;
361
 
  tmp.str=(char*) lip->m_session->getMemRoot()->allocate(tmp.length+1);
 
348
  tmp.str=(char*) lip->m_session->alloc(tmp.length+1);
362
349
  from= lip->get_tok_start() + skip;
363
350
  to= tmp.str;
364
351
  end= to+length;
434
421
      end-= post_skip;
435
422
      assert(end >= str);
436
423
 
437
 
      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)))
438
425
        return (char*) "";              // memory::SqlAlloc has set error flag
439
426
 
440
427
      lip->m_cpp_text_start= lip->get_cpp_tok_start() + pre_skip;
1397
1384
  select_limit= 0;      /* denotes the default limit = HA_POS_ERROR */
1398
1385
  offset_limit= 0;      /* denotes the default offset = 0 */
1399
1386
  with_sum_func= 0;
1400
 
  is_cross= false;
1401
1387
  is_correlated= 0;
1402
1388
  cur_pos_in_select_list= UNDEF_POS;
1403
1389
  non_agg_fields.empty();
1713
1699
    return false;
1714
1700
 
1715
1701
  return (ref_pointer_array=
1716
 
          (Item **)session->getMemRoot()->allocate(sizeof(Item*) * (n_child_sum_items +
 
1702
          (Item **)session->alloc(sizeof(Item*) * (n_child_sum_items +
1717
1703
                                                 item_list.elements +
1718
1704
                                                 select_n_having_items +
1719
1705
                                                 select_n_where_fields +
1746
1732
      str->append(STRING_WITH_LEN(" order by "));
1747
1733
      fake_select_lex->print_order(
1748
1734
        str,
1749
 
        (Order *) fake_select_lex->order_list.first,
 
1735
        (order_st *) fake_select_lex->order_list.first,
1750
1736
        query_type);
1751
1737
    }
1752
1738
    fake_select_lex->print_limit(session, str, query_type);
1754
1740
}
1755
1741
 
1756
1742
void Select_Lex::print_order(String *str,
1757
 
                                Order *order,
 
1743
                                order_st *order,
1758
1744
                                enum_query_type query_type)
1759
1745
{
1760
1746
  for (; order; order= order->next)
1813
1799
  }
1814
1800
}
1815
1801
 
1816
 
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 *)
1817
1814
{
1818
 
  delete _create_table;
1819
1815
}
1820
1816
 
1821
1817
/*
1865
1861
    statement parsing. On should use lex_start() function to prepare LEX
1866
1862
    for this.
1867
1863
*/
1868
 
LEX::LEX() :
 
1864
LEX::LEX()
 
1865
  :
1869
1866
    result(0), 
1870
1867
    yacc_yyss(0), 
1871
1868
    yacc_yyvs(0),
1872
 
    session(NULL),
1873
1869
    charset(NULL),
1874
 
    var_list(),
1875
1870
    sql_command(SQLCOM_END), 
1876
 
    statement(NULL),
1877
1871
    option_type(OPT_DEFAULT), 
1878
1872
    is_lex_started(0),
1879
1873
    cacheable(true),
1880
 
    sum_expr_used(false),
1881
 
    _create_table(NULL),
1882
 
    _create_field(NULL),
1883
 
    _exists(false)
 
1874
    sum_expr_used(false)
1884
1875
{
1885
1876
  reset_query_tables_list(true);
 
1877
  statement= NULL;
1886
1878
}
1887
1879
 
1888
1880
/**
2158
2150
                                            str, length));
2159
2151
}
2160
2152
 
2161
 
bool check_for_sql_keyword(drizzled::lex_string_t const& string)
2162
 
{
2163
 
  if (sql_reserved_words::in_word_set(string.str, string.length))
2164
 
      return true;
2165
 
 
2166
 
  return false;
2167
 
}
2168
 
 
2169
 
bool check_for_sql_keyword(drizzled::st_lex_symbol const& string)
2170
 
{
2171
 
  if (sql_reserved_words::in_word_set(string.str, string.length))
2172
 
      return true;
2173
 
 
2174
 
  return false;
2175
 
}
2176
 
 
2177
 
 
2178
2153
} /* namespace drizzled */