ChunkAccessorTable.h File Reference

#include "Catalog/CatalogFwd.h"
#include "DataMgr/Chunk/Chunk.h"
#include <tuple>
#include <vector>

Include dependency graph for ChunkAccessorTable.h:

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

Go to the source code of this file.

Typedefs
using	ChunkIterVector = std::vector< ChunkIter >
using	ChunkAccessorTable = std::vector< std::tuple< size_t, std::vector< std::shared_ptr< Chunk_NS::Chunk >>, ChunkIterVector >>

Functions
ChunkAccessorTable	getChunkAccessorTable (const Catalog_Namespace::Catalog &cat, const TableDescriptor *td, const std::vector< std::string > &columnNames)
ChunkIterVector &	getChunkItersAndRowOffset (ChunkAccessorTable &table, size_t rowid, size_t &rowOffset)

Typedef Documentation

using ChunkAccessorTable = std::vector< std::tuple<size_t, std::vector<std::shared_ptr<Chunk_NS::Chunk>>, ChunkIterVector>>

Definition at line 36 of file ChunkAccessorTable.h.

using ChunkIterVector = std::vector<ChunkIter>

Definition at line 34 of file ChunkAccessorTable.h.

Function Documentation

ChunkAccessorTable getChunkAccessorTable	(	const Catalog_Namespace::Catalog &	cat,
		const TableDescriptor *	td,
		const std::vector< std::string > &	columnNames
	)

Definition at line 29 of file ChunkAccessorTable.cpp.

References CHECK, Data_Namespace::CPU_LEVEL, Catalog_Namespace::DBMetadata::dbId, TableDescriptor::fragmenter, Chunk_NS::Chunk::getChunk(), Catalog_Namespace::Catalog::getCurrentDB(), Catalog_Namespace::Catalog::getDataMgr(), Catalog_Namespace::Catalog::getMetadataForColumn(), TableDescriptor::tableId, and TableDescriptor::tableName.

Referenced by import_export::RenderGroupAnalyzer::seedFromExistingTableContents().

                                                                                  {
  ChunkAccessorTable table;

  // get fragments
  const auto tableInfo = td->fragmenter->getFragmentsForQuery();
  if (tableInfo.fragments.size() == 0) {
    throw std::runtime_error("No fragments in table '" + td->tableName + "'");
  }

  // for each fragment...
  for (const auto& fragment : tableInfo.fragments) {
    // add a table entry for it
    table.emplace_back();
    std::get<0>(table.back()) = 0;

    // for each column...
    bool isFirstColumn = true;
    for (const auto& columnName : columnNames) {
      // get column descriptor
      const auto cd = cat.getMetadataForColumn(td->tableId, columnName);
      if (!cd) {
        throw std::runtime_error("Failed to find physical column '" + columnName + "'");
      }

      // find the chunk
      ChunkKey chunkKey{
          cat.getCurrentDB().dbId, td->tableId, cd->columnId, fragment.fragmentId};
      auto chunkMetaIt = fragment.getChunkMetadataMap().find(cd->columnId);
      if (chunkMetaIt == fragment.getChunkMetadataMap().end()) {
        throw std::runtime_error("Failed to find the chunk for column: " +
                                 cd->columnName + " in table: " + td->tableName +
                                 ". The column was likely deleted via a table truncate.");
      }

      // get the chunk
      std::shared_ptr<Chunk_NS::Chunk> chunk =
          Chunk_NS::Chunk::getChunk(cd,
                                    &cat.getDataMgr(),
                                    chunkKey,
                                    Data_Namespace::CPU_LEVEL,
                                    0,
                                    chunkMetaIt->second->numBytes,
                                    chunkMetaIt->second->numElements);
      CHECK(chunk);

      // the size
      size_t chunkSize = chunkMetaIt->second->numElements;

      // and an iterator
      ChunkIter chunkIt = chunk->begin_iterator(chunkMetaIt->second);

      // populate table entry
      if (isFirstColumn) {
        // store the size
        std::get<0>(table.back()) = chunkSize;
        isFirstColumn = false;
      } else {
        // all columns chunks must be the same size
        CHECK(std::get<0>(table.back()) == chunkSize);
      }
      std::get<1>(table.back()).push_back(chunk);
      std::get<2>(table.back()).push_back(chunkIt);
    }
  }

  // prefix-sum the per-fragment counts
  // these are now "first row of next fragment"
  size_t sum = 0;
  for (auto& entry : table) {
    sum += std::get<0>(entry);
    std::get<0>(entry) = sum;
  }

  // done
  return table;
}

Here is the call graph for this function:

Here is the caller graph for this function:

ChunkIterVector& getChunkItersAndRowOffset	(	ChunkAccessorTable &	table,
		size_t	rowid,
		size_t &	rowOffset
	)

Definition at line 108 of file ChunkAccessorTable.cpp.

References CHECK.

Referenced by import_export::RenderGroupAnalyzer::seedFromExistingTableContents().

                                                              {
  rowOffset = 0;
  for (auto& entry : table) {
    if (rowid < std::get<0>(entry)) {
      return std::get<2>(entry);
    }
    rowOffset = std::get<0>(entry);
  }
  CHECK(false);
  static ChunkIterVector emptyChunkIterVector;
  return emptyChunkIterVector;
}

Here is the caller graph for this function: