← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to drizzled/sql_lex.cc

  • Committer: LinuxJedi
  • Date: 2010-08-28 09:23:52 UTC
  • mto: (1738.1.1 build)
  • mto: This revision was merged to the branch mainline in revision 1739.
  • Revision ID: linuxjedi@linuxjedi-laptop-20100828092352-oe3zbtdy05kq9dtq
Make exit happen in main thread rather than signal handler thread thus avoiding a segfault due to a double kill of the signal handler thread

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 */
44
44
*/
45
45
static bool add_to_list(Session *session, SQL_LIST &list, Item *item, bool asc)
46
46
{
47
 
  Order *order;
48
 
  if (!(order = (Order *) session->alloc(sizeof(Order))))
 
47
  order_st *order;
 
48
  if (!(order = (order_st *) session->alloc(sizeof(order_st))))
49
49
    return(1);
50
50
  order->item_ptr= item;
51
51
  order->item= &order->item_ptr;
206
206
  Because of this, it's critical to not do too much things here.
207
207
  (We already do too much here)
208
208
*/
209
 
void LEX::start(Session *arg)
210
 
{
211
 
  lex_start(arg);
212
 
}
213
 
 
214
209
void lex_start(Session *session)
215
210
{
216
211
  LEX *lex= session->lex;
266
261
  lex->statement= NULL;
267
262
  
268
263
  lex->is_cross= false;
269
 
 
270
 
  lex->reset();
271
264
}
272
265
 
273
 
void LEX::end()
 
266
void lex_end(LEX *lex)
274
267
{
275
 
  if (yacc_yyss)
 
268
  if (lex->yacc_yyss)
276
269
  {
277
 
    free(yacc_yyss);
278
 
    free(yacc_yyvs);
279
 
    yacc_yyss= 0;
280
 
    yacc_yyvs= 0;
 
270
    free(lex->yacc_yyss);
 
271
    free(lex->yacc_yyvs);
 
272
    lex->yacc_yyss= 0;
 
273
    lex->yacc_yyvs= 0;
281
274
  }
282
275
 
283
 
  delete result;
284
 
 
285
 
  result= 0;
286
 
  setCacheable(true);
287
 
 
288
 
  delete statement;
289
 
  statement= NULL;
 
276
  delete lex->result;
 
277
 
 
278
  lex->result= 0;
 
279
  lex->setCacheable(true);
 
280
 
 
281
  if (lex->statement) 
 
282
    delete lex->statement;
290
283
}
291
284
 
292
285
static int find_keyword(Lex_input_stream *lip, uint32_t len, bool function)
1304
1297
  options= 0;
1305
1298
  linkage= UNSPECIFIED_TYPE;
1306
1299
  no_error= no_table_names_allowed= 0;
1307
 
  uncacheable.reset();
 
1300
  uncacheable= 0;
1308
1301
}
1309
1302
 
1310
1303
void Select_Lex_Node::init_select()
1373
1366
  group_list.empty();
1374
1367
  db= 0;
1375
1368
  having= 0;
 
1369
  table_join_options= 0;
1376
1370
  in_sum_expr= with_wild= 0;
1377
1371
  options= 0;
1378
1372
  braces= 0;
1569
1563
       s && s != last;
1570
1564
       s= s->outer_select())
1571
1565
  {
1572
 
    if (! (s->uncacheable.test(UNCACHEABLE_DEPENDENT)))
 
1566
    if (!(s->uncacheable & UNCACHEABLE_DEPENDENT))
1573
1567
    {
1574
1568
      // Select is dependent of outer select
1575
 
      s->uncacheable.set(UNCACHEABLE_DEPENDENT);
1576
 
      s->uncacheable.set(UNCACHEABLE_UNITED);
 
1569
      s->uncacheable= (s->uncacheable & ~UNCACHEABLE_UNITED) |
 
1570
                       UNCACHEABLE_DEPENDENT;
1577
1571
      Select_Lex_Unit *munit= s->master_unit();
1578
 
      munit->uncacheable.set(UNCACHEABLE_UNITED);
1579
 
      munit->uncacheable.set(UNCACHEABLE_DEPENDENT);
 
1572
      munit->uncacheable= (munit->uncacheable & ~UNCACHEABLE_UNITED) |
 
1573
                       UNCACHEABLE_DEPENDENT;
1580
1574
      for (Select_Lex *sl= munit->first_select(); sl ; sl= sl->next_select())
1581
1575
      {
1582
1576
        if (sl != s &&
1583
 
            ! (sl->uncacheable.test(UNCACHEABLE_DEPENDENT) && sl->uncacheable.test(UNCACHEABLE_UNITED)))
1584
 
          sl->uncacheable.set(UNCACHEABLE_UNITED);
 
1577
            !(sl->uncacheable & (UNCACHEABLE_DEPENDENT | UNCACHEABLE_UNITED)))
 
1578
          sl->uncacheable|= UNCACHEABLE_UNITED;
1585
1579
      }
1586
1580
    }
