← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to drizzled/sql_lex.h

  • Committer: Eric Day
  • Date: 2009-11-10 21:50:22 UTC
  • mto: This revision was merged to the branch mainline in revision 1218.
  • Revision ID: eday@oddments.org-20091110215022-0b2nqmurv7b2l6wo
Duplicated oldlibdrizzle module, one for Drizzle protocol and one for MySQL, per Brian's request from merge proposal. Port options are now --drizzle-protocol-port and --mysql-protocol-port.

Show diffs side-by-side

added added

removed removed

Lines of Context:
drizzled/sql_lex.h
28
28
#include "drizzled/plugin/function.h"
29
29
#include "drizzled/name_resolution_context.h"
30
30
#include "drizzled/item/subselect.h"
 
31
#include "drizzled/item/outer_ref.h"
31
32
#include "drizzled/table_list.h"
32
33
#include "drizzled/function/math/real.h"
33
34
#include "drizzled/alter_drop.h"
34
35
#include "drizzled/alter_column.h"
35
36
#include "drizzled/alter_info.h"
36
 
#include "drizzled/key_part_spec.h"
 
37
#include "drizzled/key.h"
 
38
#include "drizzled/foreign_key.h"
37
39
#include "drizzled/index_hint.h"
38
40
#include "drizzled/statement.h"
39
 
#include "drizzled/optimizer/explain_plan.h"
40
41
 
41
42
#include <bitset>
42
 
#include <string>
43
 
 
44
 
namespace drizzled
45
 
{
46
43
 
47
44
class select_result_interceptor;
48
45
 
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 *
70
64
# else
71
65
#  if defined(DRIZZLE_LEX)
72
 
#   include <drizzled/foreign_key.h>
73
66
#   include <drizzled/lex_symbol.h>
74
67
#   include <drizzled/sql_yacc.h>
75
68
#   define LEX_YYSTYPE YYSTYPE *
88
81
#define DERIVED_NONE    0
89
82
#define DERIVED_SUBQUERY        1
90
83
 
91
 
namespace drizzled
92
 
{
93
 
 
94
84
typedef List<Item> List_item;
95
85
 
96
86
enum sub_select_type
249
239
      UNCACHEABLE_EXPLAIN
250
240
      UNCACHEABLE_PREPARE
251
241
  */
252
 
  std::bitset<8> uncacheable;
 
242
  uint8_t uncacheable;
253
243
  enum sub_select_type linkage;
254
244
  bool no_table_names_allowed; /* used for global order by */
255
245
  bool no_error; /* suppress error message (convert it to warnings) */
256
246
 
257
247
  static void *operator new(size_t size)
258
248
  {
259
 
    return memory::sql_alloc(size);
 
249
    return sql_alloc(size);
260
250
  }
261
 
  static void *operator new(size_t size, memory::Root *mem_root)
262
 
  { return (void*) mem_root->alloc_root((uint32_t) size); }
 
251
  static void *operator new(size_t size, MEM_ROOT *mem_root)
 
252
  { return (void*) alloc_root(mem_root, (uint32_t) size); }
263
253
  static void operator delete(void *, size_t)
264
 
  {  }
265
 
  static void operator delete(void *, memory::Root *)
 
254
  { TRASH(ptr, size); }
 
255
  static void operator delete(void *, MEM_ROOT *)
266
256
  {}
267
257
  Select_Lex_Node(): linkage(UNSPECIFIED_TYPE) {}
268
258
  virtual ~Select_Lex_Node() {}
284
274
  virtual uint32_t get_in_sum_expr();
285
275
  virtual TableList* get_table_list();
286
276
  virtual List<Item>* get_item_list();
 
277
  virtual uint32_t get_table_join_options();
287
278
  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);
 
279
                                        LEX_STRING *alias,
 
280
                                        uint32_t table_options,
 
281
                                        thr_lock_type flags= TL_UNLOCK,
 
282
                                        List<Index_hint> *hints= 0,
 
283
                                        LEX_STRING *option= 0);
293
284
  virtual void set_lock_for_tables(thr_lock_type)
294
285
  {}
295
286
 
305
296
*/
306
297
class Session;
307
298
class select_result;
308
 
class Join;
 
