← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to drizzled/sql_lex.h

  • Committer: Lee Bieber
  • Date: 2010-01-30 23:42:02 UTC
  • mto: This revision was merged to the branch mainline in revision 1282.
  • Revision ID: lbieber@lee-biebers-macbook-pro.local-20100130234202-sxmqfteqwiq15ptg
add target to japanese tests

Show diffs side-by-side

added added

removed removed

Lines of Context:
drizzled/sql_lex.h
41
41
#include <bitset>
42
42
#include <string>
43
43
 
44
 
namespace drizzled
45
 
{
46
 
 
47
44
class select_result_interceptor;
48
45
 
49
46
/* YACC and LEX Definitions */
54
51
class Lex_Column;
55
52
class Item_outer_ref;
56
53
 
57
 
} /* namespace drizzled */
58
 
 
59
54
/*
60
55
  The following hack is needed because mysql_yacc.cc does not define
61
56
  YYSTYPE before including this file
62
57
*/
63
58
 
64
59
#ifdef DRIZZLE_SERVER
65
 
/* set_var should change to set_var here ... */
66
 
# include <drizzled/sys_var.h>
 
60
# include <drizzled/set_var.h>
67
61
# include <drizzled/item/func.h>
68
62
# ifdef DRIZZLE_YACC
69
63
#  define LEX_YYSTYPE void *
88
82
#define DERIVED_NONE    0
89
83
#define DERIVED_SUBQUERY        1
90
84
 
91
 
namespace drizzled
92
 
{
93
 
 
94
85
typedef List<Item> List_item;
95
86
 
96
87
enum sub_select_type
249
240
      UNCACHEABLE_EXPLAIN
250
241
      UNCACHEABLE_PREPARE
251
242
  */
252
 
  std::bitset<8> uncacheable;
 
243
  uint8_t uncacheable;
253
244
  enum sub_select_type linkage;
254
245
  bool no_table_names_allowed; /* used for global order by */
255
246
  bool no_error; /* suppress error message (convert it to warnings) */
256
247
 
257
248
  static void *operator new(size_t size)
258
249
  {
259
 
    return memory::sql_alloc(size);
 
250
    return drizzled::memory::sql_alloc(size);
260
251
  }
261
 
  static void *operator new(size_t size, memory::Root *mem_root)
262
 
  { return (void*) mem_root->alloc_root((uint32_t) size); }
 
252
  static void *operator new(size_t size, drizzled::memory::Root *mem_root)
 
253
  { return (void*) alloc_root(mem_root, (uint32_t) size); }
263
254
  static void operator delete(void *, size_t)
264
255
  {  }
265
 
  static void operator delete(void *, memory::Root *)
 
256
  static void operator delete(void *, drizzled::memory::Root *)
266
257
  {}
267
258
  Select_Lex_Node(): linkage(UNSPECIFIED_TYPE) {}
268
259
  virtual ~Select_Lex_Node() {}
284
275
  virtual uint32_t get_in_sum_expr();
285
276
  virtual TableList* get_table_list();
286
277
  virtual List<Item>* get_item_list();
 
278
  virtual uint32_t get_table_join_options();
287
279
  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);
 
280
                                        LEX_STRING *alias,
 
281
                                        uint32_t table_options,
 
282
                                        thr_lock_type flags= TL_UNLOCK,
 
283
                                        List<Index_hint> *hints= 0,
 
284
                                        LEX_STRING *option= 0);
293
285
  virtual void set_lock_for_tables(thr_lock_type)
294
286
  {}
295
287
 
305
297
*/
306
298
class Session;
307
299
class select_result;
308
 
class Join;
 