1587
1581
    s->is_correlated= true;
1606
1600
List<Item>* Select_Lex_Node::get_item_list()
1607
1601
{ return NULL; }
1608
1602
 
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 *)
 
1603
TableList *Select_Lex_Node::add_table_to_list (Session *, Table_ident *, LEX_STRING *, uint32_t,
 
1604
                                                  thr_lock_type, List<Index_hint> *, LEX_STRING *)
1616
1605
{
1617
1606
  return 0;
1618
1607
}
1619
1608
 
 
1609
uint32_t Select_Lex_Node::get_table_join_options()
 
1610
{
 
1611
  return 0;
 
1612
}
1620
1613
 
1621
1614
/*
1622
1615
  prohibit using LIMIT clause
1694
1687
  return &item_list;
1695
1688
}
1696
1689
 
 
1690
uint32_t Select_Lex::get_table_join_options()
 
1691
{
 
1692
  return table_join_options;
 
1693
}
1697
1694
 
1698
1695
bool Select_Lex::setup_ref_array(Session *session, uint32_t order_group_num)
1699
1696
{
1734
1731
      str->append(STRING_WITH_LEN(" order by "));
1735
1732
      fake_select_lex->print_order(
1736
1733
        str,
1737
 
        (Order *) fake_select_lex->order_list.first,
 
1734
        (order_st *) fake_select_lex->order_list.first,
1738
1735
        query_type);
1739
1736
    }
1740
1737
    fake_select_lex->print_limit(session, str, query_type);
1742
1739
}
1743
1740
 
1744
1741
void Select_Lex::print_order(String *str,
1745
 
                                Order *order,
 
1742
                                order_st *order,
1746
1743
                                enum_query_type query_type)
1747
1744
{
1748
1745
  for (; order; order= order->next)
1872
1869
    sql_command(SQLCOM_END), 
1873
1870
    option_type(OPT_DEFAULT), 
1874
1871
    is_lex_started(0),
1875
 
    cacheable(true),
1876
 
    sum_expr_used(false)
 
1872
    cacheable(true)
1877
1873
{
1878
1874
  reset_query_tables_list(true);
1879
1875
  statement= NULL;
1880
1876
}
1881
1877
 
 
1878
/*
 
1879
  Detect that we need only table structure of derived table/view
 
1880
 
 
1881
  SYNOPSIS
 
1882
    only_view_structure()
 
1883
 
 
1884
  RETURN
 
1885
    true yes, we need only structure
 
1886
    false no, we need data
 
1887
*/
 
1888
bool LEX::only_view_structure()
 
1889
{
 
1890
  if (sql_command == SQLCOM_SHOW_CREATE)
 
1891
    return true;
 
1892
 
 
1893
  return false;
 
1894
}
 
1895
 
 
1896
/*
 
1897
  Should Items_ident be printed correctly
 
1898
 
 
1899
  SYNOPSIS
 
1900
    need_correct_ident()
 
1901
 
 
1902
  RETURN
 
1903
    true yes, we need only structure
 
1904
    false no, we need data
 
1905
*/
 
1906
bool LEX::need_correct_ident()
 
1907
{
 
1908
  if (sql_command== SQLCOM_SHOW_CREATE)
 
1909
    return true;
 
1910
 
 
1911
  return false;
 
1912
}
 
1913
 
1882
1914
/**
1883
1915
  This method should be called only during parsing.
1884
1916
  It is aware of compound statements (stored routine bodies)