133 lines
3.1 KiB
C++
133 lines
3.1 KiB
C++
#pragma once
|
|
|
|
#include "exception.h"
|
|
#include "parser.h"
|
|
#include "row.h"
|
|
|
|
#include <iostream>
|
|
#include <utility>
|
|
#include <vector>
|
|
#include <variant>
|
|
#include <map>
|
|
|
|
|
|
namespace usql {
|
|
|
|
using IndexValue = std::variant<long, std::string>;
|
|
using rowid_t = size_t; // int is now enough but size_t is correct
|
|
|
|
static const int k_default_rowids_size = 16;
|
|
|
|
|
|
class Index {
|
|
public:
|
|
Index(std::string index_name, std::string col_name, ColumnType type) :
|
|
m_index_name(std::move(index_name)), m_column_name(std::move(col_name)),
|
|
m_data_type(type), m_uniq(false) {
|
|
if (type != ColumnType::integer_type && type != ColumnType::varchar_type)
|
|
throw Exception("creating index on unsupported type");
|
|
}
|
|
|
|
|
|
std::vector<rowid_t> search(ValueNode *key) {
|
|
return search(to_index_value(key));
|
|
}
|
|
|
|
void insert(ColValue *key, rowid_t rowid) {
|
|
return insert(to_index_value(key), rowid);
|
|
}
|
|
|
|
void remove(ColValue *key, rowid_t rowid) {
|
|
return remove(to_index_value(key), rowid);
|
|
}
|
|
|
|
void truncate() {
|
|
m_index.clear();
|
|
}
|
|
|
|
[[nodiscard]] const std::string &get_column_name() const {
|
|
return m_column_name;
|
|
}
|
|
|
|
[[nodiscard]] const std::string &get_index_name() const {
|
|
return m_index_name;
|
|
}
|
|
|
|
[[nodiscard]] ColumnType get_data_type() const {
|
|
return m_data_type;
|
|
}
|
|
|
|
private:
|
|
|
|
IndexValue to_index_value(ValueNode *key) {
|
|
if (m_data_type == ColumnType::integer_type)
|
|
return key->getIntegerValue();
|
|
else if (m_data_type == ColumnType::varchar_type)
|
|
return key->getStringValue();
|
|
else
|
|
throw Exception("using index on unsupported type");
|
|
}
|
|
|
|
IndexValue to_index_value(ColValue *key) {
|
|
if (m_data_type == ColumnType::integer_type)
|
|
return key->getIntValue();
|
|
else if (m_data_type == ColumnType::varchar_type)
|
|
return key->getStringValue();
|
|
else
|
|
throw Exception("using index on unsupported type");
|
|
}
|
|
|
|
void insert(IndexValue key, rowid_t rowid) {
|
|
auto search = m_index.find(key);
|
|
if (search != m_index.end()) {
|
|
if (m_uniq)
|
|
throw Exception("Inserting duplicate value into unique index");
|
|
|
|
search->second.push_back(rowid);
|
|
} else {
|
|
std::vector<rowid_t> rowids{rowid};
|
|
if (!m_uniq)
|
|
rowids.reserve(k_default_rowids_size);
|
|
m_index[key] = rowids;
|
|
}
|
|
}
|
|
|
|
void remove(IndexValue key, rowid_t rowid) {
|
|
auto search = m_index.find(key);
|
|
if (search != m_index.end()) {
|
|
search->second.erase(find(search->second.begin(), search->second.end(), rowid));
|
|
if (search->second.empty())
|
|
m_index.erase(search);
|
|
}
|
|
}
|
|
|
|
std::vector<rowid_t> search(IndexValue key) {
|
|
auto search = m_index.find(key);
|
|
if (search != m_index.end()) {
|
|
return search->second;
|
|
} else {
|
|
return std::vector<rowid_t>{};
|
|
}
|
|
}
|
|
|
|
|
|
|
|
// void dump() {
|
|
// std::for_each(m_index.begin(), m_index.end(),
|
|
// [](std::pair<IndexValue, std::vector<rowid_t>> element){
|
|
// IndexValue key = element.first;
|
|
// std::vector<rowid_t> rowids = element.second;
|
|
// std::cout << "key: " << key << ", rowids count:" << rowids.size() << std::endl;
|
|
// });
|
|
// }
|
|
|
|
private:
|
|
bool m_uniq;
|
|
std::string m_index_name;
|
|
std::string m_column_name;
|
|
ColumnType m_data_type;
|
|
|
|
std::map<IndexValue, std::vector<rowid_t> > m_index;
|
|
};
|
|
|
|
} // namespace
|