300
class JOIN;
309
301
class select_union;
310
302
class Select_Lex_Unit: public Select_Lex_Node {
311
303
protected:
404
396
class Select_Lex: public Select_Lex_Node
405
397
{
406
398
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
399
  Name_resolution_context context;
466
400
  char *db;
467
401
  /* An Item representing the WHERE clause */
480
414
  List<Item> item_list;  /* list of fields & expressions */
481
415
  List<String> interval_list;
482
416
  bool is_item_list_lookup;
483
 
  Join *join; /* after Join::prepare it is pointer to corresponding JOIN */
 
417
  JOIN *join; /* after JOIN::prepare it is pointer to corresponding JOIN */
484
418
  List<TableList> top_join_list; /* join list of the top level          */
485
419
  List<TableList> *join_list;    /* list for the currently parsed join  */
486
420
  TableList *embedding;          /* table embedding to the above list   */
516
450
  enum_parsing_place parsing_place; /* where we are parsing expression */
517
451
  bool with_sum_func;   /* sum function indicator */
518
452
 
 
453
  uint32_t table_join_options;
519
454
  uint32_t in_sum_expr;
520
455
  uint32_t select_number; /* number of select (used for EXPLAIN) */
521
456
  int8_t nest_level;     /* nesting level of select */
571
506
          defined as SUM_FUNC_USED.
572
507
  */
573
508
  std::bitset<2> full_group_by_flag;
574
 
 
575
509
  void init_query();
576
510
  void init_select();
577
511
  Select_Lex_Unit* master_unit();
609
543
  TableList* add_table_to_list(Session *session,
610
544
                               Table_ident *table,
611
545
                               LEX_STRING *alias,
612
 
                               const std::bitset<NUM_OF_TABLE_OPTIONS>& table_options,
 
546
                               uint32_t table_options,
613
547
                               thr_lock_type flags= TL_UNLOCK,
614
548
                               List<Index_hint> *hints= 0,
615
549
                               LEX_STRING *option= 0);
620
554
  void add_joined_table(TableList *table);
621
555
  TableList *convert_right_join();
622
556
  List<Item>* get_item_list();
 
557
  uint32_t get_table_join_options();
623
558
  void set_lock_for_tables(thr_lock_type lock_type);
624
559
  inline void init_order()
625
560
  {
640
575
  bool test_limit();
641
576
 
642
577
  friend void lex_start(Session *session);
 
578
  Select_Lex() : n_sum_items(0), n_child_sum_items(0) {}
643
579
  void make_empty_select()
644
580
  {
645
581
    init_query();
648
584
  bool setup_ref_array(Session *session, uint32_t order_group_num);
649
585
  void print(Session *session, String *str, enum_query_type query_type);
650
586
  static void print_order(String *str,
651
 
                          Order *order,
 
587
                          order_st *order,
652
588
                          enum_query_type query_type);
653
589
  void print_limit(Session *session, String *str, enum_query_type query_type);
654
590
  void fix_prepare_information(Session *session, Item **conds, Item **having_conds);
793
729
  DISCARD_COMMENT
794
730
};
795
731
 
796
 
} /* namespace drizzled */
797
 
 
798
732
#include "drizzled/lex_input_stream.h"
799
733
 
800
 
namespace drizzled
801
 
{
802
 
 
803
734
/* The state of the lex parsing. This is saved in the Session struct */
804
735
class LEX : public Query_tables_list
805
736
{
870
801
  SQL_LIST save_list;
871
802
  CreateField *last_field;
872
803
  Item_sum *in_sum_func;
873
 
  plugin::Function *udf;
 
804
  drizzled::plugin::Function *udf;
874
805
  uint32_t type;
875
806
  /*
876
807
    This variable is used in post-parse stage to declare that sum-functions,
883
814
  */
884
815
  nesting_map allow_sum_func;
885
816
  enum_sql_command sql_command;
886
 
  statement::Statement *statement;
 
817
  drizzled::statement::Statement *statement;
887
818
  /*
888
819
    Usually `expr` rule of yacc is quite reused but some commands better
889
820
    not support subqueries which comes standard with this rule, like
898
829
    enum ha_rkey_function ha_rkey_mode;
899
830
    enum xa_option_words xa_opt;
900
831
  };
901
 
  sql_var_t option_type;
 
832
  enum enum_var_type option_type;
902
833
 
903
834
  int nest_level;
904
835
  uint8_t describe;
908
839
  */
909
840
  uint8_t derived_tables;
910
841
 
 
842
  /* Only true when FULL symbol is found (e.g. SHOW FULL PROCESSLIST) */
 
843
  bool verbose;
 
844
  
911
845
  /* Was the IGNORE symbol found in statement */
912
846
  bool ignore;
913
847
 
938
872
  void link_first_table_back(TableList *first, bool link_to_local);
939
873
  void first_lists_tables_same();
940
874
 
 
875
  bool only_view_structure();
 
876
  bool need_correct_ident();
 
877
 
941
878
  void cleanup_after_one_table_open();
942
879
 
943
880
  bool push_context(Name_resolution_context *context)
982
919
    }
983
920
    return false;
984
921
  }
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
922
};
1017
923
 
1018
924
extern void lex_start(Session *session);
 
925
extern void lex_end(LEX *lex);
1019
926
extern void trim_whitespace(const CHARSET_INFO * const cs, LEX_STRING *str);
1020
927
extern bool is_lex_native_function(const LEX_STRING *name);
1021
928
 
1023
930
  @} (End of group Semantic_Analysis)
1024
931
*/
1025
932
 
1026
 
} /* namespace drizzled */
1027
 
 
1028
933
#endif /* DRIZZLE_SERVER */
1029
934
#endif /* DRIZZLED_SQL_LEX_H */