← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to drizzled/sql_lex.cc

  • Committer: lbieber
  • Date: 2010-10-02 19:48:35 UTC
  • mfrom: (1730.6.19 drizzle-make-lcov)
  • Revision ID: lbieber@orisndriz08-20101002194835-q5zd9qc4lvx1xnfo
Merge Hartmut - clean up lex, now require flex to build, also "make lcov" improvements

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
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)
 
270
  if (lex->yacc_yyss)
284
271
  {
285
 
    free(yacc_yyss);
286
 
    free(yacc_yyvs);
287
 
    yacc_yyss= 0;
288
 
    yacc_yyvs= 0;
 
272
    free(lex->yacc_yyss);
 
273
    free(lex->yacc_yyvs);
 
274
    lex->yacc_yyss= 0;
 
275
    lex->yacc_yyvs= 0;
289
276
  }
290
277
 
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;
 
278
  delete lex->result;
 
279
 
 
280
  lex->result= 0;
 
281
  lex->setCacheable(true);
 
282
 
 
283
  if (lex->statement) 
 
284
    delete lex->statement;
301
285
}
302
286
 
303
287
static int find_keyword(Lex_input_stream *lip, uint32_t len, bool function)
358
342
  char *to;
359
343
  lip->yyUnget();                       // ptr points now after last token char
360
344
  tmp.length= lip->yytoklen=length;
361
 
  tmp.str=(char*) lip->m_session->getMemRoot()->allocate(tmp.length+1);
 
345
  tmp.str=(char*) lip->m_session->alloc(tmp.length+1);
362
346
  from= lip->get_tok_start() + skip;
363
347
  to= tmp.str;
364
348
  end= to+length;
434
418
      end-= post_skip;
435
419
      assert(end >= str);
436
420
 
437
 
      if (!(start= (char*) lip->m_session->getMemRoot()->allocate((uint32_t) (end-str)+1)))
 
421
      if (!(start= (char*) lip->m_session->alloc((uint32_t) (end-str)+1)))
438
422
        return (char*) "";              // memory::SqlAlloc has set error flag
439
423
 
440
424
      lip->m_cpp_text_start= lip->get_cpp_tok_start() + pre_skip;
1315
1299
  options= 0;
1316
1300
  linkage= UNSPECIFIED_TYPE;
1317
1301
  no_error= no_table_names_allowed= 0;
1318
 
  uncacheable.reset();
 
1302
  uncacheable= 0;
1319
1303
}
1320
1304
 
1321
1305
void Select_Lex_Node::init_select()
1384
1368
  group_list.empty();
1385
1369
  db= 0;
1386
1370
  having= 0;
 
1371
  table_join_options= 0;
1387
1372
  in_sum_expr= with_wild= 0;
1388
1373
  options= 0;
1389
1374
  braces= 0;
1397
1382
  select_limit= 0;      /* denotes the default limit = HA_POS_ERROR */
1398
1383
  offset_limit= 0;      /* denotes the default offset = 0 */
1399
1384
  with_sum_func= 0;
1400
 
  is_cross= false;
1401
1385
  is_correlated= 0;
1402
1386
  cur_pos_in_select_list= UNDEF_POS;
1403
1387
  non_agg_fields.empty();
1581
1565
       s && s != last;
1582
1566
       s= s->outer_select())
1583
1567
  {
1584
 
    if (! (s->uncacheable.test(UNCACHEABLE_DEPENDENT)))
 
1568
    if (!(s->uncacheable & UNCACHEABLE_DEPENDENT))
1585
1569
    {
1586
1570
      // Select is dependent of outer select
1587
 
      s->uncacheable.set(UNCACHEABLE_DEPENDENT);
1588
 
      s->uncacheable.set(UNCACHEABLE_UNITED);
 
1571
      s->uncacheable= (s->uncacheable & ~UNCACHEABLE_UNITED) |
 
1572
                       UNCACHEABLE_DEPENDENT;
1589
1573
      Select_Lex_Unit *munit= s->master_unit();
1590
 
      munit->uncacheable.set(UNCACHEABLE_UNITED);
1591
 
      munit->uncacheable.set(UNCACHEABLE_DEPENDENT);
 
1574
      munit->uncacheable= (munit->uncacheable & ~UNCACHEABLE_UNITED) |
 
1575
                       UNCACHEABLE_DEPENDENT;
1592
1576
      for (Select_Lex *sl= munit->first_select(); sl ; sl= sl->next_select())
1593
1577
      {
1594
1578
        if (sl != s &&
1595
 
            ! (sl->uncacheable.test(UNCACHEABLE_DEPENDENT) && sl->uncacheable.test(UNCACHEABLE_UNITED)))
1596
 
          sl->uncacheable.set(UNCACHEABLE_UNITED);
 
1579
            !(sl->uncacheable & (UNCACHEABLE_DEPENDENT | UNCACHEABLE_UNITED)))
 
1580
          sl->uncacheable|= UNCACHEABLE_UNITED;
1597
1581
      }
1598
1582
    }
1599
1583
    s->is_correlated= true;
1618
1602
List<Item>* Select_Lex_Node::get_item_list()
1619
1603
{ return NULL; }
1620
1604
 
1621
 
