JoinHashTableInterface.h File Reference

#include <llvm/IR/Value.h>
#include <cstdint>
#include <set>
#include <string>
#include "Analyzer/Analyzer.h"
#include "CompilationOptions.h"

Include dependency graph for JoinHashTableInterface.h:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Classes
class	TooManyHashEntries
class	TableMustBeReplicated
class	HashJoinFail
class	FailedToFetchColumn
class	FailedToJoinOnVirtualColumn
struct	HashJoinMatchingSet
struct	DecodedJoinHashBufferEntry
class	JoinHashTableInterface

Typedefs
using	InnerOuter = std::pair< const Analyzer::ColumnVar *, const Analyzer::Expr * >

Functions
std::string	decodeJoinHashBufferToString (size_t key_component_count, size_t key_component_width, const int8_t *ptr1, const int8_t *ptr2, const int8_t *ptr3, const int8_t *ptr4, size_t buffer_size, bool raw=false)
std::ostream &	operator<< (std::ostream &os, const DecodedJoinHashBufferEntry &e)
std::ostream &	operator<< (std::ostream &os, const std::set< DecodedJoinHashBufferEntry > &s)
std::set< DecodedJoinHashBufferEntry >	decodeJoinHashBuffer (size_t key_component_count, size_t key_component_width, const int8_t *ptr1, const int8_t *ptr2, const int8_t *ptr3, const int8_t *ptr4, size_t buffer_size)

Typedef Documentation

InnerOuter

using InnerOuter = std::pair<const Analyzer::ColumnVar*, const Analyzer::Expr*>

Definition at line 74 of file JoinHashTableInterface.h.

Function Documentation

decodeJoinHashBuffer()

std::set<DecodedJoinHashBufferEntry> decodeJoinHashBuffer	(	size_t	key_component_count,
		size_t	key_component_width,
		const int8_t *	ptr1,
		const int8_t *	ptr2,
		const int8_t *	ptr3,
		const int8_t *	ptr4,
		size_t	buffer_size
	)

Definition at line 268 of file JoinHashTableInterface.cpp.

References CHECK, CHECK_LE, and CHECK_LT.

Referenced by BaselineJoinHashTable::decodeJoinHashBuffer(), and JoinHashTable::decodeJoinHashBuffer().

                        {        // total memory size
  std::set<DecodedJoinHashBufferEntry> s;

  CHECK(key_component_width == 8 || key_component_width == 4);

  auto i64ptr1 = reinterpret_cast<const int64_t*>(ptr1);
  auto i64ptr2 = reinterpret_cast<const int64_t*>(ptr2);
  auto i32ptr2 = reinterpret_cast<const int32_t*>(ptr2);
  auto i32ptr3 = reinterpret_cast<const int32_t*>(ptr3);
  auto i32ptr4 = reinterpret_cast<const int32_t*>(ptr4);
  auto i32ptr5 = reinterpret_cast<const int32_t*>(ptr1 + buffer_size);
  auto i64ptr5 = reinterpret_cast<const int64_t*>(i32ptr5);

  CHECK_LE(i64ptr1, i64ptr2);
  CHECK_LT(i64ptr2, i64ptr5);
  CHECK_LT(i32ptr2, i32ptr3);
  CHECK_LT(i32ptr3, i32ptr4);
  CHECK_LT(i32ptr4, i32ptr5);

  size_t entry_count = (ptr3 - ptr2) / sizeof(int32_t);

  if (i64ptr1 < i64ptr2) {  // BaselineJoinHashTable or OverlapsJoinHashTable
    if (key_component_width == 8) {
      innerDecodeJoinHashBuffer<int64_t>(
          ptr1, i32ptr2, i32ptr3, i32ptr4, entry_count, key_component_count, s);
    } else if (key_component_width == 4) {
      innerDecodeJoinHashBuffer<int32_t>(
          ptr1, i32ptr2, i32ptr3, i32ptr4, entry_count, key_component_count, s);
    }
  } else {  // JoinHashTable
    if (key_component_width == 8) {
      innerDecodeJoinHashBuffer<int64_t>(i32ptr2, i32ptr3, i32ptr4, entry_count, s);
    } else if (key_component_width == 4) {
      innerDecodeJoinHashBuffer<int32_t>(i32ptr2, i32ptr3, i32ptr4, entry_count, s);
    }
  }

  return s;
}

