← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to drizzled/sql_lex.cc

Re-org'd the replication stuff into slots.

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
 
#include "config.h"
20
19
#define DRIZZLE_LEX 1
21
 
#include "drizzled/configmake.h"
 
20
#include "drizzled/server_includes.h"
22
21
#include "drizzled/item/num.h"
23
22
#include "drizzled/error.h"
24
23
#include "drizzled/session.h"
26
25
#include "drizzled/lookup_symbol.h"
27
26
#include "drizzled/index_hint.h"
28
27
 
29
 
#include <cstdio>
30
28
#include <ctype.h>
31
29
 
32
30
using namespace std;
33
31
 
34
 
/* Stay outside of the namespace because otherwise bison goes nuts */
 
32
static int lex_one_token(void *arg, void *yysession);
35
33
int DRIZZLElex(void *arg, void *yysession);
36
34
 
37
 
namespace drizzled
38
 
{
39
 
 
40
 
static int lex_one_token(void *arg, void *yysession);
41
 
 
42
35
/**
43
36
  save order by and tables in own lists.
44
37
*/
45
38
static bool add_to_list(Session *session, SQL_LIST &list, Item *item, bool asc)
46
39
{
47
 
  Order *order;
48
 
  if (!(order = (Order *) session->alloc(sizeof(Order))))
 
40
  order_st *order;
 
41
  if (!(order = (order_st *) session->alloc(sizeof(order_st))))
49
42
    return(1);
50
43
  order->item_ptr= item;
51
44
  order->item= &order->item_ptr;
57
50
  return(0);
58
51
}
59
52
 
 
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
 
60
61
/**
61
62
  LEX_STRING constant for null-string to be used in parser and other places.
62
63
*/
85
86
  m_body_utf8(NULL),
86
87
  m_cpp_utf8_processed_ptr(NULL),
87
88
  next_state(MY_LEX_START),
 
89
  found_semicolon(NULL),
88
90
  ignore_space(1),
89
91
  in_comment(NO_COMMENT)
90
92
{
206
208
  Because of this, it's critical to not do too much things here.
207
209
  (We already do too much here)
208
210
*/
209
 
void LEX::start(Session *arg)
210
 
{
211
 
  lex_start(arg);
212
 
}
213
 
 
214
211
void lex_start(Session *session)
215
212
{
216
213
  LEX *lex= session->lex;
225
222
  lex->select_lex.init_query();
226
223
  lex->value_list.empty();
227
224
  lex->update_list.empty();
 
225
  lex->param_list.empty();
228
226
  lex->auxiliary_table_list.empty();
229
227
  lex->unit.next= lex->unit.master=
230
228
    lex->unit.link_next= lex->unit.return_to= 0;
263
261
  lex->in_sum_func= NULL;
264
262
 
265
263
  lex->is_lex_started= true;
 
264
  lex->create_table_proto= NULL;
266
265
  lex->statement= NULL;
267
 
  
268
 
  lex->is_cross= false;
269
 
 
270
 
  lex->reset();
271
266
}
272
267
 
273
 
void LEX::end()
 
268
void lex_end(LEX *lex)
274
269
{
275
 
  if (yacc_yyss)
 
270
  if (lex->yacc_yyss)
276
271
  {
277
 
    free(yacc_yyss);
278
 
    free(yacc_yyvs);
279
 
    yacc_yyss= 0;
280
 
    yacc_yyvs= 0;
 
272
    free(lex->yacc_yyss);
 
273
    free(lex->yacc_yyvs);
 
274
    lex->yacc_yyss= 0;
 
275
    lex->yacc_yyvs= 0;
281
276
  }
282
277
 
283
 
  delete result;
284
 
 
285
 
  result= 0;
286
 
  setCacheable(true);
287
 
 
288
 
  delete statement;
289
 
  statement= NULL;
 
278
  delete lex->result;
 
279
 
 
280
  if(lex->create_table_proto)
 
281
    delete lex->create_table_proto;
 
282
  lex->result= 0;
 
283
 
 
284
  if (lex->statement) 
 
285
    delete lex->statement;
290
286
}
291
287
 
292
288
static int find_keyword(Lex_input_stream *lip, uint32_t len, bool function)
424
420
      assert(end >= str);
425
421
 
426
422
      if (!(start= (char*) lip->m_session->alloc((uint32_t) (end-str)+1)))
427
 
        return (char*) "";              // memory::SqlAlloc has set error flag
 
423
        return (char*) "";              // Sql_alloc has set error flag
428
424
 
429
425
      lip->m_cpp_text_start= lip->get_cpp_tok_start() + pre_skip;
430
426
      lip->m_cpp_text_end= lip->get_cpp_ptr() - post_skip;
587
583
  return ((unsigned char) str[-1] <= (unsigned char) cmp[-1]) ? smaller : bigger;
588
584
}
589
585
 
590
 
} /* namespace drizzled */
591
586
/*
592
587
  DRIZZLElex remember the following states from the following DRIZZLElex()
593
588
 
597
592
*/
598
593
int DRIZZLElex(void *arg, void *yysession)
599
594
{
600
 
  drizzled::Session *session= (drizzled::Session *)yysession;
601
 
  drizzled::Lex_input_stream *lip= session->m_lip;
 
595
  Session *session= (Session *)yysession;
 
596
  Lex_input_stream *lip= session->m_lip;
602
597
  YYSTYPE *yylval=(YYSTYPE*) arg;
603
598
  int token;
604
599
 
615
610
    return token;
616
611
  }