TableList *Select_Lex_Node::add_table_to_list(Session *, 
1622
 
                                              Table_ident *, 
1623
 
                                              LEX_STRING *, 
1624
 
                                              const bitset<NUM_OF_TABLE_OPTIONS>&,
1625
 
                                              thr_lock_type, 
1626
 
                                              List<Index_hint> *, 
1627
 
                                              LEX_STRING *)
 
1605
TableList *Select_Lex_Node::add_table_to_list (Session *, Table_ident *, LEX_STRING *, uint32_t,
 
1606
                                                  thr_lock_type, List<Index_hint> *, LEX_STRING *)
1628
1607
{
1629
1608
  return 0;
1630
1609
}
1631
1610
 
 
1611
uint32_t Select_Lex_Node::get_table_join_options()
 
1612
{
 
1613
  return 0;
 
1614
}
1632
1615
 
1633
1616
/*
1634
1617
  prohibit using LIMIT clause
1706
1689
  return &item_list;
1707
1690
}
1708
1691
 
 
1692
uint32_t Select_Lex::get_table_join_options()
 
1693
{
 
1694
  return table_join_options;
 
1695
}
1709
1696
 
1710
1697
bool Select_Lex::setup_ref_array(Session *session, uint32_t order_group_num)
1711
1698
{
1713
1700
    return false;
1714
1701
 
1715
1702
  return (ref_pointer_array=
1716
 
          (Item **)session->getMemRoot()->allocate(sizeof(Item*) * (n_child_sum_items +
 
1703
          (Item **)session->alloc(sizeof(Item*) * (n_child_sum_items +
1717
1704
                                                 item_list.elements +
1718
1705
                                                 select_n_having_items +
1719
1706
                                                 select_n_where_fields +
1746
1733
      str->append(STRING_WITH_LEN(" order by "));
1747
1734
      fake_select_lex->print_order(
1748
1735
        str,
1749
 
        (Order *) fake_select_lex->order_list.first,
 
1736
        (order_st *) fake_select_lex->order_list.first,
1750
1737
        query_type);
1751
1738
    }
1752
1739
    fake_select_lex->print_limit(session, str, query_type);
1754
1741
}
1755
1742
 
1756
1743
void Select_Lex::print_order(String *str,
1757
 
                                Order *order,
 
1744
                                order_st *order,
1758
1745
                                enum_query_type query_type)
1759
1746
{
1760
1747
  for (; order; order= order->next)
1813
1800
  }
1814
1801
}
1815
1802
 
1816
 
LEX::~LEX()
 
1803
/**
 
1804
  @brief Restore the LEX and Session in case of a parse error.
 
1805
 
 
1806
  This is a clean up call that is invoked by the Bison generated
 
1807
  parser before returning an error from DRIZZLEparse. If your
 
1808
  semantic actions manipulate with the global thread state (which
 
1809
  is a very bad practice and should not normally be employed) and
 
1810
  need a clean-up in case of error, and you can not use %destructor
 
1811
  rule in the grammar file itself, this function should be used
 
1812
  to implement the clean up.
 
1813
*/
 
1814
void LEX::cleanup_lex_after_parse_error(Session *)
1817
1815
{
1818
 
  delete _create_table;
1819
1816
}
1820
1817
 
1821
1818
/*
1865
1862
    statement parsing. On should use lex_start() function to prepare LEX
1866
1863
    for this.
1867
1864
*/
1868
 
LEX::LEX() :
 
1865
LEX::LEX()
 
1866
  :
1869
1867
    result(0), 
1870
1868
    yacc_yyss(0), 
1871
1869
    yacc_yyvs(0),
1872
 
    session(NULL),
1873
1870
    charset(NULL),
1874
 
    var_list(),
1875
1871
    sql_command(SQLCOM_END), 
1876
 
    statement(NULL),
1877
1872
    option_type(OPT_DEFAULT), 
1878
1873
    is_lex_started(0),
1879
1874
    cacheable(true),
1880
 
    sum_expr_used(false),
1881
 
    _create_table(NULL),
1882
 
    _create_field(NULL),
1883
 
    _exists(false)
 
1875
    sum_expr_used(false)
1884
1876
{
1885
1877
  reset_query_tables_list(true);
 
1878
  statement= NULL;
 
1879
}
 
1880
 
 
1881
/*
 
1882
  Detect that we need only table structure of derived table/view
 
1883
 
 
1884
  SYNOPSIS
 
1885
    only_view_structure()
 
1886
 
 
1887
  RETURN
 
1888
    true yes, we need only structure
 
1889
    false no, we need data
 
1890
*/
 
1891
bool LEX::only_view_structure()
 
1892
{
 
1893
  if (sql_command == SQLCOM_SHOW_CREATE)
 
1894
    return true;
 
1895
 
 
1896
  return false;
 
1897
}
 
1898
 
 
1899
/*
 
1900
  Should Items_ident be printed correctly
 
1901
 
 
1902
  SYNOPSIS
 
1903
    need_correct_ident()
 
1904
 
 
1905
  RETURN
 
1906
    true yes, we need only structure
 
1907
    false no, we need data
 
1908
*/
 
1909
bool LEX::need_correct_ident()
 
1910
{
 
1911
  if (sql_command== SQLCOM_SHOW_CREATE)
 
1912
    return true;
 
1913
 
 
1914
  return false;
1886
1915
}
1887
1916
 
1888
1917
/**
2158
2187
                                            str, length));
2159
2188
}
2160
2189
 
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
2190
} /* namespace drizzled */