TableInfo.h

Go to the documentation of this file.

/* -*- c++ -*-
 * 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_TableInfo_h
#define Hypertable_RangeServer_TableInfo_h

#include <Hypertable/RangeServer/Range.h>
#include <Hypertable/RangeServer/RangeSet.h>

#include <Hypertable/Lib/Master/Client.h>
#include <Hypertable/Lib/RangeSpec.h>
#include <Hypertable/Lib/TableIdentifier.h>

#include <AsyncComm/Clock.h>

#include <Common/StringExt.h>

#include <algorithm>
#include <condition_variable>
#include <iterator>
#include <memory>
#include <mutex>
#include <set>
#include <string>

namespace Hypertable {


  class RangeData {
  public:
    RangeData(RangePtr r, Range::MaintenanceData *md=0) : range(r), data(md) {}

    RangePtr range;

    Range::MaintenanceData *data;
  };

  class Ranges {
  public:
    template<typename Func>
    void remove_if(Func pred) {
      std::vector<RangeData> stripped;
      stripped.reserve(array.size());
      remove_copy_if(array.begin(), array.end(), back_inserter(stripped), pred);
      array.swap(stripped);
    }
    std::vector<RangeData> array;
    ByteArena arena;
  };

  typedef std::shared_ptr<Ranges> RangesPtr;

  class RangeInfo {
  public:
    RangeInfo(const String &start_row, const String &end_row)
       : start_row(start_row), end_row(end_row) { }
    String start_row;
    String end_row;
    RangePtr range;
  };

  inline bool operator < (const RangeInfo &lhs, const RangeInfo &rhs) {
    return lhs.end_row.compare(rhs.end_row) < 0;
  }


  class Schema;

  class TableInfo : public RangeSet {
  public:

    TableInfo(const TableIdentifier *identifier,
              SchemaPtr &schema, bool maintenance_disabled);

    virtual ~TableInfo() { }

    virtual bool remove(const String &start_row, const String &end_row);

    virtual void change_end_row(const String &start_row, const String &old_end_row,
                                const String &new_end_row);

    virtual void change_start_row(const String &old_start_row, const String &new_start_row,
                                  const String &end_row);

    SchemaPtr get_schema() {
      std::lock_guard<std::mutex> lock(m_mutex);
      return m_schema;
    }

    bool maintenance_disabled() {
      std::lock_guard<std::mutex> lock(m_mutex);
      return m_maintenance_disabled;
    }

    void set_maintenance_disabled(bool val) {
      std::lock_guard<std::mutex> lock(m_mutex);
      m_maintenance_disabled = val;
    }

    void update_schema(SchemaPtr &schema);

    bool get_range(const RangeSpec &range_spec, RangePtr &range);

    bool has_range(const RangeSpec &range_spec);

    bool remove_range(const RangeSpec &range_spec, RangePtr &range);

    void stage_range(const RangeSpec &range_spec,
                     std::chrono::fast_clock::time_point deadline);

    void unstage_range(const RangeSpec &range_spec);

    void promote_staged_range(RangePtr &range);

    void add_range(RangePtr &range, bool remove_if_exists = false);

    bool find_containing_range(const String &row, RangePtr &range,
                               String &start_row, String &end_row);

    bool includes_row(const String &row) const;

    void get_ranges(Ranges &ranges);

    size_t get_range_count();

    void clear();

    TableIdentifier &identifier() { return m_identifier; }

  private:

    std::mutex m_mutex;

    std::condition_variable m_cond;

    TableIdentifierManaged m_identifier;

    SchemaPtr m_schema;

    std::set<RangeInfo> m_active_set;

    std::set<RangeInfo> m_staged_set;

    bool m_maintenance_disabled {};
  };

  typedef std::shared_ptr<TableInfo> TableInfoPtr;


}

#endif // Hypertable_RangeServer_TableInfo_h