299
class JOIN;
309
300
class select_union;
310
301
class Select_Lex_Unit: public Select_Lex_Node {
311
302
protected:
404
395
class Select_Lex: public Select_Lex_Node
405
396
{
406
397
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
398
  Name_resolution_context context;
466
399
  char *db;
467
400
  /* An Item representing the WHERE clause */
480
413
  List<Item> item_list;  /* list of fields & expressions */
481
414
  List<String> interval_list;
482
415
  bool is_item_list_lookup;
483
 
  Join *join; /* after Join::prepare it is pointer to corresponding JOIN */
 
416
  JOIN *join; /* after JOIN::prepare it is pointer to corresponding JOIN */
484
417
  List<TableList> top_join_list; /* join list of the top level          */
485
418
  List<TableList> *join_list;    /* list for the currently parsed join  */
486
419
  TableList *embedding;          /* table embedding to the above list   */
491
424
    by TableList::next_leaf, so leaf_tables points to the left-most leaf.
492
425
  */
493
426
  TableList *leaf_tables;
494
 
  enum drizzled::optimizer::select_type type; /* type of select for EXPLAIN */
 
427
  const char *type;               /* type of select for EXPLAIN          */
495
428
 
496
429
  SQL_LIST order_list;                /* ORDER clause */
497
430
  SQL_LIST *gorder_list;
516
449
  enum_parsing_place parsing_place; /* where we are parsing expression */
517
450
  bool with_sum_func;   /* sum function indicator */
518
451
 
 
452
  uint32_t table_join_options;
519
453
  uint32_t in_sum_expr;
520
454
  uint32_t select_number; /* number of select (used for EXPLAIN) */
521
455
  int8_t nest_level;     /* nesting level of select */
571
505
          defined as SUM_FUNC_USED.
572
506
  */
573
507
  std::bitset<2> full_group_by_flag;
574
 
 
575
508
  void init_query();
576
509
  void init_select();
577
510
  Select_Lex_Unit* master_unit();
609
542
  TableList* add_table_to_list(Session *session,
610
543
                               Table_ident *table,
611
544
                               LEX_STRING *alias,
612
 
                               const std::bitset<NUM_OF_TABLE_OPTIONS>& table_options,
 
545
                               uint32_t table_options,
613
546
                               thr_lock_type flags= TL_UNLOCK,
614
547
                               List<Index_hint> *hints= 0,
615
548
                               LEX_STRING *option= 0);
620
553
  void add_joined_table(TableList *table);
621
554
  TableList *convert_right_join();
622
555
  List<Item>* get_item_list();
 
556
  uint32_t get_table_join_options();
623
557
  void set_lock_for_tables(thr_lock_type lock_type);
624
558
  inline void init_order()
625
559
  {
640
574
  bool test_limit();
641
575
 
642
576
  friend void lex_start(Session *session);
 
577
  Select_Lex() : n_sum_items(0), n_child_sum_items(0) {}
643
578
  void make_empty_select()
644
579
  {
645
580
    init_query();
648
583
  bool setup_ref_array(Session *session, uint32_t order_group_num);
649
584
  void print(Session *session, String *str, enum_query_type query_type);
650
585
  static void print_order(String *str,
651
 
                          Order *order,
 
586
                          order_st *order,
652
587
                          enum_query_type query_type);
653
588
  void print_limit(Session *session, String *str, enum_query_type query_type);
654
589
  void fix_prepare_information(Session *session, Item **conds, Item **having_conds);
739
674
    of Query_tables_list instances which are used as backup storage.
740
675
  */
741
676
  Query_tables_list() {}
742
 
  virtual ~Query_tables_list() {}
 
677
  ~Query_tables_list() {}
743
678
 
744
679
  /* Initializes (or resets) Query_tables_list object for "real" use. */
745
680
  void reset_query_tables_list(bool init);
793
728
  DISCARD_COMMENT
794
729
};
795
730
 
796
 
} /* namespace drizzled */
797
 
 
798
731
#include "drizzled/lex_input_stream.h"
799
732
 
800
 
namespace drizzled
801
 
{
802
 
 
803
733
/* The state of the lex parsing. This is saved in the Session struct */
804
734
class LEX : public Query_tables_list
805
735
{
870
800
  SQL_LIST save_list;
871
801
  CreateField *last_field;
872
802
  Item_sum *in_sum_func;
873
 
  plugin::Function *udf;
 
803
  drizzled::plugin::Function *udf;
874
804
  uint32_t type;
875
805
  /*
876
806
    This variable is used in post-parse stage to declare that sum-functions,
883
813
  */
884
814
  nesting_map allow_sum_func;
885
815
  enum_sql_command sql_command;
886
 
  statement::Statement *statement;
 
816
  drizzled::statement::Statement *statement;
887
817
  /*
888
818
    Usually `expr` rule of yacc is quite reused but some commands better
889
819
    not support subqueries which comes standard with this rule, like
898
828
    enum ha_rkey_function ha_rkey_mode;
899
829
    enum xa_option_words xa_opt;
900
830
  };
901
 
  sql_var_t option_type;
 
831
  enum enum_var_type option_type;
 
832
 
 
833
  /* Options used in START TRANSACTION statement */
 
834
  uint32_t start_transaction_opt;
902
835
 
903
836
  int nest_level;
904
837
  uint8_t describe;
908
841
  */
909
842
  uint8_t derived_tables;
910
843
 
 
844
  /* Only true when FULL symbol is found (e.g. SHOW FULL PROCESSLIST) */
 
845
  bool verbose;
 
846
  
911
847
  /* Was the IGNORE symbol found in statement */
912
848
  bool ignore;
913
849
 
938
874
  void link_first_table_back(TableList *first, bool link_to_local);
939
875
  void first_lists_tables_same();
940
876
 
 
877
  bool only_view_structure();
 
878
  bool need_correct_ident();
 
879
 
941
880
  void cleanup_after_one_table_open();
942
881
 
943
882
  bool push_context(Name_resolution_context *context)
982
921
    }
983
922
    return false;
984
923
  }
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
924
};
1017
925
 
1018
926
extern void lex_start(Session *session);
 
927
extern void lex_end(LEX *lex);
1019
928
extern void trim_whitespace(const CHARSET_INFO * const cs, LEX_STRING *str);
1020
929
extern bool is_lex_native_function(const LEX_STRING *name);
1021
930
 
1023
932
  @} (End of group Semantic_Analysis)
1024
933
*/
1025
934
 
1026
 
} /* namespace drizzled */
1027
 
 
1028
935
#endif /* DRIZZLE_SERVER */
1029
936
#endif /* DRIZZLED_SQL_LEX_H */