CellStore.h

Go to the documentation of this file.

/*
 * Copyright (C) 2007-2015 Hypertable, Inc.
 *
 * This file is part of Hypertable.
 *
 * Hypertable 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 3 of the
 * License, or any later version.
 *
 * Hypertable 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 Street, Fifth Floor, Boston, MA
 * 02110-1301, USA.
 */


#ifndef Hypertable_RangeServer_CellStore_h
#define Hypertable_RangeServer_CellStore_h

#include <Hypertable/RangeServer/CellList.h>
#include <Hypertable/RangeServer/CellListScannerBuffer.h>
#include <Hypertable/RangeServer/CellStoreBlockIndexArray.h>
#include <Hypertable/RangeServer/CellStoreTrailer.h>
#include <Hypertable/RangeServer/KeyDecompressor.h>

#include <Hypertable/Lib/BlockCompressionCodec.h>
#include <Hypertable/Lib/TableIdentifier.h>

#include <Common/String.h>
#include <Common/ByteString.h>
#include <Common/Filesystem.h>

#include <memory>
#include <mutex>
#include <vector>

namespace Hypertable {


  class CellStore : public CellList, public std::enable_shared_from_this<CellStore> {
  public:

    class IndexMemoryStats {
    public:
      IndexMemoryStats() :
        bloom_filter_memory(0), bloom_filter_access_counter(0),
        block_index_memory(0), block_index_access_counter(0) { }
      int64_t  bloom_filter_memory;
      uint64_t bloom_filter_access_counter;
      int64_t  block_index_memory;
      uint64_t block_index_access_counter;
    };

    CellStore() : m_bytes_read(0), m_block_count(0), m_index_refcount(0) { }

    virtual ~CellStore() { return; }

    virtual void add(const Key &key, const ByteString value) = 0;

    virtual void split_row_estimate_data(SplitRowDataMapT &split_row_data) {
      HT_FATAL("Not implemented!");
    }

    virtual void populate_index_pseudo_table_scanner(CellListScannerBuffer *scanner) { }

    virtual int64_t get_total_entries() = 0;

    virtual CellListScannerPtr
      create_scanner(ScanContext *scan_ctx) { return CellListScannerPtr(); }

    virtual void create(const char *fname, size_t max_entries,
                        PropertiesPtr &props, const TableIdentifier *table_id=0) = 0;

    virtual void finalize(TableIdentifier *table_identifier) = 0;

    virtual void open(const String &fname, const String &start_row,
                      const String &end_row, int32_t fd, int64_t file_length,
                      CellStoreTrailer *trailer) = 0;

    virtual void rescope(const String &start_row, const String &end_row) {
      HT_FATAL("Not implemented!");
    }

    virtual int64_t get_blocksize() = 0;

    virtual bool may_contain(ScanContext *scan_ctx) = 0;

    virtual uint64_t disk_usage() = 0;

    virtual size_t block_count() {
      std::lock_guard<std::mutex> lock(m_mutex);
      return m_block_count;
    }

    virtual float compression_ratio() = 0;

    virtual std::string &get_filename() = 0;

    virtual int get_file_id() = 0;

    virtual CellStoreTrailer *get_trailer() = 0;

    virtual BlockCompressionCodec *create_block_compression_codec() = 0;

    virtual KeyDecompressor *create_key_decompressor();

    virtual void set_replaced_files(const std::vector<String> &old_files);

    virtual const std::vector<String> &get_replaced_files();

    virtual void display_block_info() = 0;

    virtual size_t bloom_filter_size() = 0;

    virtual int32_t get_fd() = 0;

    virtual int32_t reopen_fd() = 0;

    virtual int64_t bloom_filter_memory_used() = 0;

    virtual int64_t block_index_memory_used() = 0;

    virtual int64_t end_of_last_block() = 0;

    virtual uint64_t purge_indexes() = 0;

    virtual void get_index_memory_stats(IndexMemoryStats *statsp) {
      std::lock_guard<std::mutex> lock(m_mutex);
      memcpy(statsp, &m_index_stats, sizeof(IndexMemoryStats));
    }

    virtual bool restricted_range() = 0;

    uint64_t bytes_read() {
      std::lock_guard<std::mutex> lock(m_mutex);
      return m_bytes_read;
    }

    void decrement_index_refcount() {
      std::lock_guard<std::mutex> lock(m_mutex);
      m_index_refcount--;
    }

    virtual uint16_t block_header_format() = 0;

    static const char DATA_BLOCK_MAGIC[10];
    static const char INDEX_FIXED_BLOCK_MAGIC[10];
    static const char INDEX_VARIABLE_BLOCK_MAGIC[10];

  protected:

    std::mutex m_mutex;
    IndexMemoryStats m_index_stats;
    std::vector <String> m_replaced_files;
    uint64_t m_bytes_read;
    size_t m_block_count;
    uint32_t m_index_refcount;
  };

  typedef std::shared_ptr<CellStore> CellStorePtr;


} // namespace Hypertable

#endif // Hypertable_RangeServer_CellStore_h