617
612
 
618
 
  token= drizzled::lex_one_token(arg, yysession);
 
613
  token= lex_one_token(arg, yysession);
619
614
 
620
615
  switch(token) {
621
616
  case WITH:
626
621
      to transform the grammar into a LALR(1) grammar,
627
622
      which sql_yacc.yy can process.
628
623
    */
629
 
    token= drizzled::lex_one_token(arg, yysession);
 
624
    token= lex_one_token(arg, yysession);
630
625
    if (token == ROLLUP_SYM)
631
626
    {
632
627
      return WITH_ROLLUP_SYM;
648
643
  return token;
649
644
}
650
645
 
651
 
namespace drizzled
652
 
{
653
 
 
654
646
int lex_one_token(void *arg, void *yysession)
655
647
{
656
648
  register unsigned char c= 0; /* Just set to shutup GCC */
1304
1296
  options= 0;
1305
1297
  linkage= UNSPECIFIED_TYPE;
1306
1298
  no_error= no_table_names_allowed= 0;
1307
 
  uncacheable.reset();
 
1299
  uncacheable= 0;
1308
1300
}
1309
1301
 
1310
1302
void Select_Lex_Node::init_select()
1371
1363
{
1372
1364
  sj_nests.empty();
1373
1365
  group_list.empty();
1374
 
  db= 0;
 
1366
  type= db= 0;
1375
1367
  having= 0;
 
1368
  table_join_options= 0;
1376
1369
  in_sum_expr= with_wild= 0;
1377
1370
  options= 0;
1378
1371
  braces= 0;
1569
1562
       s && s != last;
1570
1563
       s= s->outer_select())
1571
1564
  {
1572
 
    if (! (s->uncacheable.test(UNCACHEABLE_DEPENDENT)))
 
1565
    if (!(s->uncacheable & UNCACHEABLE_DEPENDENT))
1573
1566
    {
1574
1567
      // Select is dependent of outer select
1575
 
      s->uncacheable.set(UNCACHEABLE_DEPENDENT);
1576
 
      s->uncacheable.set(UNCACHEABLE_UNITED);
 
1568
      s->uncacheable= (s->uncacheable & ~UNCACHEABLE_UNITED) |
 
1569
                       UNCACHEABLE_DEPENDENT;
1577
1570
      Select_Lex_Unit *munit= s->master_unit();
1578
 
      munit->uncacheable.set(UNCACHEABLE_UNITED);
1579
 
      munit->uncacheable.set(UNCACHEABLE_DEPENDENT);
 
1571
      munit->uncacheable= (munit->uncacheable & ~UNCACHEABLE_UNITED) |
 
1572
                       UNCACHEABLE_DEPENDENT;
1580
1573
      for (Select_Lex *sl= munit->first_select(); sl ; sl= sl->next_select())
1581
1574
      {
1582
1575
        if (sl != s &&
1583
 
            ! (sl->uncacheable.test(UNCACHEABLE_DEPENDENT) && sl->uncacheable.test(UNCACHEABLE_UNITED)))
1584
 
          sl->uncacheable.set(UNCACHEABLE_UNITED);
 
1576
            !(sl->uncacheable & (UNCACHEABLE_DEPENDENT | UNCACHEABLE_UNITED)))
 
1577
          sl->uncacheable|= UNCACHEABLE_UNITED;
1585
1578
      }
1586
1579
    }
1587
1580
    s->is_correlated= true;
1606
1599
List<Item>* Select_Lex_Node::get_item_list()
1607
1600
{ return NULL; }
1608
1601
 
1609
 
TableList *Select_Lex_Node::add_table_to_list(Session *, 
1610
 
                                              Table_ident *, 
1611
 
                                              LEX_STRING *, 
1612
 
                                              const bitset<NUM_OF_TABLE_OPTIONS>&,
1613
 
                                              thr_lock_type, 
1614
 
                                              List<Index_hint> *, 
1615
 
                                              LEX_STRING *)
 
1602
TableList *Select_Lex_Node::add_table_to_list (Session *, Table_ident *, LEX_STRING *, uint32_t,
 
1603
                                                  thr_lock_type, List<Index_hint> *, LEX_STRING *)
1616
1604
{
1617
1605
  return 0;
1618
1606
}
1619
1607
 
 
1608
uint32_t Select_Lex_Node::get_table_join_options()
 
1609
{
 
1610
  return 0;
 
1611
}
1620
1612
 
1621
1613
/*
1622
1614
  prohibit using LIMIT clause
1694
1686
  return &item_list;
1695
1687
}
1696
1688
 
 
1689
uint32_t Select_Lex::get_table_join_options()
 
1690
{
 
1691
  return table_join_options;
 
1692
}
1697
1693
 
1698
1694
bool Select_Lex::setup_ref_array(Session *session, uint32_t order_group_num)
1699
1695
{
1734
1730
      str->append(STRING_WITH_LEN(" order by "));
1735
1731
      fake_select_lex->print_order(
1736
1732
        str,
1737
 
        (Order *) fake_select_lex->order_list.first,
 
1733
        (order_st *) fake_select_lex->order_list.first,
1738
1734
        query_type);
1739
1735
    }
1740
1736
    fake_select_lex->print_limit(session, str, query_type);
1742
1738
}
1743
1739
 
1744
1740
void Select_Lex::print_order(String *str,
1745
 
                                Order *order,
 
1741
                                order_st *order,
1746
1742
                                enum_query_type query_type)
1747
1743
{
1748
1744
  for (; order; order= order->next)
1864
1860
    for this.
1865
1861
*/
1866
1862
LEX::LEX()
1867
 
  :
1868
 
    result(0), 
1869
 
    yacc_yyss(0), 
1870
 
    yacc_yyvs(0),
1871
 
    charset(NULL),
1872
 
    sql_command(SQLCOM_END), 
1873
 
    option_type(OPT_DEFAULT), 
1874
 
    is_lex_started(0),
1875
 
    cacheable(true),
1876
 
    sum_expr_used(false)
 
1863
  :result(0), yacc_yyss(0), yacc_yyvs(0),
 
1864
   sql_command(SQLCOM_END), option_type(OPT_DEFAULT), is_lex_started(0)
1877
1865
{
1878
1866
  reset_query_tables_list(true);
 
1867
  create_table_proto= NULL;
1879
1868
  statement= NULL;
1880
1869
}
1881
1870
 
 
1871
/*
 
1872
  Detect that we need only table structure of derived table/view
 
1873
 
 
1874
  SYNOPSIS
 
1875
    only_view_structure()
 
1876
 
 
1877
  RETURN
 
1878
    true yes, we need only structure
 
1879
    false no, we need data
 
1880
*/
 
1881
bool LEX::only_view_structure()
 
1882
{
 
1883
  switch (sql_command) {
 
1884
  case SQLCOM_SHOW_CREATE:
 
1885
  case SQLCOM_SHOW_TABLES:
 
1886
  case SQLCOM_SHOW_FIELDS:
 
1887
    return true;
 
1888
  default:
 
1889
    return false;
 
1890
  }
 
1891
}
 
1892
 
 
1893
/*
 
1894
  Should Items_ident be printed correctly
 
1895
 
 
1896
  SYNOPSIS
 
1897
    need_correct_ident()
 
1898
 
 
1899
  RETURN
 
1900
    true yes, we need only structure
 
1901
    false no, we need data
 
1902
*/
 
1903
bool LEX::need_correct_ident()
 
1904
{
 
1905
  switch(sql_command)
 
1906
  {
 
1907
  case SQLCOM_SHOW_CREATE:
 
1908
  case SQLCOM_SHOW_TABLES:
 
1909
    return true;
 
1910
  default:
 
1911
    return false;
 
1912
  }
 
1913
}
 
1914
 
1882
1915
/**
1883
1916
  This method should be called only during parsing.
1884
1917
  It is aware of compound statements (stored routine bodies)
2151
2184
                                            current_index_hint_clause,
2152
2185
                                            str, length));
2153
2186
}
2154
 
 
2155
 
} /* namespace drizzled */