summaryrefslogtreecommitdiff
path: root/storage/mroonga/vendor/groonga/lib/grn_egn.hpp
diff options
context:
space:
mode:
Diffstat (limited to 'storage/mroonga/vendor/groonga/lib/grn_egn.hpp')
-rw-r--r--storage/mroonga/vendor/groonga/lib/grn_egn.hpp318
1 files changed, 318 insertions, 0 deletions
diff --git a/storage/mroonga/vendor/groonga/lib/grn_egn.hpp b/storage/mroonga/vendor/groonga/lib/grn_egn.hpp
new file mode 100644
index 00000000000..46511afd6ca
--- /dev/null
+++ b/storage/mroonga/vendor/groonga/lib/grn_egn.hpp
@@ -0,0 +1,318 @@
+/* -*- c-basic-offset: 2 -*- */
+/*
+ Copyright(C) 2015 Brazil
+
+ This library is free software; you can redistribute it and/or
+ modify it under the terms of the GNU Lesser General Public
+ License version 2.1 as published by the Free Software Foundation.
+
+ This library 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
+ Lesser General Public License for more details.
+
+ You should have received a copy of the GNU Lesser General Public
+ License along with this library; if not, write to the Free Software
+ Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+*/
+
+#ifndef GRN_EGN_HPP
+#define GRN_EGN_HPP
+
+#include <cstring>
+#include <vector>
+
+#include "grn_egn.h"
+
+namespace grn {
+namespace egn {
+
+// Constant values.
+
+typedef grn_egn_operator_type OperatorType;
+typedef grn_egn_data_type DataType;
+
+typedef grn_egn_expression_node_type ExpressionNodeType;
+typedef grn_egn_expression_type ExpressionType;
+
+// Built-in data types.
+
+typedef grn_egn_id ID;
+typedef grn_egn_score Score;
+typedef grn_egn_record Record;
+
+//typedef grn_egn_bool Bool;
+//typedef grn_egn_int Int;
+//typedef grn_egn_float Float;
+//typedef grn_egn_time Time;
+//typedef grn_egn_text Text;
+//typedef grn_egn_geo_point GeoPoint;
+
+//inline bool operator==(const Text &lhs, const Text &rhs) {
+// if (lhs.size != rhs.size) {
+// return false;
+// }
+// return std::memcmp(lhs.ptr, rhs.ptr, lhs.size) == 0;
+//}
+//inline bool operator!=(const Text &lhs, const Text &rhs) {
+// if (lhs.size != rhs.size) {
+// return true;
+// }
+// return std::memcmp(lhs.ptr, rhs.ptr, lhs.size) != 0;
+//}
+//inline bool operator<(const Text &lhs, const Text &rhs) {
+// size_t min_size = (lhs.size < rhs.size) ? lhs.size : rhs.size;
+// int result = std::memcmp(lhs.ptr, rhs.ptr, min_size);
+// if (result == 0) {
+// return lhs.size < rhs.size;
+// }
+// return result < 0;
+//}
+//inline bool operator<=(const Text &lhs, const Text &rhs) {
+// size_t min_size = (lhs.size < rhs.size) ? lhs.size : rhs.size;
+// int result = std::memcmp(lhs.ptr, rhs.ptr, min_size);
+// if (result == 0) {
+// return lhs.size <= rhs.size;
+// }
+// return result <= 0;
+//}
+//inline bool operator>(const Text &lhs, const Text &rhs) {
+// return rhs < lhs;
+//}
+//inline bool operator>=(const Text &lhs, const Text &rhs) {
+// return rhs <= lhs;
+//}
+
+//inline bool operator==(const GeoPoint &lhs, const GeoPoint &rhs) {
+// return (lhs.latitude == rhs.latitude) && (lhs.longitude == rhs.longitude);
+//}
+//inline bool operator!=(const GeoPoint &lhs, const GeoPoint &rhs) {
+// return (lhs.latitude != rhs.latitude) || (lhs.longitude != rhs.longitude);
+//}
+
+struct Bool {
+ typedef grn_egn_bool Raw;
+ Raw raw;
+
+ static DataType data_type() {
+ return GRN_DB_BOOL;
+ }
+
+ Bool() : raw() {}
+ Bool(const Bool &value) : raw(value.raw) {}
+ explicit Bool(Raw value) : raw(value) {}
+ ~Bool() {}
+};
+
+inline bool operator!(Bool value) { return !value.raw; }
+inline bool operator==(Bool lhs, Bool rhs) { return lhs.raw == rhs.raw; }
+inline bool operator!=(Bool lhs, Bool rhs) { return lhs.raw != rhs.raw; }
+
+struct Int {
+ typedef grn_egn_int Raw;
+ Raw raw;
+
+ static DataType data_type() {
+ return GRN_DB_INT64;
+ }
+
+ Int() : raw() {}
+ Int(const Int &value) : raw(value.raw) {}
+ explicit Int(Raw value) : raw(value) {}
+ ~Int() {}
+};
+
+inline bool operator==(Int lhs, Int rhs) { return lhs.raw == rhs.raw; }
+inline bool operator!=(Int lhs, Int rhs) { return lhs.raw != rhs.raw; }
+inline bool operator<(Int lhs, Int rhs) { return lhs.raw < rhs.raw; }
+inline bool operator<=(Int lhs, Int rhs) { return lhs.raw <= rhs.raw; }
+inline bool operator>(Int lhs, Int rhs) { return lhs.raw > rhs.raw; }
+inline bool operator>=(Int lhs, Int rhs) { return lhs.raw >= rhs.raw; }
+
+struct Float {
+ typedef grn_egn_float Raw;
+ Raw raw;
+
+ static DataType data_type() {
+ return GRN_DB_FLOAT;
+ }
+
+ Float() : raw() {}
+ Float(const Float &value) : raw(value.raw) {}
+ explicit Float(Raw value) : raw(value) {}
+ ~Float() {}
+};
+
+inline bool operator==(Float lhs, Float rhs) { return lhs.raw == rhs.raw; }
+inline bool operator!=(Float lhs, Float rhs) { return lhs.raw != rhs.raw; }
+inline bool operator<(Float lhs, Float rhs) { return lhs.raw < rhs.raw; }
+inline bool operator<=(Float lhs, Float rhs) { return lhs.raw <= rhs.raw; }
+inline bool operator>(Float lhs, Float rhs) { return lhs.raw > rhs.raw; }
+inline bool operator>=(Float lhs, Float rhs) { return lhs.raw >= rhs.raw; }
+
+struct Time {
+ typedef grn_egn_time Raw;
+ Raw raw;
+
+ static DataType data_type() {
+ return GRN_DB_TIME;
+ }
+
+ Time() : raw() {}
+ Time(const Time &value) : raw(value.raw) {}
+ explicit Time(Raw value) : raw(value) {}
+ ~Time() {}
+};
+
+inline bool operator==(Time lhs, Time rhs) { return lhs.raw == rhs.raw; }
+inline bool operator!=(Time lhs, Time rhs) { return lhs.raw != rhs.raw; }
+inline bool operator<(Time lhs, Time rhs) { return lhs.raw < rhs.raw; }
+inline bool operator<=(Time lhs, Time rhs) { return lhs.raw <= rhs.raw; }
+inline bool operator>(Time lhs, Time rhs) { return lhs.raw > rhs.raw; }
+inline bool operator>=(Time lhs, Time rhs) { return lhs.raw >= rhs.raw; }
+
+struct Text {
+ typedef grn_egn_text Raw;
+ Raw raw;
+
+ static DataType data_type() {
+ return GRN_DB_TEXT;
+ }
+
+ Text() : raw() {}
+ Text(const Text &value) : raw(value.raw) {}
+ explicit Text(const Raw &value) : raw(value) {}
+ Text(const char *ptr, size_t size) : raw((Raw){ptr, size}) {}
+ ~Text() {}
+};
+
+inline bool operator==(const Text &lhs, const Text &rhs) {
+ if (lhs.raw.size != rhs.raw.size) {
+ return false;
+ }
+ return std::memcmp(lhs.raw.ptr, rhs.raw.ptr, lhs.raw.size) == 0;
+}
+inline bool operator!=(const Text &lhs, const Text &rhs) {
+ if (lhs.raw.size != rhs.raw.size) {
+ return true;
+ }
+ return std::memcmp(lhs.raw.ptr, rhs.raw.ptr, lhs.raw.size) != 0;
+}
+inline bool operator<(const Text &lhs, const Text &rhs) {
+ size_t min_size = (lhs.raw.size < rhs.raw.size) ?
+ lhs.raw.size : rhs.raw.size;
+ int result = std::memcmp(lhs.raw.ptr, rhs.raw.ptr, min_size);
+ if (result == 0) {
+ return lhs.raw.size < rhs.raw.size;
+ }
+ return result < 0;
+}
+inline bool operator<=(const Text &lhs, const Text &rhs) {
+ size_t min_size = (lhs.raw.size < rhs.raw.size) ?
+ lhs.raw.size : rhs.raw.size;
+ int result = std::memcmp(lhs.raw.ptr, rhs.raw.ptr, min_size);
+ if (result == 0) {
+ return lhs.raw.size <= rhs.raw.size;
+ }
+ return result <= 0;
+}
+inline bool operator>(const Text &lhs, const Text &rhs) { return rhs < lhs; }
+inline bool operator>=(const Text &lhs, const Text &rhs) { return rhs <= lhs; }
+
+struct GeoPoint {
+ typedef grn_egn_geo_point Raw;
+ Raw raw;
+
+ static DataType data_type() {
+ return GRN_DB_WGS84_GEO_POINT;
+ }
+
+ GeoPoint() : raw() {}
+ GeoPoint(const GeoPoint &value) : raw(value.raw) {}
+ explicit GeoPoint(Raw value) : raw(value) {}
+ GeoPoint(int latitude, int longitude) : raw((Raw){ latitude, longitude }) {}
+ ~GeoPoint() {}
+};
+
+inline bool operator==(GeoPoint lhs, GeoPoint rhs) {
+ return (lhs.raw.latitude == rhs.raw.latitude) &&
+ (lhs.raw.longitude == rhs.raw.longitude);
+}
+inline bool operator!=(GeoPoint lhs, GeoPoint rhs) {
+ return (lhs.raw.latitude != rhs.raw.latitude) ||
+ (lhs.raw.longitude != rhs.raw.longitude);
+}
+
+// Cursor is a base class which provides an interface for sequential access to
+// records.
+class Cursor {
+ public:
+ Cursor() {}
+ virtual ~Cursor() {}
+
+ // FIXME: Give me options.
+ static grn_rc open_table_cursor(grn_ctx *ctx, grn_obj *table,
+ Cursor **cursor);
+
+ virtual grn_rc read(Record *records, size_t size, size_t *count);
+};
+
+// ExpressionNode is an element of Expression.
+class ExpressionNode;
+
+// Expression is a class which represents an expression.
+class Expression {
+ public:
+ Expression(grn_ctx *ctx, grn_obj *table);
+ ~Expression();
+
+ static grn_rc open(grn_ctx *ctx, grn_obj *table, Expression **expression);
+ static grn_rc parse(grn_ctx *ctx, grn_obj *table,
+ const char *query, size_t query_size,
+ Expression **expression);
+
+ ExpressionType type() const {
+ return type_;
+ }
+ DataType data_type() const {
+ return data_type_;
+ }
+
+ grn_rc push_object(grn_obj *obj);
+ grn_rc push_operator(grn_operator operator_type);
+
+ grn_rc filter(Record *input, size_t input_size,
+ Record *output, size_t *output_size);
+ grn_rc adjust(Record *records, size_t num_records);
+
+ template <typename T>
+ grn_rc evaluate(const Record *records, size_t num_records, T *results);
+
+ private:
+ grn_ctx *ctx_;
+ grn_obj *table_;
+ ExpressionType type_;
+ DataType data_type_;
+ std::vector<ExpressionNode *> stack_;
+
+ // Disable copy and assignment.
+ Expression(const Expression &);
+ Expression &operator=(const Expression &);
+
+ ExpressionNode *root() const;
+
+ void update_types();
+
+ grn_rc push_bulk_object(grn_obj *obj);
+ grn_rc push_column_object(grn_obj *obj);
+
+ grn_rc create_unary_node(OperatorType operator_type,
+ ExpressionNode *arg, ExpressionNode **node);
+ grn_rc create_binary_node(OperatorType operator_type,
+ ExpressionNode *arg1, ExpressionNode *arg2, ExpressionNode **node);
+};
+
+} // namespace egn
+} // namespace grn
+
+#endif // GRN_EGN_HPP
View Lorry Controller Status