← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to drizzled/sql_lex.h

  • Committer: Stewart Smith
  • Date: 2010-03-18 12:01:34 UTC
  • mto: (1666.2.3 build)
  • mto: This revision was merged to the branch mainline in revision 1596.
  • Revision ID: stewart@flamingspork.com-20100318120134-45fdnsw8g3j6c7oy
move RAND() into a plugin

Show diffs side-by-side

added added

removed removed

Lines of Context:
drizzled/sql_lex.h
62
62
*/
63
63
 
64
64
#ifdef DRIZZLE_SERVER
65
 
/* set_var should change to set_var here ... */
66
 
# include <drizzled/sys_var.h>
 
65
# include <drizzled/set_var.h>
67
66
# include <drizzled/item/func.h>
68
67
# ifdef DRIZZLE_YACC
69
68
#  define LEX_YYSTYPE void *
249
248
      UNCACHEABLE_EXPLAIN
250
249
      UNCACHEABLE_PREPARE
251
250
  */
252
 
  std::bitset<8> uncacheable;
 
251
  uint8_t uncacheable;
253
252
  enum sub_select_type linkage;
254
253
  bool no_table_names_allowed; /* used for global order by */
255
254
  bool no_error; /* suppress error message (convert it to warnings) */
259
258
    return memory::sql_alloc(size);
260
259
  }
261
260
  static void *operator new(size_t size, memory::Root *mem_root)
262
 
  { return (void*) mem_root->alloc_root((uint32_t) size); }
 
261
  { return (void*) alloc_root(mem_root, (uint32_t) size); }
263
262
  static void operator delete(void *, size_t)
264
263
  {  }
265
264
  static void operator delete(void *, memory::Root *)
284
283
  virtual uint32_t get_in_sum_expr();
285
284
  virtual TableList* get_table_list();
286
285
  virtual List<Item>* get_item_list();
 
286
  virtual uint32_t get_table_join_options();
287
287
  virtual TableList *add_table_to_list(Session *session, Table_ident *table,
288
 
                                       LEX_STRING *alias,
289
 
                                       const std::bitset<NUM_OF_TABLE_OPTIONS>& table_options,
290
 
                                       thr_lock_type flags= TL_UNLOCK,
291
 
                                       List<Index_hint> *hints= 0,
292
 
                                       LEX_STRING *option= 0);
 
288
                                        LEX_STRING *alias,
 
289
                                        uint32_t table_options,
 
290
                                        thr_lock_type flags= TL_UNLOCK,
 
291
                                        List<Index_hint> *hints= 0,
 
292
                                        LEX_STRING *option= 0);
293
293
  virtual void set_lock_for_tables(thr_lock_type)
294
294
  {}
295
295
 
305
305
*/
306
306
class Session;
307
307
class select_result;
308
 
class Join;
 