Here is the caller graph for this function:

decodeJoinHashBufferToString()

std::string decodeJoinHashBufferToString	(	size_t	key_component_count,
		size_t	key_component_width,
		const int8_t *	ptr1,
		const int8_t *	ptr2,
		const int8_t *	ptr3,
		const int8_t *	ptr4,
		size_t	buffer_size,
		bool	raw = false
	)

Definition at line 53 of file JoinHashTableInterface.cpp.

References CHECK, CHECK_LE, CHECK_LT, and to_string().

Referenced by BaselineJoinHashTable::toString(), and JoinHashTable::toString().

              {
  std::string txt;

  CHECK(key_component_width == 8 || key_component_width == 4);

  auto i64ptr1 = reinterpret_cast<const int64_t*>(ptr1);
  auto i64ptr2 = reinterpret_cast<const int64_t*>(ptr2);
  auto i32ptr2 = reinterpret_cast<const int32_t*>(ptr2);
  auto i32ptr3 = reinterpret_cast<const int32_t*>(ptr3);
  auto i32ptr4 = reinterpret_cast<const int32_t*>(ptr4);
  auto i32ptr5 = reinterpret_cast<const int32_t*>(ptr1 + buffer_size);
  auto i64ptr5 = reinterpret_cast<const int64_t*>(i32ptr5);

  CHECK_LE(i64ptr1, i64ptr2);
  CHECK_LT(i64ptr2, i64ptr5);
  CHECK_LT(i32ptr2, i32ptr3);
  CHECK_LT(i32ptr3, i32ptr4);
  CHECK_LT(i32ptr4, i32ptr5);

  size_t entry_count = (ptr3 - ptr2) / sizeof(int32_t);

  // first section: keys
  if (i64ptr1 < i64ptr2) {
    if (key_component_width == 8) {
      innerDecodeJoinHashBufferToString<int64_t>(
          ptr1, entry_count, key_component_count, raw, txt);
    } else if (key_component_width == 4) {
      innerDecodeJoinHashBufferToString<int32_t>(
          ptr1, entry_count, key_component_count, raw, txt);
    }

    txt += " | ";
  }

  // second section: offsets
  for (size_t i = 0; &i32ptr2[i] < i32ptr3; ++i) {
    if (i != 0) {
      txt += " ";
    }
    if (i32ptr2[i] == -1) {
      txt += "*";  // null
    } else {
      txt += std::to_string(i32ptr2[i]);
    }
  }

  txt += " | ";

  // third section: counts
  for (size_t i = 0; &i32ptr3[i] < i32ptr4; ++i) {
    if (i != 0) {
      txt += " ";
    }
    if (i32ptr3[i] == 0) {
      txt += "*";  // null
    } else {
      txt += std::to_string(i32ptr3[i]);
    }
  }

  txt += " | ";

  // fourth section: payloads (rowids)
  for (size_t i = 0; &i32ptr4[i] < i32ptr5; ++i) {
    if (i != 0) {
      txt += " ";
    }
    if (i32ptr4[i] == -1) {
      txt += "*";  // null
    } else {
      txt += std::to_string(i32ptr4[i]);
    }
  }

  return txt;
}

Here is the call graph for this function:

Here is the caller graph for this function:

operator<<() [1/2]

std::ostream& operator<<	(	std::ostream &	os,
		const DecodedJoinHashBufferEntry &	e
	)

Definition at line 169 of file JoinHashTableInterface.cpp.

References DecodedJoinHashBufferEntry::key, and DecodedJoinHashBufferEntry::payload.

                                                                            {
  os << "(";
  bool first = true;
  for (auto k : e.key) {
    if (!first) {
      os << ",";
    } else {
      first = false;
    }
    os << k;
  }
  os << ")";
  os << ": ";
  first = true;
  for (auto p : e.payload) {
    if (!first) {
      os << " ";
    } else {
      first = false;
    }
    os << p;
  }
  return os;
}

operator<<() [2/2]

std::ostream& operator<<	(	std::ostream &	os,
		const std::set< DecodedJoinHashBufferEntry > &	s
	)

Definition at line 194 of file JoinHashTableInterface.cpp.

                                                                      {
  for (auto e : s) {
    os << e << "\n";
  }
  return os;
}