~drizzle-trunk/drizzle/development

 

 

/* classes to use when handling where clause */

 

 

typedef struct st_key_part {

  uint16_t           key,part;

 

class QUICK_RANGE :public Sql_alloc {

 public:

  uint16_t min_length,max_length,flag;

  key_part_map min_keypart_map, // bitmap of used keyparts in min_key

               max_keypart_map; // bitmap of used keyparts in max_key

  uint16_t dummy;                                       /* Avoid warnings on 'flag' */

#endif

  QUICK_RANGE();                                /* Full range */

              key_part_map min_keypart_map_arg,

              key_part_map max_keypart_map_arg,

      min_length((uint16_t) min_length_arg),

      max_length((uint16_t) max_length_arg),

      flag((uint16_t) flag_arg),

  bool sorted;

  ha_rows records;  /* estimate of # of records to be retrieved */

  double  read_time; /* time to perform this retrieval          */

  /*

    Index this quick select uses, or MAX_KEY for quick selects

    that use several indexes

  */

 

  /*

    Total length of first used_key_parts parts of the key.

    Applicable if index!= MAX_KEY.

  */

 

  /*

    Max. number of (first) key parts this quick select uses for retrieval.

 

    For QUICK_GROUP_MIN_MAX_SELECT it includes MIN/MAX argument keyparts.

  */

 

  QUICK_SELECT_I();

  virtual ~QUICK_SELECT_I(){};

      0     Ok

      other Error

  */

  { assert(0); return 1; }

 

  /*

    This function is implemented only by quick selects that merge other quick

    selects output and/or can produce output suitable for merging.

  */

  /*

    Return 1 if any index used by this quick select

    uses field which is marked in passed bitmap.

    rowid of last row retrieved by this quick select. This is used only when

    doing ROR-index_merge selects

  */

 

  /*

    Table record buffer used by this quick select.

  */

};

 

 

  QUICK_RANGE **last;

} QUICK_RANGE_SEQ_CTX;

 

 

 

/*

  /* Members needed to use the MRR interface */

  QUICK_RANGE_SEQ_CTX qr_traversal_ctx;

public:

protected:

  HANDLER_BUFFER *mrr_buf_desc; /* the handler buffer */

 

  /* Info about index we're scanning */

public:

  MEM_ROOT alloc;

 

                     MEM_ROOT *parent_alloc, bool *create_err);

  ~QUICK_RANGE_SELECT();

 

  int reset(void);

  int get_next();

  void range_end();

  bool reverse_sorted() { return 0; }

  bool unique_key_range();

  int init_ror_merged_scan(bool reuse_handler);

  int get_type() { return QS_TYPE_RANGE; }

  void add_keys_and_lengths(String *key_names, String *used_lengths);

  void add_info_string(String *str);

  }

  friend class TRP_ROR_INTERSECT;

  friend

                                               struct st_table_ref *ref,

                                               ha_rows records);

  friend bool get_quick_keys(PARAM *param, QUICK_RANGE_SELECT *quick, 

                             KEY_PART *key, SEL_ARG *key_tree, 

                                              SEL_ARG *key_tree,

                                              MEM_ROOT *alloc);

  friend class QUICK_SELECT_DESC;

  friend class QUICK_INDEX_MERGE_SELECT;

  friend class QUICK_ROR_INTERSECT_SELECT;

  friend class QUICK_GROUP_MIN_MAX_SELECT;

  friend range_seq_t quick_range_seq_init(void *init_param,

  friend void select_describe(JOIN *join, bool need_tmp_table, bool need_order,

                              bool distinct,const char *message);

};

class QUICK_INDEX_MERGE_SELECT : public QUICK_SELECT_I

{

public:

  ~QUICK_INDEX_MERGE_SELECT();

 

  int  init();

  bool  doing_pk_scan;

 

  MEM_ROOT alloc;

  int read_keys_and_merge();

 

  /* used to get rows collected in Unique */

class QUICK_ROR_INTERSECT_SELECT : public QUICK_SELECT_I

{

public:

                             bool retrieve_full_rows,

                             MEM_ROOT *parent_alloc);

  ~QUICK_ROR_INTERSECT_SELECT();

  QUICK_RANGE_SELECT *cpk_quick;

 

  MEM_ROOT alloc; /* Memory pool for this and merged quick selects data. */

  bool need_to_fetch_row; /* if true, do retrieve full table records. */

  /* in top-level quick select, true if merged scans where initialized */

  bool scans_inited; 

class QUICK_ROR_UNION_SELECT : public QUICK_SELECT_I

{

public:

  ~QUICK_ROR_UNION_SELECT();

 

  int  init();

  QUEUE queue;    /* Priority queue for merge operation */

  MEM_ROOT alloc; /* Memory pool for this and merged quick selects data. */