public:

/**

BKAIterator(THD *thd, unique_ptr_destroy_only<RowIterator> outer_input,

const Prealloced_array<TABLE *, 4> &outer_input_tables,

unique_ptr_destroy_only<RowIterator> inner_input,

size_t max_memory_available,

size_t mrr_bytes_needed_for_single_inner_row,

float expected_inner_rows_per_outer_row, bool store_rowids,

table_map tables_to_get_rowid_for,

MultiRangeRowIterator *mrr_iterator, JoinType join_type);

bool Init() override;

int Read() override;

void SetNullRowFlag(bool is_null_row) override {

m_outer_input->SetNullRowFlag(is_null_row);

m_inner_input->SetNullRowFlag(is_null_row);

}

void UnlockRow() override {

// Since we don't know which condition that caused the row to be rejected,

// we can't know whether we could also unlock the outer row

// (it may still be used as parts of other joined rows).

if (m_state == State::RETURNING_JOINED_ROWS) {

m_inner_input->UnlockRow();

}

}

void EndPSIBatchModeIfStarted() override {

m_outer_input->EndPSIBatchModeIfStarted();

m_inner_input->EndPSIBatchModeIfStarted();

}

private:

/// Clear out the MEM_ROOT and prepare for reading rows anew.

void BeginNewBatch();

/// If there are more outer rows, begin the next batch. If not,

/// move to the EOF state.

void BatchFinished();

/// Find the next unmatched row, and load it for output as a NULL-complemented

/// row. (Assumes the NULL row flag has already been set on the inner table

/// iterator.) Returns 0 if a row was found, -1 if no row was found. (Errors

/// cannot happen.)

int MakeNullComplementedRow();

/// Read a batch of outer rows (BeginNewBatch() must have been called

/// earlier). Returns -1 for no outer rows found (sets state to END_OF_ROWS),

/// 0 for OK (sets state to RETURNING_JOINED_ROWS) or 1 for error.

int ReadOuterRows();

enum class State {

/**

NEED_OUTER_ROWS,

/**

RETURNING_JOINED_ROWS,

/**

RETURNING_NULL_COMPLEMENTED_ROWS,

/**

END_OF_ROWS

};

State m_state;

const unique_ptr_destroy_only<RowIterator> m_outer_input;

const unique_ptr_destroy_only<RowIterator> m_inner_input;

/// The MEM_ROOT we are storing the outer rows on, and also allocating MRR

/// buffer from. In total, this should not go significantly over

/// m_max_memory_available bytes.

MEM_ROOT m_mem_root;

/// Buffered outer rows.

Mem_root_array<hash_join_buffer::BufferRow> m_rows;

/// Tables and columns needed for each outer row. Rows/columns that are not

/// needed are filtered out in the constructor; the rest are read and stored

/// in m_rows.

pack_rows::TableCollection m_outer_input_tables;

/// Used for serializing the row we read from the outer table(s), before it

/// stored into the MEM_ROOT and put into m_rows. Should there not be room in

/// m_rows for the row, it will stay in this variable until we start reading

/// the next batch of outer rows.

///

/// If there are no BLOB/TEXT column in the join, we calculate an upper bound

/// of the row size that is used to preallocate this buffer. In the case of

/// BLOB/TEXT columns, we cannot calculate a reasonable upper bound, and the

/// row size is calculated per row. The allocated memory is kept for the

/// duration of the iterator, so that we (most likely) avoid reallocations.

String m_outer_row_buffer;

/// Whether we have a row in m_outer_row_buffer from the previous batch of

/// rows that we haven't stored in m_rows yet.

bool m_has_row_from_previous_batch = false;

/// For each outer row, how many bytes we need in the MRR buffer (ie., the

/// number of bytes we expect to use on rows from the inner table).

/// This is the expected number of inner rows per key, multiplied by the

/// (fixed) size of each inner row. We use this information to stop scanning

/// before we've used up the entire RAM allowance on outer rows, so that

/// we have space remaining for the inner rows (in the MRR buffer), too.

size_t m_mrr_bytes_needed_per_row;

/// Estimated number of bytes used on m_mem_root so far.

size_t m_bytes_used = 0;

/// Whether we've seen EOF from the outer iterator.

bool m_end_of_outer_rows = false;

/// See max_memory_available in the constructor.

const size_t m_max_memory_available;

/// See max_memory_available in the constructor.

const size_t m_mrr_bytes_needed_for_single_inner_row;

/// See mrr_iterator in the constructor.

MultiRangeRowIterator *const m_mrr_iterator;

/// The join type of the BKA join.

JoinType m_join_type;

/// If we are synthesizing NULL-complemented rows (for an outer join or

/// antijoin), points to the next row within "m_rows" that we haven't

/// considered yet.

hash_join_buffer::BufferRow *m_current_pos;

public:

/**

MultiRangeRowIterator(THD *thd, TABLE *table, Index_lookup *ref,

int mrr_flags, JoinType join_type,

const Prealloced_array<TABLE *, 4> &outer_input_tables,

bool store_rowids, table_map tables_to_get_rowid_for);

/**

void set_rows(const hash_join_buffer::BufferRow *begin,

const hash_join_buffer::BufferRow *end) {

m_begin = begin;

m_end = end;

}

/**

void set_mrr_buffer(uchar *ptr, size_t size) {

m_mrr_buffer.buffer = ptr;

m_mrr_buffer.buffer_end = ptr + size;

}

/**

void set_match_flag_buffer(uchar *ptr) { m_match_flag_buffer = ptr; }

/**

void MarkLastRowAsRead() {

if (m_match_flag_buffer != nullptr) {

size_t row_number = std::distance(m_begin, m_last_row_returned);

m_match_flag_buffer[row_number / 8] |= 1 << (row_number % 8);

}

}

/**

bool RowHasBeenRead(const hash_join_buffer::BufferRow *row) const {

assert(m_match_flag_buffer != nullptr);

size_t row_number = std::distance(m_begin, row);

return m_match_flag_buffer[row_number / 8] & (1 << (row_number % 8));

}

/**

bool Init() override;

/**

int Read() override;

private:

// Thunks from function pointers to the actual callbacks.

static range_seq_t MrrInitCallbackThunk(void *init_params, uint n_ranges,

uint flags) {

return (pointer_cast<MultiRangeRowIterator *>(init_params))

->MrrInitCallback(n_ranges, flags);

}

static uint MrrNextCallbackThunk(void *init_params, KEY_MULTI_RANGE *range) {

return (pointer_cast<MultiRangeRowIterator *>(init_params))

->MrrNextCallback(range);

}

static bool MrrSkipRecordCallbackThunk(range_seq_t seq, char *range_info,

uchar *) {

return (reinterpret_cast<MultiRangeRowIterator *>(seq))

->MrrSkipRecord(range_info);

}

// Callbacks we get from the handler during the actual read.

range_seq_t MrrInitCallback(uint n_ranges, uint flags);

uint MrrNextCallback(KEY_MULTI_RANGE *range);

bool MrrSkipIndexTuple(char *range_info);

bool MrrSkipRecord(char *range_info);

/// Handler for the table we are reading from.

handler *const m_file;

/// The index condition.

Index_lookup *const m_ref;

/// Flags passed on to MRR.

const int m_mrr_flags;

/// Current outer rows to read inner rows for. Set by set_rows().

const hash_join_buffer::BufferRow *m_begin;

const hash_join_buffer::BufferRow *m_end;

/// Which row we are at in the [m_begin, m_end) range.

/// Used during the MRR callbacks.

const hash_join_buffer::BufferRow *m_current_pos;

/// What row we last returned from Read() (used for MarkLastRowAsRead()).

const hash_join_buffer::BufferRow *m_last_row_returned;

/// Temporary space for storing inner rows, used by MRR.

/// Set by set_mrr_buffer().

HANDLER_BUFFER m_mrr_buffer;

/// See set_match_flag_buffer().

uchar *m_match_flag_buffer = nullptr;

/// Tables and columns needed for each outer row. Same as m_outer_input_tables

/// in the corresponding BKAIterator.

pack_rows::TableCollection m_outer_input_tables;

/// The join type of the BKA join we are part of. Same as m_join_type in the

/// corresponding BKAIterator.

const JoinType m_join_type;