308
class JOIN;
309
309
class select_union;
310
310
class Select_Lex_Unit: public Select_Lex_Node {
311
311
protected:
404
404
class Select_Lex: public Select_Lex_Node
405
405
{
406
406
public:
407
 
 
408
 
  Select_Lex() :
409
 
    context(),
410
 
    db(0),
411
 
    where(0),
412
 
    having(0),
413
 
    cond_value(),
414
 
    having_value(),
415
 
    parent_lex(0),
416
 
    olap(UNSPECIFIED_OLAP_TYPE),
417
 
    table_list(),
418
 
    group_list(),
419
 
    item_list(),
420
 
    interval_list(),
421
 
    is_item_list_lookup(false),
422
 
    join(0),
423
 
    top_join_list(),
424
 
    join_list(0),
425
 
    embedding(0),
426
 
    sj_nests(),
427
 
    leaf_tables(0),
428
 
    type(optimizer::ST_PRIMARY),
429
 
    order_list(),
430
 
    gorder_list(0),
431
 
    select_limit(0),
432
 
    offset_limit(0),
433
 
    ref_pointer_array(0),
434
 
    select_n_having_items(0),
435
 
    cond_count(0),
436
 
    between_count(0),
437
 
    max_equal_elems(0),
438
 
    select_n_where_fields(0),
439
 
    parsing_place(NO_MATTER),
440
 
    with_sum_func(0),
441
 
    in_sum_expr(0),
442
 
    select_number(0),
443
 
    nest_level(0),
444
 
    inner_sum_func_list(0),
445
 
    with_wild(0),
446
 
    braces(0),
447
 
    having_fix_field(0),
448
 
    inner_refs_list(),
449
 
    n_sum_items(0),
450
 
    n_child_sum_items(0),
451
 
    explicit_limit(0),
452
 
    subquery_in_having(0),
453
 
    is_correlated(0),
454
 
    exclude_from_table_unique_test(0),
455
 
    non_agg_fields(),
456
 
    cur_pos_in_select_list(0),
457
 
    prev_join_using(0),
458
 
    full_group_by_flag(),
459
 
    current_index_hint_type(INDEX_HINT_IGNORE),
460
 
    current_index_hint_clause(),
461
 
    index_hints(0)
462
 
  {
463
 
  }
464
 
 
465
407
  Name_resolution_context context;
466
408
  char *db;
467
409
  /* An Item representing the WHERE clause */
480
422
  List<Item> item_list;  /* list of fields & expressions */
481
423
  List<String> interval_list;
482
424
  bool is_item_list_lookup;
483
 
  Join *join; /* after Join::prepare it is pointer to corresponding JOIN */
 
425
  JOIN *join; /* after JOIN::prepare it is pointer to corresponding JOIN */
484
426
  List<TableList> top_join_list; /* join list of the top level          */
485
427
  List<TableList> *join_list;    /* list for the currently parsed join  */
486
428
  TableList *embedding;          /* table embedding to the above list   */
516
458
  enum_parsing_place parsing_place; /* where we are parsing expression */
517
459
  bool with_sum_func;   /* sum function indicator */
518
460
 
 
461
  uint32_t table_join_options;
519
462
  uint32_t in_sum_expr;
520
463
  uint32_t select_number; /* number of select (used for EXPLAIN) */
521
464
  int8_t nest_level;     /* nesting level of select */
571
514
          defined as SUM_FUNC_USED.
572
515
  */
573
516
  std::bitset<2> full_group_by_flag;
574
 
 
575
517
  void init_query();
576
518
  void init_select();
577
519
  Select_Lex_Unit* master_unit();
609
551
  TableList* add_table_to_list(Session *session,
610
552
                               Table_ident *table,
611
553
                               LEX_STRING *alias,
612
 
                               const std::bitset<NUM_OF_TABLE_OPTIONS>& table_options,
 
554
                               uint32_t table_options,
613
555
                               thr_lock_type flags= TL_UNLOCK,
614
556
                               List<Index_hint> *hints= 0,
615
557
                               LEX_STRING *option= 0);
620
562
  void add_joined_table(TableList *table);
621
563
  TableList *convert_right_join();
622
564
  List<Item>* get_item_list();
 
565
  uint32_t get_table_join_options();
623
566
  void set_lock_for_tables(thr_lock_type lock_type);
624
567
  inline void init_order()
625
568
  {
640
583
  bool test_limit();
641
584
 
642
585
  friend void lex_start(Session *session);
 
586
  Select_Lex() : n_sum_items(0), n_child_sum_items(0) {}
643
587
  void make_empty_select()
644
588
  {
645
589
    init_query();
648
592
  bool setup_ref_array(Session *session, uint32_t order_group_num);
649
593
  void print(Session *session, String *str, enum_query_type query_type);
650
594
  static void print_order(String *str,
651
 
                          Order *order,
 
595
                          order_st *order,
652
596
                          enum_query_type query_type);
653
597
  void print_limit(Session *session, String *str, enum_query_type query_type);
654
598
  void fix_prepare_information(Session *session, Item **conds, Item **having_conds);
938
882
  void link_first_table_back(TableList *first, bool link_to_local);
939
883
  void first_lists_tables_same();
940
884
 
 
885
  bool only_view_structure();
 
886
  bool need_correct_ident();
 
887
 
941
888
  void cleanup_after_one_table_open();
942
889
 
943
890
  bool push_context(Name_resolution_context *context)
982
929
    }
983
930
    return false;
984
931
  }
985
 
  bool is_cross; // CROSS keyword was used
986
 
  bool isCacheable()
987
 
  {
988
 
    return cacheable;
989
 
  }
990
 
  void setCacheable(bool val)
991
 
  {
992
 
    cacheable= val;
993
 
  }
994
 
 
995
 
  void reset()
996
 
  {
997
 
    sum_expr_used= false;
998
 
  }
999
 
 
1000
 
  void setSumExprUsed()
1001
 
  {
1002
 
    sum_expr_used= true;
1003
 
  }
1004
 
 
1005
 
  bool isSumExprUsed()
1006
 
  {
1007
 
    return sum_expr_used;
1008
 
  }
1009
 
 
1010
 
  void start(Session *session);
1011
 
  void end();
1012
 
 
1013
 
private: 
1014
 
  bool cacheable;
1015
 
  bool sum_expr_used;
1016
932
};
1017
933
 
1018
934
extern void lex_start(Session *session);
 
935
extern void lex_end(LEX *lex);
1019
936
extern void trim_whitespace(const CHARSET_INFO * const cs, LEX_STRING *str);
1020
937
extern bool is_lex_native_function(const LEX_STRING *name);
1021
938