join.h

Go to the documentation of this file.

/* - mode: c; c-basic-offset: 2; indent-tabs-mode: nil; -*-
 *  vim:expandtab:shiftwidth=2:tabstop=2:smarttab:
 *
 *  Copyright (C) 2008-2009 Sun Microsystems, Inc.
 *
 *  This program is free software; you can redistribute it and/or modify
 *  it under the terms of the GNU General Public License as published by
 *  the Free Software Foundation; either version 2 of the License, or
 *  (at your option) any later version.
 *
 *  This program is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with this program; if not, write to the Free Software
 *  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
 */

#pragma once

#include <drizzled/dynamic_array.h>
#include <drizzled/optimizer/position.h>
#include <drizzled/sql_select.h>
#include <drizzled/tmp_table_param.h>
#include <bitset>

namespace drizzled {

class Join : public memory::SqlAlloc, boost::noncopyable
{
  optimizer::Position positions[MAX_TABLES+1];

  optimizer::Position best_positions[MAX_TABLES+1];

public:
  JoinTable *join_tab;
  JoinTable **best_ref;
  JoinTable **map2table;    
  JoinTable *join_tab_save; 
  Table **table;
  Table **all_tables;
  Table *sort_by_table;

  uint32_t tables;        
  uint32_t outer_tables;  
  uint32_t const_tables;
  uint32_t send_group_parts;

  bool sort_and_group;
  bool first_record;
  bool full_join;
  bool group;
  bool no_field_update;
  bool do_send_rows;
  bool resume_nested_loop;
  bool no_const_tables;
  bool select_distinct;       
  bool group_optimized_away;

  /*
    simple_xxxxx is set if order_st/GROUP BY doesn't include any references
    to other tables than the first non-constant table in the Join.
    It's also set if order_st/GROUP BY is empty.
  */
  bool simple_order;
  bool simple_group;
  bool no_order;
  bool skip_sort_order;
  bool union_part; 
  bool optimized; 
  bool need_tmp;
  bool hidden_group_fields;

  table_map const_table_map;
  table_map found_const_table_map;
  table_map outer_join;

  ha_rows send_records;
  ha_rows found_records;
  ha_rows examined_rows;
  ha_rows row_limit;
  ha_rows select_limit;
  ha_rows fetch_limit;

  Session *session;
  List<Item> *fields;
  List<Item> &fields_list; 
  List<TableList> *join_list; 
  Select_Lex_Unit *unit;
  Select_Lex *select_lex;
  optimizer::SqlSelect *select; 
  std::bitset<64> cur_embedding_map;

  double best_read;
  List<Cached_item> group_fields;
  List<Cached_item> group_fields_cache;
  Table *tmp_table;
  Table *exec_tmp_table1;
  Table *exec_tmp_table2;
  Item_sum **sum_funcs;
  Item_sum ***sum_funcs_end;
  Item_sum **sum_funcs2;
  Item_sum ***sum_funcs_end2;
  Item *having;
  Item *tmp_having; 
  Item *having_history; 
  uint64_t select_options;
  select_result *result;
  Tmp_Table_Param tmp_table_param;
  DrizzleLock *lock;

  Join *tmp_join; 
  Rollup rollup;        
  DYNAMIC_ARRAY keyuse;
  Item::cond_result cond_value;
  Item::cond_result having_value;
  List<Item> all_fields; 
  List<Item> tmp_all_fields1;
  List<Item> tmp_all_fields2;
  List<Item> tmp_all_fields3;
  List<Item> tmp_fields_list1;
  List<Item> tmp_fields_list2;
  List<Item> tmp_fields_list3;
  int error;

  Order *order;
  Order *group_list; 
  COND *conds;                            // ---"---
  Item *conds_history; 
  TableList *tables_list; 
  COND_EQUAL *cond_equal;
  JoinTable *return_tab; 
  Item **ref_pointer_array; 
  Item **items0;
  Item **items1;
  Item **items2;
  Item **items3;
  Item **current_ref_pointer_array;
  uint32_t ref_pointer_array_size; 
  const char *zero_result_cause; 

