usql update

usql/index.h

@@ -0,0 +1,119 @@
+#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(const ValueNode *key) {
+		return search(to_index_value(key));
+	}
+
+	void insert(const ColValue *key, rowid_t rowid) {
+		return insert(to_index_value(key), rowid);
+	}
+
+	void remove(const 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;
+	}
+
+
+private:
+	IndexValue to_index_value(const 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(const ColValue *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");
+	}
+
+	void insert(const 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(const 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(const IndexValue& key) {
+		auto search = m_index.find(key);
+		if (search != m_index.end()) {
+			return search->second;
+		} else {
+			return std::vector<rowid_t>{};
+		}
+	}
+
+
+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