abstract_query_plan.h

/*
   Copyright (c) 2010, 2011, Oracle and/or its affiliates. All rights reserved.

   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; version 2 of the License.

   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
*/

#ifndef ABSTRACT_QUERY_PLAN_H_INCLUDED
#define ABSTRACT_QUERY_PLAN_H_INCLUDED

struct TABLE;
struct st_join_table;
typedef st_join_table JOIN_TAB;
class JOIN;
class Item;
class Item_field;
class Item_equal_iterator;

#include "sql_list.h"

namespace AQP
{
  class Table_access;

  class Join_plan : public Sql_alloc
  {
    friend class Equal_set_iterator;
    friend class Table_access;
  public:

    explicit Join_plan(const JOIN* join);

    ~Join_plan();

    const Table_access* get_table_access(uint access_no) const;

    uint get_access_count() const;

  private:
    const JOIN_TAB* const m_join_tabs;

    const uint m_access_count;
    Table_access* m_table_accesses;

    const JOIN_TAB* get_join_tab(uint join_tab_no) const;

    // No copying.
    Join_plan(const Join_plan&);
    Join_plan& operator=(const Join_plan&);
  }; 
  // class Join_plan


  class Equal_set_iterator : public Sql_alloc
  {
  public:
    explicit Equal_set_iterator(Item_equal& item_equal)
    : m_iterator(item_equal) {}

    const Item_field* next()
    { return m_iterator++; }

  private:
    Item_equal_iterator m_iterator;

    // No copying.
    Equal_set_iterator(const Equal_set_iterator&);
    Equal_set_iterator& operator=(const Equal_set_iterator&);
  }; 
  // class Equal_set_iterator

  enum enum_access_type
  {
    AT_VOID,
    AT_FIXED,
    AT_PRIMARY_KEY,
    AT_UNIQUE_KEY,
    AT_ORDERED_INDEX_SCAN,
    AT_MULTI_PRIMARY_KEY,
    AT_MULTI_UNIQUE_KEY,
    AT_MULTI_MIXED,
    AT_TABLE_SCAN,
    AT_UNDECIDED,
    AT_OTHER
  };

  enum enum_join_type
  {
    JT_OUTER_JOIN,
    JT_INNER_JOIN,
    JT_SEMI_JOIN
  };

  class Table_access : public Sql_alloc
  {
    friend class Join_plan;
    friend inline bool equal(const Table_access*, const Table_access*);
  public:

    const Join_plan* get_join_plan() const;

    enum_access_type get_access_type() const;

    const char* get_other_access_reason() const;

    enum_join_type get_join_type(const Table_access* parent) const;

    uint get_no_of_key_fields() const;

    const Item* get_key_field(uint field_no) const;

    const KEY_PART_INFO* get_key_part_info(uint field_no) const;

    uint get_access_no() const;

    int get_index_no() const;

    TABLE* get_table() const;

    double get_fanout() const;

    Item_equal* get_item_equal(const Item_field* field_item) const;

    void dbug_print() const;

    bool uses_join_cache() const;

    bool filesort_before_join() const;

  private:

    const Join_plan* m_join_plan;

    uint m_tab_no;

    mutable enum_access_type m_access_type;

    mutable const char* m_other_access_reason;

    mutable int m_index_no;

    explicit Table_access();

    const JOIN_TAB* get_join_tab() const;

    void compute_type_and_index() const;

    Table_access(const Table_access&);
    Table_access& operator=(const Table_access&);
  }; 
  // class Table_access

  inline const Table_access* Join_plan::get_table_access(uint access_no) const
  {
    DBUG_ASSERT(access_no < m_access_count);
    return m_table_accesses + access_no;
  }

  inline uint Join_plan::get_access_count() const
  { 
    return m_access_count;
  }

  inline const Join_plan* Table_access::get_join_plan() const
  {
    return m_join_plan;
  }

  inline enum_access_type Table_access::get_access_type() const
  {
    if (m_access_type == AT_VOID)
      compute_type_and_index();
    return m_access_type;
  }

  inline const char* Table_access::get_other_access_reason() const
  {
    if (m_access_type == AT_VOID)
      compute_type_and_index();
    return m_other_access_reason;
  }

  inline int Table_access::get_index_no() const
  {
    if (m_access_type == AT_VOID)
      compute_type_and_index();
        
    return m_index_no;
  }

  inline uint Table_access::get_access_no() const
  { 
    return m_tab_no;
  }

}; 
// namespace AQP

#endif