  /*
    storage for caching buffers allocated during query execution.
    These buffers allocations need to be cached as the thread memory pool is
    cleared only at the end of the execution of the whole query and not caching
    allocations that occur in repetition at execution time will result in
    excessive memory usage.
  */
  SortField *sortorder;                        // make_unireg_sortorder()
  Table **table_reexec;                         // make_simple_join()
  JoinTable *join_tab_reexec;                    // make_simple_join()
  /* end of allocation caching storage */

  Join(Session *session_arg, 
       List<Item> &fields_arg, 
       uint64_t select_options_arg,
       select_result *result_arg);

  void reset(Session *session_arg, 
             List<Item> &fields_arg, 
             uint64_t select_options_arg,
             select_result *result_arg);

  int prepare(Item ***rref_pointer_array, 
              TableList *tables,
              uint32_t wind_num,
              COND *conds,
              uint32_t og_num,
              Order *order,
              Order *group,
              Item *having,
              Select_Lex *select,
              Select_Lex_Unit *unit);

  int optimize();
  int reinit();
  void exec();
  int destroy();
  void restore_tmp();
  bool alloc_func_list();
  bool setup_subquery_materialization();
  bool make_sum_func_list(List<Item> &all_fields, 
                          List<Item> &send_fields,
                          bool before_group_by,
                          bool recompute= false);

  inline void set_items_ref_array(Item **ptr)
  {
    memcpy(ref_pointer_array, ptr, ref_pointer_array_size);
    current_ref_pointer_array= ptr;
  }
  inline void init_items_ref_array()
  {
    items0= ref_pointer_array + all_fields.size();
    memcpy(items0, ref_pointer_array, ref_pointer_array_size);
    current_ref_pointer_array= items0;
  }

  bool rollup_init();
  bool rollup_make_fields(List<Item> &all_fields, 
                          List<Item> &fields,
                          Item_sum ***func);
  int rollup_send_data(uint32_t idx);
  int rollup_write_data(uint32_t idx, Table *table);
  void remove_subq_pushed_predicates(Item **where);
  void join_free();
  void cleanup(bool full);
  void clear();
  void save_join_tab();
  void init_save_join_tab();
  bool send_row_on_empty_set()
  {
    return (do_send_rows && tmp_table_param.sum_func_count != 0 &&
      !group_list);
  }
  bool change_result(select_result *result);
  bool is_top_level_join() const;

  void copyPartialPlanIntoOptimalPlan(uint32_t size)
  {
    memcpy(best_positions, positions, 
           sizeof(optimizer::Position) * size);
  }

  void cache_const_exprs();

  optimizer::Position &getPosFromOptimalPlan(uint32_t index)
  {
    return best_positions[index];
  }

  optimizer::Position &getPosFromPartialPlan(uint32_t index)
  {
    return positions[index];
  }

  void setPosInPartialPlan(uint32_t index, optimizer::Position &in_pos)
  {
    positions[index]= in_pos;
  }

  optimizer::Position *getFirstPosInPartialPlan()
  {
    return positions;
  }

  optimizer::Position *getSpecificPosInPartialPlan(int32_t index)
  {
    return positions + index;
  }

};

enum_nested_loop_state evaluate_join_record(Join *join, JoinTable *join_tab, int error);
enum_nested_loop_state evaluate_null_complemented_join_record(Join *join, JoinTable *join_tab);
enum_nested_loop_state flush_cached_records(Join *join, JoinTable *join_tab, bool skip_last);
enum_nested_loop_state end_send(Join *join, JoinTable *join_tab, bool end_of_records);
enum_nested_loop_state end_write(Join *join, JoinTable *join_tab, bool end_of_records);
enum_nested_loop_state end_update(Join *join, JoinTable *join_tab, bool end_of_records);
enum_nested_loop_state end_unique_update(Join *join, JoinTable *join_tab, bool end_of_records);

} /* namespace drizzled */