← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to drizzled/join.h

  • Committer: Monty Taylor
  • Date: 2009-08-29 19:30:29 UTC
  • mto: (1126.5.1 captain-20090914-03)
  • mto: This revision was merged to the branch mainline in revision 1129.
  • Revision ID: mordred@inaugust.com-20090829193029-i12fw4pg91dm8nu9
https://launchpad.net/bugs/405501
Fixed a buffer overrun that was causing some translated message output to suck.

Honestly guys, declaring a char[80] and then doing an sprintf into it with
no length checking? sigh

Show diffs side-by-side

added added

removed removed

Lines of Context:
drizzled/join.h
21
21
/**
22
22
 * @file
23
23
 *
24
 
 * Defines the Join class
 
24
 * Defines the JOIN class
25
25
 */
26
26
 
27
27
#ifndef DRIZZLED_JOIN_H
28
28
#define DRIZZLED_JOIN_H
29
29
 
30
30
#include <drizzled/optimizer/position.h>
31
 
#include "drizzled/sql_select.h"
32
31
#include <bitset>
33
32
 
34
 
namespace drizzled
35
 
{
36
 
 
37
 
class Join :public memory::SqlAlloc
38
 
{
39
 
  Join(const Join &rhs);                        /**< not implemented */
40
 
  Join& operator=(const Join &rhs);             /**< not implemented */
 
33
class JOIN :public Sql_alloc
 
34
{
 
35
  JOIN(const JOIN &rhs);                        /**< not implemented */
 
36
  JOIN& operator=(const JOIN &rhs);             /**< not implemented */
41
37
 
42
38
  /**
43
39
   * Contains a partial query execution plan which is extended during
44
40
   * cost-based optimization.
45
41
   */
46
 
  optimizer::Position positions[MAX_TABLES+1];
 
42
  drizzled::optimizer::Position positions[MAX_TABLES+1];
47
43
 
48
44
  /**
49
45
   * Contains the optimal query execution plan after cost-based optimization
50
46
   * has taken place. 
51
47
   */
52
 
  optimizer::Position best_positions[MAX_TABLES+1];
 
48
  drizzled::optimizer::Position best_positions[MAX_TABLES+1];
53
49
 
54
50
public:
55
51
  JoinTable *join_tab;
102
98
 
103
99
  /*
104
100
    simple_xxxxx is set if order_st/GROUP BY doesn't include any references
105
 
    to other tables than the first non-constant table in the Join.
 
101
    to other tables than the first non-constant table in the JOIN.
106
102
    It's also set if order_st/GROUP BY is empty.
107
103
  */
108
104
  bool simple_order;
109
105
  bool simple_group;
110
106
  /**
111
107
    Is set only in case if we have a GROUP BY clause
112
 
    and no ORDER BY after constant elimination of 'order'.
 
108
    and no order_st BY after constant elimination of 'order'.
113
109
  */
114
110
  bool no_order;
115
 
  /** Is set if we have a GROUP BY and we have ORDER BY on a constant. */
 
111
  /** Is set if we have a GROUP BY and we have order_st BY on a constant. */
116
112
  bool skip_sort_order;
117
113
  bool union_part; /**< this subselect is part of union */
118
114
  bool optimized; /**< flag to avoid double optimization in EXPLAIN */
147
143
  Select_Lex_Unit *unit;
148
144
  /** select that processed */
149
145
  Select_Lex *select_lex;
150
 
  optimizer::SqlSelect *select; /**< created in optimization phase */
 
146
  SQL_SELECT *select; /**< created in optimisation phase */
 
147
  Array<Item_in_subselect> sj_subselects;
151
148
 
152
149
  /**
153
150
    Bitmap of nested joins embedding the position at the end of the current
177
174
  uint64_t select_options;
178
175
  select_result *result;
179
176
  Tmp_Table_Param tmp_table_param;
180
 
  DrizzleLock *lock;
 
177
  DRIZZLE_LOCK *lock;
181
178
 
182
 
  Join *tmp_join; /**< copy of this Join to be used with temporary tables */
 
179
  JOIN *tmp_join; /**< copy of this JOIN to be used with temporary tables */
183
180
  ROLLUP rollup;                                /**< Used with rollup */
184
181
  DYNAMIC_ARRAY keyuse;
185
182
  Item::cond_result cond_value;
195
192
  List<Item> tmp_fields_list3;
196
193
  int error;
197
194
 
198
 
  Order *order;
199
 
  Order *group_list; /**< hold parameters of mysql_select */
 
195
  order_st *order;
 
196
  order_st *group_list; /**< hold parameters of mysql_select */
200
197
  COND *conds;                            // ---"---
201
198
  Item *conds_history; /**< store WHERE for explain */
202
199
  TableList *tables_list; /**< hold 'tables' parameter of mysql_select */
219
216
    allocations that occur in repetition at execution time will result in
220
217
    excessive memory usage.
221
218
  */
222
 
  SortField *sortorder;                        // make_unireg_sortorder()
 
219
  SORT_FIELD *sortorder;                        // make_unireg_sortorder()
223
220
  Table **table_reexec;                         // make_simple_join()
224
221
  JoinTable *join_tab_reexec;                    // make_simple_join()
225
222
  /* end of allocation caching storage */
226
223
 
227
224
  /** Constructors */
228
 
  Join(Session *session_arg, 
 
225
  JOIN(Session *session_arg, 
229
226
       List<Item> &fields_arg, 
230
227
       uint64_t select_options_arg,
231
228
       select_result *result_arg)
274
271
      unit(NULL),
275
272
      select_lex(NULL),
276
273
      select(NULL),
 
274
      sj_subselects(session_arg->mem_root, 4),
277
275
      exec_tmp_table1(NULL),
278
276
      exec_tmp_table2(NULL),
279
277
      sum_funcs(NULL),
403
401
              uint32_t wind_num,
404
402
              COND *conds,
405
403
              uint32_t og_num,
406
 
              Order *order,
407
 
              Order *group,
 
404
              order_st *order,
 
405
              order_st *group,
408
406
              Item *having,
409
407
              Select_Lex *select,
410
408
              Select_Lex_Unit *unit);
446
444
    memory consumption.
447
445
  */
448
446
  void join_free();
449
 
  /** Cleanup this Join, possibly for reuse */
 
447
  /** Cleanup this JOIN, possibly for reuse */
450
448
  void cleanup(bool full);
451
449
  void clear();
452
450
  bool save_join_tab();
471
469
  void copyPartialPlanIntoOptimalPlan(uint32_t size)
472
470
  {
473
471
    memcpy(best_positions, positions, 
474
 
           sizeof(optimizer::Position) * size);
 
472
           sizeof(drizzled::optimizer::Position) * size);
475
473
  }
476
474
 
477
 
  void cache_const_exprs();
478
 
 
479
475
  /**
480
476
   * @param[in] index the index of the position to retrieve
481
477
   * @return a reference to the specified position in the optimal
482
478
   *         query plan
483
479
   */
484
 
  optimizer::Position &getPosFromOptimalPlan(uint32_t index)
 
480
  drizzled::optimizer::Position &getPosFromOptimalPlan(uint32_t index)
485
481
  {
486
482
    return best_positions[index];
487
483
  }
491
487
   * @return a reference to the specified position in the partial
492
488
   *         query plan
493
489
   */
494
 
  optimizer::Position &getPosFromPartialPlan(uint32_t index)
 
490
  drizzled::optimizer::Position &getPosFromPartialPlan(uint32_t index)
495
491
  {
496
492
    return positions[index];
497
493
  }
500
496
   * @param[in] index the index of the position to set
501
497
   * @param[in] in_pos the value to set the position to
502
498
   */
503
 
  void setPosInPartialPlan(uint32_t index, optimizer::Position &in_pos)
 
499
  void setPosInPartialPlan(uint32_t index, drizzled::optimizer::Position &in_pos)
504
500
  {
505
501
    positions[index]= in_pos;
506
502
  }
508
504
  /**
509
505
   * @return a pointer to the first position in the partial query plan
510
506
   */
511
 
  optimizer::Position *getFirstPosInPartialPlan()
 
507
  drizzled::optimizer::Position *getFirstPosInPartialPlan()
512
508
  {
513
509
    return positions;
514
510
  }
518
514
   *                  query plan
519
515
   * @return a pointer to the position in the partial query plan
520
516
   */
521
 
  optimizer::Position *getSpecificPosInPartialPlan(int32_t index)
 
517
  drizzled::optimizer::Position *getSpecificPosInPartialPlan(int32_t index)
522
518
  {
523
519
    return positions + index;
524
520
  }
525
521
 
526
522
};
527
523
 
528
 
enum_nested_loop_state evaluate_join_record(Join *join, JoinTable *join_tab, int error);
529
 
enum_nested_loop_state evaluate_null_complemented_join_record(Join *join, JoinTable *join_tab);
530
 
enum_nested_loop_state flush_cached_records(Join *join, JoinTable *join_tab, bool skip_last);
531
 
enum_nested_loop_state end_send(Join *join, JoinTable *join_tab, bool end_of_records);
532
 
enum_nested_loop_state end_write(Join *join, JoinTable *join_tab, bool end_of_records);
533
 
enum_nested_loop_state end_update(Join *join, JoinTable *join_tab, bool end_of_records);
534
 
enum_nested_loop_state end_unique_update(Join *join, JoinTable *join_tab, bool end_of_records);
535
 
 
536
 
} /* namespace drizzled */
 
524
enum_nested_loop_state evaluate_join_record(JOIN *join, JoinTable *join_tab, int error);
 
525
enum_nested_loop_state evaluate_null_complemented_join_record(JOIN *join, JoinTable *join_tab);
 
526
enum_nested_loop_state flush_cached_records(JOIN *join, JoinTable *join_tab, bool skip_last);
 
527
enum_nested_loop_state end_send(JOIN *join, JoinTable *join_tab, bool end_of_records);
 
528
enum_nested_loop_state end_write(JOIN *join, JoinTable *join_tab, bool end_of_records);
 
529
enum_nested_loop_state end_update(JOIN *join, JoinTable *join_tab, bool end_of_records);
 
530
enum_nested_loop_state end_unique_update(JOIN *join, JoinTable *join_tab, bool end_of_records);
537
531
 
538
532
#endif /* DRIZZLED_JOIN_H */