You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@arrow.apache.org by ko...@apache.org on 2018/12/12 08:57:18 UTC
[arrow] branch master updated: ARROW-3913: [Gandiva] [GLib] Add
GGandivaLiteralNode
This is an automated email from the ASF dual-hosted git repository.
kou pushed a commit to branch master
in repository https://gitbox.apache.org/repos/asf/arrow.git
The following commit(s) were added to refs/heads/master by this push:
new 527fed6 ARROW-3913: [Gandiva] [GLib] Add GGandivaLiteralNode
527fed6 is described below
commit 527fed672260752e72a6572238d1029063091ef1
Author: Yosuke Shiro <yo...@gmail.com>
AuthorDate: Wed Dec 12 17:50:13 2018 +0900
ARROW-3913: [Gandiva] [GLib] Add GGandivaLiteralNode
Support GGandivaLiteralNode including the following sub classes.
- GGandivaUint8LiteralNode
- GGandivaUint16LiteralNode
- GGandivaUint32LiteralNode
- GGandivaUint64LiteralNode
- GGandivaInt8LiteralNode
- GGandivaInt16LiteralNode
- GGandivaInt32LiteralNode
- GGandivaInt64LiteralNode
- GGandivaFloatLiteralNode
- GGandivaDoubleLiteralNode
- GGandivaStringLiteralNode
- GGandivaBinaryLiteralNode
Author: Yosuke Shiro <yo...@gmail.com>
Author: Kouhei Sutou <ko...@clear-code.com>
Closes #3092 from shiro615/glib-add-ggandiva-literal-node and squashes the following commits:
fb49b256 <Kouhei Sutou> Add a missing ref
91cebe1c <Kouhei Sutou> Break a long line
3ad1e5d8 <Yosuke Shiro> Support BooleanLiteralNode#value
28d301eb <Yosuke Shiro> Fix class orders
7d70c89e <Yosuke Shiro> Remove binary literal property
783a2868 <Yosuke Shiro> Use g_bytes_ref in ggandiva_binary_literal_node_get_value()
4162234d <Yosuke Shiro> Fix class orders
289dfce2 <Yosuke Shiro> Add ggandiva_binary_literal_node_new_bytes()
77f9eb89 <Yosuke Shiro> Remove (transfer full) to use return value.c_str()
e43d525f <Yosuke Shiro> Use static_pointer_cast
62a6dd5c <Yosuke Shiro> Return GBytes in ggandiva_binary_literal_node_get_value()
48d1175d <Yosuke Shiro> Remove unnecessary static_cast
d7ac46b4 <Yosuke Shiro> Remove (nullable) of size of binary literal
8f6643af <Yosuke Shiro> Fix documents
3ded5866 <Yosuke Shiro> Refactor ggandiva_literal_{}_node_new_raw()
a54c6f58 <Yosuke Shiro> Add the original raw value getter
bb2f71be <Yosuke Shiro> Rename Uint to UInt
34422ad1 <Yosuke Shiro> Remove property
7a3fe325 <Yosuke Shiro> Use 'const guint8 *value, gsize size' for binary data
138abbf8 <Yosuke Shiro> Fix a typo
ba501d60 <Yosuke Shiro> Rename is_true to value
a45fa752 <Yosuke Shiro> Use MakeStringLiteral, MakeBinaryLiteral
d8775e4a <Yosuke Shiro> Fix property name in BooleanLiteralNode
62a4eb48 <Yosuke Shiro> Add test case for LiteralNode
83876ccd <Yosuke Shiro> Support GGandivaLiteralNode
---
c_glib/gandiva-glib/node.cpp | 754 +++++++++++++++++++++
c_glib/gandiva-glib/node.h | 236 +++++++
c_glib/gandiva-glib/node.hpp | 3 +
.../test/gandiva/test-binary-literal-node.rb | 22 +-
.../test/gandiva/test-boolean-literal-node.rb | 16 +-
.../test/gandiva/test-double-literal-node.rb | 16 +-
.../test/gandiva/test-float-literal-node.rb | 20 +-
.../test/gandiva/test-int16-literal-node.rb | 16 +-
.../test/gandiva/test-int32-literal-node.rb | 16 +-
.../test/gandiva/test-int64-literal-node.rb | 16 +-
.../test/gandiva/test-int8-literal-node.rb | 16 +-
.../test/gandiva/test-string-literal-node.rb | 16 +-
.../test/gandiva/test-uint16-literal-node.rb | 16 +-
.../test/gandiva/test-uint32-literal-node.rb | 16 +-
.../test/gandiva/test-uint64-literal-node.rb | 16 +-
.../test/gandiva/test-uint8-literal-node.rb | 16 +-
ruby/red-gandiva/lib/gandiva/loader.rb | 14 +
.../test-boolean-literal-node.rb} | 12 +-
18 files changed, 1140 insertions(+), 97 deletions(-)
diff --git a/c_glib/gandiva-glib/node.cpp b/c_glib/gandiva-glib/node.cpp
index 49d1d0b..cdb9724 100644
--- a/c_glib/gandiva-glib/node.cpp
+++ b/c_glib/gandiva-glib/node.cpp
@@ -26,6 +26,15 @@
#include <gandiva-glib/node.hpp>
+template <typename Type>
+Type
+ggandiva_literal_node_get(GGandivaLiteralNode *node)
+{
+ auto gandiva_literal_node =
+ std::static_pointer_cast<gandiva::LiteralNode>(ggandiva_node_get_raw(GGANDIVA_NODE(node)));
+ return boost::get<Type>(gandiva_literal_node->holder());
+}
+
G_BEGIN_DECLS
/**
@@ -40,6 +49,48 @@ G_BEGIN_DECLS
*
* #GGandivaFunctionNode is a class for a node in the expression tree, representing a function.
*
+ * #GGandivaLiteralNode is a base class for a node in the expression tree,
+ * representing a literal.
+ *
+ * #GGandivaBooleanLiteralNode is a class for a node in the expression tree,
+ * representing a boolean literal.
+ *
+ * #GGandivaInt8LiteralNode is a class for a node in the expression tree,
+ * representing a 8-bit integer literal.
+ *
+ * #GGandivaUInt8LiteralNode is a class for a node in the expression tree,
+ * representing a 8-bit unsigned integer literal.
+ *
+ * #GGandivaInt16LiteralNode is a class for a node in the expression tree,
+ * representing a 16-bit integer literal.
+ *
+ * #GGandivaUInt16LiteralNode is a class for a node in the expression tree,
+ * representing a 16-bit unsigned integer literal.
+ *
+ * #GGandivaInt32LiteralNode is a class for a node in the expression tree,
+ * representing a 32-bit integer literal.
+ *
+ * #GGandivaUInt32LiteralNode is a class for a node in the expression tree,
+ * representing a 32-bit unsigned integer literal.
+ *
+ * #GGandivaInt64LiteralNode is a class for a node in the expression tree,
+ * representing a 64-bit integer literal.
+ *
+ * #GGandivaUInt64LiteralNode is a class for a node in the expression tree,
+ * representing a 64-bit unsigned integer literal.
+ *
+ * #GGandivaFloatLiteralNode is a class for a node in the expression tree,
+ * representing a 32-bit floating point literal.
+ *
+ * #GGandivaDoubleLiteralNode is a class for a node in the expression tree,
+ * representing a 64-bit floating point literal.
+ *
+ * #GGandivaBinaryLiteralNode is a class for a node in the expression tree,
+ * representing a binary literal.
+ *
+ * #GGandivaStringLiteralNode is a class for a node in the expression tree,
+ * representing an UTF-8 encoded string literal.
+ *
* Since: 0.12.0
*/
@@ -395,6 +446,654 @@ ggandiva_function_node_get_parameters(GGandivaFunctionNode *node)
return priv->parameters;
}
+
+G_DEFINE_TYPE(GGandivaLiteralNode,
+ ggandiva_literal_node,
+ GGANDIVA_TYPE_NODE)
+
+static void
+ggandiva_literal_node_init(GGandivaLiteralNode *literal_node)
+{
+}
+
+static void
+ggandiva_literal_node_class_init(GGandivaLiteralNodeClass *klass)
+{
+}
+
+
+G_DEFINE_TYPE(GGandivaBooleanLiteralNode,
+ ggandiva_boolean_literal_node,
+ GGANDIVA_TYPE_LITERAL_NODE)
+
+static void
+ggandiva_boolean_literal_node_init(GGandivaBooleanLiteralNode *boolean_literal_node)
+{
+}
+
+static void
+ggandiva_boolean_literal_node_class_init(GGandivaBooleanLiteralNodeClass *klass)
+{
+}
+
+/**
+ * ggandiva_boolean_literal_node_new:
+ * @value: The value of the boolean literal.
+ *
+ * Returns: A newly created #GGandivaBooleanLiteralNode.
+ *
+ * Since: 0.12.0
+ */
+GGandivaBooleanLiteralNode *
+ggandiva_boolean_literal_node_new(gboolean value)
+{
+ auto gandiva_node = gandiva::TreeExprBuilder::MakeLiteral(static_cast<bool>(value));
+ return GGANDIVA_BOOLEAN_LITERAL_NODE(ggandiva_literal_node_new_raw(&gandiva_node));
+}
+
+/**
+ * ggandiva_boolean_literal_node_get_value:
+ * @node: A #GGandivaBooleanLiteralNode.
+ *
+ * Returns: The value of the boolean literal.
+ *
+ * Since: 0.12.0
+ */
+gboolean
+ggandiva_boolean_literal_node_get_value(GGandivaBooleanLiteralNode *node)
+{
+ auto value = ggandiva_literal_node_get<bool>(GGANDIVA_LITERAL_NODE(node));
+ return static_cast<gboolean>(value);
+}
+
+
+G_DEFINE_TYPE(GGandivaInt8LiteralNode,
+ ggandiva_int8_literal_node,
+ GGANDIVA_TYPE_LITERAL_NODE)
+
+static void
+ggandiva_int8_literal_node_init(GGandivaInt8LiteralNode *int8_literal_node)
+{
+}
+
+static void
+ggandiva_int8_literal_node_class_init(GGandivaInt8LiteralNodeClass *klass)
+{
+}
+
+/**
+ * ggandiva_int8_literal_node_new:
+ * @value: The value of the 8-bit integer literal.
+ *
+ * Returns: A newly created #GGandivaInt8LiteralNode.
+ *
+ * Since: 0.12.0
+ */
+GGandivaInt8LiteralNode *
+ggandiva_int8_literal_node_new(gint8 value)
+{
+ auto gandiva_node = gandiva::TreeExprBuilder::MakeLiteral(value);
+ return GGANDIVA_INT8_LITERAL_NODE(ggandiva_literal_node_new_raw(&gandiva_node));
+}
+
+/**
+ * ggandiva_int8_literal_node_get_value:
+ * @node: A #GGandivaInt8LiteralNode.
+ *
+ * Returns: The value of the 8-bit integer literal.
+ *
+ * Since: 0.12.0
+ */
+gint8
+ggandiva_int8_literal_node_get_value(GGandivaInt8LiteralNode *node)
+{
+ return ggandiva_literal_node_get<int8_t>(GGANDIVA_LITERAL_NODE(node));
+}
+
+
+G_DEFINE_TYPE(GGandivaUInt8LiteralNode,
+ ggandiva_uint8_literal_node,
+ GGANDIVA_TYPE_LITERAL_NODE)
+
+static void
+ggandiva_uint8_literal_node_init(GGandivaUInt8LiteralNode *uint8_literal_node)
+{
+}
+
+static void
+ggandiva_uint8_literal_node_class_init(GGandivaUInt8LiteralNodeClass *klass)
+{
+}
+
+/**
+ * ggandiva_uint8_literal_node_new:
+ * @value: The value of the 8-bit unsigned integer literal.
+ *
+ * Returns: A newly created #GGandivaUInt8LiteralNode.
+ *
+ * Since: 0.12.0
+ */
+GGandivaUInt8LiteralNode *
+ggandiva_uint8_literal_node_new(guint8 value)
+{
+ auto gandiva_node = gandiva::TreeExprBuilder::MakeLiteral(value);
+ return GGANDIVA_UINT8_LITERAL_NODE(ggandiva_literal_node_new_raw(&gandiva_node));
+}
+
+/**
+ * ggandiva_uint8_literal_node_get_value:
+ * @node: A #GGandivaUInt8LiteralNode.
+ *
+ * Returns: The value of the 8-bit unsigned integer literal.
+ *
+ * Since: 0.12.0
+ */
+guint8
+ggandiva_uint8_literal_node_get_value(GGandivaUInt8LiteralNode *node)
+{
+ return ggandiva_literal_node_get<uint8_t>(GGANDIVA_LITERAL_NODE(node));
+}
+
+
+G_DEFINE_TYPE(GGandivaInt16LiteralNode,
+ ggandiva_int16_literal_node,
+ GGANDIVA_TYPE_LITERAL_NODE)
+
+static void
+ggandiva_int16_literal_node_init(GGandivaInt16LiteralNode *int16_literal_node)
+{
+}
+
+static void
+ggandiva_int16_literal_node_class_init(GGandivaInt16LiteralNodeClass *klass)
+{
+}
+
+/**
+ * ggandiva_int16_literal_node_new:
+ * @value: The value of the 16-bit integer literal.
+ *
+ * Returns: A newly created #GGandivaInt16LiteralNode.
+ *
+ * Since: 0.12.0
+ */
+GGandivaInt16LiteralNode *
+ggandiva_int16_literal_node_new(gint16 value)
+{
+ auto gandiva_node = gandiva::TreeExprBuilder::MakeLiteral(value);
+ return GGANDIVA_INT16_LITERAL_NODE(ggandiva_literal_node_new_raw(&gandiva_node));
+}
+
+/**
+ * ggandiva_int16_literal_node_get_value:
+ * @node: A #GGandivaInt16LiteralNode.
+ *
+ * Returns: The value of the 16-bit integer literal.
+ *
+ * Since: 0.12.0
+ */
+gint16
+ggandiva_int16_literal_node_get_value(GGandivaInt16LiteralNode *node)
+{
+ return ggandiva_literal_node_get<int16_t>(GGANDIVA_LITERAL_NODE(node));
+}
+
+
+G_DEFINE_TYPE(GGandivaUInt16LiteralNode,
+ ggandiva_uint16_literal_node,
+ GGANDIVA_TYPE_LITERAL_NODE)
+
+static void
+ggandiva_uint16_literal_node_init(GGandivaUInt16LiteralNode *uint16_literal_node)
+{
+}
+
+static void
+ggandiva_uint16_literal_node_class_init(GGandivaUInt16LiteralNodeClass *klass)
+{
+}
+
+/**
+ * ggandiva_uint16_literal_node_new:
+ * @value: The value of the 16-bit unsigned integer literal.
+ *
+ * Returns: A newly created #GGandivaUInt16LiteralNode.
+ *
+ * Since: 0.12.0
+ */
+GGandivaUInt16LiteralNode *
+ggandiva_uint16_literal_node_new(guint16 value)
+{
+ auto gandiva_node = gandiva::TreeExprBuilder::MakeLiteral(value);
+ return GGANDIVA_UINT16_LITERAL_NODE(ggandiva_literal_node_new_raw(&gandiva_node));
+}
+
+/**
+ * ggandiva_uint16_literal_node_get_value:
+ * @node: A #GGandivaUInt16LiteralNode.
+ *
+ * Returns: The value of the 16-bit unsigned integer literal.
+ *
+ * Since: 0.12.0
+ */
+guint16
+ggandiva_uint16_literal_node_get_value(GGandivaUInt16LiteralNode *node)
+{
+ return ggandiva_literal_node_get<uint16_t>(GGANDIVA_LITERAL_NODE(node));
+}
+
+
+G_DEFINE_TYPE(GGandivaInt32LiteralNode,
+ ggandiva_int32_literal_node,
+ GGANDIVA_TYPE_LITERAL_NODE)
+
+static void
+ggandiva_int32_literal_node_init(GGandivaInt32LiteralNode *int32_literal_node)
+{
+}
+
+static void
+ggandiva_int32_literal_node_class_init(GGandivaInt32LiteralNodeClass *klass)
+{
+}
+
+/**
+ * ggandiva_int32_literal_node_new:
+ * @value: The value of the 32-bit integer literal.
+ *
+ * Returns: A newly created #GGandivaInt32LiteralNode.
+ *
+ * Since: 0.12.0
+ */
+GGandivaInt32LiteralNode *
+ggandiva_int32_literal_node_new(gint32 value)
+{
+ auto gandiva_node = gandiva::TreeExprBuilder::MakeLiteral(value);
+ return GGANDIVA_INT32_LITERAL_NODE(ggandiva_literal_node_new_raw(&gandiva_node));
+}
+
+/**
+ * ggandiva_int32_literal_node_get_value:
+ * @node: A #GGandivaInt32LiteralNode.
+ *
+ * Returns: The value of the 32-bit integer literal.
+ *
+ * Since: 0.12.0
+ */
+gint32
+ggandiva_int32_literal_node_get_value(GGandivaInt32LiteralNode *node)
+{
+ return ggandiva_literal_node_get<int32_t>(GGANDIVA_LITERAL_NODE(node));
+}
+
+
+G_DEFINE_TYPE(GGandivaUInt32LiteralNode,
+ ggandiva_uint32_literal_node,
+ GGANDIVA_TYPE_LITERAL_NODE)
+
+static void
+ggandiva_uint32_literal_node_init(GGandivaUInt32LiteralNode *uint32_literal_node)
+{
+}
+
+static void
+ggandiva_uint32_literal_node_class_init(GGandivaUInt32LiteralNodeClass *klass)
+{
+}
+
+/**
+ * ggandiva_uint32_literal_node_new:
+ * @value: The value of the 32-bit unsigned integer literal.
+ *
+ * Returns: A newly created #GGandivaUInt32LiteralNode.
+ *
+ * Since: 0.12.0
+ */
+GGandivaUInt32LiteralNode *
+ggandiva_uint32_literal_node_new(guint32 value)
+{
+ auto gandiva_node = gandiva::TreeExprBuilder::MakeLiteral(value);
+ return GGANDIVA_UINT32_LITERAL_NODE(ggandiva_literal_node_new_raw(&gandiva_node));
+}
+
+/**
+ * ggandiva_uint32_literal_node_get_value:
+ * @node: A #GGandivaUInt32LiteralNode.
+ *
+ * Returns: The value of the 32-bit unsigned integer literal.
+ *
+ * Since: 0.12.0
+ */
+guint32
+ggandiva_uint32_literal_node_get_value(GGandivaUInt32LiteralNode *node)
+{
+ return ggandiva_literal_node_get<uint32_t>(GGANDIVA_LITERAL_NODE(node));
+}
+
+
+G_DEFINE_TYPE(GGandivaInt64LiteralNode,
+ ggandiva_int64_literal_node,
+ GGANDIVA_TYPE_LITERAL_NODE)
+
+static void
+ggandiva_int64_literal_node_init(GGandivaInt64LiteralNode *int64_literal_node)
+{
+}
+
+static void
+ggandiva_int64_literal_node_class_init(GGandivaInt64LiteralNodeClass *klass)
+{
+}
+
+/**
+ * ggandiva_int64_literal_node_new:
+ * @value: The value of the 64-bit integer literal.
+ *
+ * Returns: A newly created #GGandivaInt64LiteralNode.
+ *
+ * Since: 0.12.0
+ */
+GGandivaInt64LiteralNode *
+ggandiva_int64_literal_node_new(gint64 value)
+{
+ auto gandiva_node = gandiva::TreeExprBuilder::MakeLiteral(value);
+ return GGANDIVA_INT64_LITERAL_NODE(ggandiva_literal_node_new_raw(&gandiva_node));
+}
+
+/**
+ * ggandiva_int64_literal_node_get_value:
+ * @node: A #GGandivaInt64LiteralNode.
+ *
+ * Returns: The value of the 64-bit integer literal.
+ *
+ * Since: 0.12.0
+ */
+gint64
+ggandiva_int64_literal_node_get_value(GGandivaInt64LiteralNode *node)
+{
+ return ggandiva_literal_node_get<int64_t>(GGANDIVA_LITERAL_NODE(node));
+}
+
+
+G_DEFINE_TYPE(GGandivaUInt64LiteralNode,
+ ggandiva_uint64_literal_node,
+ GGANDIVA_TYPE_LITERAL_NODE)
+
+static void
+ggandiva_uint64_literal_node_init(GGandivaUInt64LiteralNode *uint64_literal_node)
+{
+}
+
+static void
+ggandiva_uint64_literal_node_class_init(GGandivaUInt64LiteralNodeClass *klass)
+{
+}
+
+/**
+ * ggandiva_uint64_literal_node_new:
+ * @value: The value of the 64-bit unsigned integer literal.
+ *
+ * Returns: A newly created #GGandivaUInt64LiteralNode.
+ *
+ * Since: 0.12.0
+ */
+GGandivaUInt64LiteralNode *
+ggandiva_uint64_literal_node_new(guint64 value)
+{
+ auto gandiva_node = gandiva::TreeExprBuilder::MakeLiteral(value);
+ return GGANDIVA_UINT64_LITERAL_NODE(ggandiva_literal_node_new_raw(&gandiva_node));
+}
+
+/**
+ * ggandiva_uint64_literal_node_get_value:
+ * @node: A #GGandivaUInt64LiteralNode.
+ *
+ * Returns: The value of the 64-bit unsigned integer literal.
+ *
+ * Since: 0.12.0
+ */
+guint64
+ggandiva_uint64_literal_node_get_value(GGandivaUInt64LiteralNode *node)
+{
+ return ggandiva_literal_node_get<uint64_t>(GGANDIVA_LITERAL_NODE(node));
+}
+
+
+G_DEFINE_TYPE(GGandivaFloatLiteralNode,
+ ggandiva_float_literal_node,
+ GGANDIVA_TYPE_LITERAL_NODE)
+
+static void
+ggandiva_float_literal_node_init(GGandivaFloatLiteralNode *float_literal_node)
+{
+}
+
+static void
+ggandiva_float_literal_node_class_init(GGandivaFloatLiteralNodeClass *klass)
+{
+}
+
+/**
+ * ggandiva_float_literal_node_new:
+ * @value: The value of the 32-bit floating point literal.
+ *
+ * Returns: A newly created #GGandivaFloatLiteralNode.
+ *
+ * Since: 0.12.0
+ */
+GGandivaFloatLiteralNode *
+ggandiva_float_literal_node_new(gfloat value)
+{
+ auto gandiva_node = gandiva::TreeExprBuilder::MakeLiteral(value);
+ return GGANDIVA_FLOAT_LITERAL_NODE(ggandiva_literal_node_new_raw(&gandiva_node));
+}
+
+/**
+ * ggandiva_float_literal_node_get_value:
+ * @node: A #GGandivaFloatLiteralNode.
+ *
+ * Returns: The value of the 32-bit floating point literal.
+ *
+ * Since: 0.12.0
+ */
+gfloat
+ggandiva_float_literal_node_get_value(GGandivaFloatLiteralNode *node)
+{
+ return ggandiva_literal_node_get<float>(GGANDIVA_LITERAL_NODE(node));
+}
+
+
+G_DEFINE_TYPE(GGandivaDoubleLiteralNode,
+ ggandiva_double_literal_node,
+ GGANDIVA_TYPE_LITERAL_NODE)
+
+static void
+ggandiva_double_literal_node_init(GGandivaDoubleLiteralNode *double_literal_node)
+{
+}
+
+static void
+ggandiva_double_literal_node_class_init(GGandivaDoubleLiteralNodeClass *klass)
+{
+}
+
+/**
+ * ggandiva_double_literal_node_new:
+ * @value: The value of the 64-bit floating point literal.
+ *
+ * Returns: A newly created #GGandivaDoubleLiteralNode.
+ *
+ * Since: 0.12.0
+ */
+GGandivaDoubleLiteralNode *
+ggandiva_double_literal_node_new(gdouble value)
+{
+ auto gandiva_node = gandiva::TreeExprBuilder::MakeLiteral(value);
+ return GGANDIVA_DOUBLE_LITERAL_NODE(ggandiva_literal_node_new_raw(&gandiva_node));
+}
+
+/**
+ * ggandiva_double_literal_node_get_value:
+ * @node: A #GGandivaDoubleLiteralNode.
+ *
+ * Returns: The value of the 64-bit floating point literal.
+ *
+ * Since: 0.12.0
+ */
+gdouble
+ggandiva_double_literal_node_get_value(GGandivaDoubleLiteralNode *node)
+{
+ return ggandiva_literal_node_get<double>(GGANDIVA_LITERAL_NODE(node));
+}
+
+
+typedef struct GGandivaBinaryLiteralNodePrivate_ {
+ GBytes *value;
+} GGandivaBinaryLiteralNodePrivate;
+
+G_DEFINE_TYPE_WITH_PRIVATE(GGandivaBinaryLiteralNode,
+ ggandiva_binary_literal_node,
+ GGANDIVA_TYPE_LITERAL_NODE)
+
+#define GGANDIVA_BINARY_LITERAL_NODE_GET_PRIVATE(object) \
+ static_cast<GGandivaBinaryLiteralNodePrivate *>( \
+ ggandiva_binary_literal_node_get_instance_private( \
+ GGANDIVA_BINARY_LITERAL_NODE(object)))
+
+static void
+ggandiva_binary_literal_node_dispose(GObject *object)
+{
+ auto priv = GGANDIVA_BINARY_LITERAL_NODE_GET_PRIVATE(object);
+
+ if (priv->value) {
+ g_bytes_unref(priv->value);
+ priv->value = nullptr;
+ }
+
+ G_OBJECT_CLASS(ggandiva_binary_literal_node_parent_class)->dispose(object);
+}
+
+static void
+ggandiva_binary_literal_node_init(GGandivaBinaryLiteralNode *binary_literal_node)
+{
+}
+
+static void
+ggandiva_binary_literal_node_class_init(GGandivaBinaryLiteralNodeClass *klass)
+{
+ auto gobject_class = G_OBJECT_CLASS(klass);
+
+ gobject_class->dispose = ggandiva_binary_literal_node_dispose;
+}
+
+/**
+ * ggandiva_binary_literal_node_new:
+ * @value: (array length=size): The value of the binary literal.
+ * @size: The number of bytes of the value.
+ *
+ * Returns: A newly created #GGandivaBinaryLiteralNode.
+ *
+ * Since: 0.12.0
+ */
+GGandivaBinaryLiteralNode *
+ggandiva_binary_literal_node_new(const guint8 *value,
+ gsize size)
+{
+ auto gandiva_node =
+ gandiva::TreeExprBuilder::MakeBinaryLiteral(std::string(reinterpret_cast<const char *>(value),
+ size));
+ return GGANDIVA_BINARY_LITERAL_NODE(ggandiva_literal_node_new_raw(&gandiva_node));
+}
+
+/**
+ * ggandiva_binary_literal_node_new_bytes:
+ * @value: The value of the binary literal.
+ *
+ * Returns: A newly created #GGandivaBinaryLiteralNode.
+ *
+ * Since: 0.12.0
+ */
+GGandivaBinaryLiteralNode *
+ggandiva_binary_literal_node_new_bytes(GBytes *value)
+{
+ size_t value_size;
+ auto raw_value = g_bytes_get_data(value, &value_size);
+ auto gandiva_node =
+ gandiva::TreeExprBuilder::MakeBinaryLiteral(
+ std::string(reinterpret_cast<const char *>(raw_value),
+ value_size));
+ auto literal_node = ggandiva_literal_node_new_raw(&gandiva_node);
+ auto priv = GGANDIVA_BINARY_LITERAL_NODE_GET_PRIVATE(literal_node);
+ priv->value = value;
+ g_bytes_ref(priv->value);
+ return GGANDIVA_BINARY_LITERAL_NODE(literal_node);
+}
+
+/**
+ * ggandiva_binary_literal_node_get_value:
+ * @node: A #GGandivaBinaryLiteralNode.
+ *
+ * Returns: (transfer none): The value of the binary literal.
+ *
+ * Since: 0.12.0
+ */
+GBytes *
+ggandiva_binary_literal_node_get_value(GGandivaBinaryLiteralNode *node)
+{
+ auto priv = GGANDIVA_BINARY_LITERAL_NODE_GET_PRIVATE(node);
+ if (!priv->value) {
+ auto value = ggandiva_literal_node_get<std::string>(GGANDIVA_LITERAL_NODE(node));
+ priv->value = g_bytes_new(value.data(), value.size());
+ }
+
+ return priv->value;
+}
+
+
+G_DEFINE_TYPE(GGandivaStringLiteralNode,
+ ggandiva_string_literal_node,
+ GGANDIVA_TYPE_LITERAL_NODE)
+
+static void
+ggandiva_string_literal_node_init(GGandivaStringLiteralNode *string_literal_node)
+{
+}
+
+static void
+ggandiva_string_literal_node_class_init(GGandivaStringLiteralNodeClass *klass)
+{
+}
+
+/**
+ * ggandiva_string_literal_node_new:
+ * @value: The value of the UTF-8 encoded string literal.
+ *
+ * Returns: A newly created #GGandivaStringLiteralNode.
+ *
+ * Since: 0.12.0
+ */
+GGandivaStringLiteralNode *
+ggandiva_string_literal_node_new(const gchar *value)
+{
+ auto gandiva_node = gandiva::TreeExprBuilder::MakeStringLiteral(value);
+ return GGANDIVA_STRING_LITERAL_NODE(ggandiva_literal_node_new_raw(&gandiva_node));
+}
+
+/**
+ * ggandiva_string_literal_node_get_value:
+ * @node: A #GGandivaStringLiteralNode.
+ *
+ * Returns: The value of the UTF-8 encoded string literal.
+ *
+ * Since: 0.12.0
+ */
+const gchar *
+ggandiva_string_literal_node_get_value(GGandivaStringLiteralNode *node)
+{
+ auto value = ggandiva_literal_node_get<std::string>(GGANDIVA_LITERAL_NODE(node));
+ return value.c_str();
+}
+
G_END_DECLS
std::shared_ptr<gandiva::Node>
@@ -434,3 +1133,58 @@ ggandiva_function_node_new_raw(std::shared_ptr<gandiva::Node> *gandiva_node,
priv->parameters = g_list_reverse(priv->parameters);
return GGANDIVA_FUNCTION_NODE(function_node);
}
+
+GGandivaLiteralNode *
+ggandiva_literal_node_new_raw(std::shared_ptr<gandiva::Node> *gandiva_node)
+{
+ GType type;
+
+ switch ((*gandiva_node)->return_type()->id()) {
+ case arrow::Type::BOOL:
+ type = GGANDIVA_TYPE_BOOLEAN_LITERAL_NODE;
+ break;
+ case arrow::Type::type::UINT8:
+ type = GGANDIVA_TYPE_UINT8_LITERAL_NODE;
+ break;
+ case arrow::Type::type::UINT16:
+ type = GGANDIVA_TYPE_UINT16_LITERAL_NODE;
+ break;
+ case arrow::Type::type::UINT32:
+ type = GGANDIVA_TYPE_UINT32_LITERAL_NODE;
+ break;
+ case arrow::Type::type::UINT64:
+ type = GGANDIVA_TYPE_UINT64_LITERAL_NODE;
+ break;
+ case arrow::Type::type::INT8:
+ type = GGANDIVA_TYPE_INT8_LITERAL_NODE;
+ break;
+ case arrow::Type::type::INT16:
+ type = GGANDIVA_TYPE_INT16_LITERAL_NODE;
+ break;
+ case arrow::Type::type::INT32:
+ type = GGANDIVA_TYPE_INT32_LITERAL_NODE;
+ break;
+ case arrow::Type::type::INT64:
+ type = GGANDIVA_TYPE_INT64_LITERAL_NODE;
+ break;
+ case arrow::Type::type::FLOAT:
+ type = GGANDIVA_TYPE_FLOAT_LITERAL_NODE;
+ break;
+ case arrow::Type::type::DOUBLE:
+ type = GGANDIVA_TYPE_DOUBLE_LITERAL_NODE;
+ break;
+ case arrow::Type::type::STRING:
+ type = GGANDIVA_TYPE_STRING_LITERAL_NODE;
+ break;
+ case arrow::Type::type::BINARY:
+ type = GGANDIVA_TYPE_BINARY_LITERAL_NODE;
+ break;
+ default:
+ type = GGANDIVA_TYPE_LITERAL_NODE;
+ break;
+ }
+ auto literal_node = GGANDIVA_LITERAL_NODE(g_object_new(type,
+ "node", gandiva_node,
+ NULL));
+ return literal_node;
+}
diff --git a/c_glib/gandiva-glib/node.h b/c_glib/gandiva-glib/node.h
index 98ab3af..183003f 100644
--- a/c_glib/gandiva-glib/node.h
+++ b/c_glib/gandiva-glib/node.h
@@ -67,4 +67,240 @@ ggandiva_function_node_new(const gchar *name,
GList *
ggandiva_function_node_get_parameters(GGandivaFunctionNode *node);
+
+#define GGANDIVA_TYPE_LITERAL_NODE (ggandiva_literal_node_get_type())
+G_DECLARE_DERIVABLE_TYPE(GGandivaLiteralNode,
+ ggandiva_literal_node,
+ GGANDIVA,
+ LITERAL_NODE,
+ GGandivaNode)
+struct _GGandivaLiteralNodeClass
+{
+ GGandivaNodeClass parent_class;
+};
+
+
+#define GGANDIVA_TYPE_BOOLEAN_LITERAL_NODE (ggandiva_boolean_literal_node_get_type())
+G_DECLARE_DERIVABLE_TYPE(GGandivaBooleanLiteralNode,
+ ggandiva_boolean_literal_node,
+ GGANDIVA,
+ BOOLEAN_LITERAL_NODE,
+ GGandivaLiteralNode)
+struct _GGandivaBooleanLiteralNodeClass
+{
+ GGandivaLiteralNodeClass parent_class;
+};
+
+GGandivaBooleanLiteralNode *
+ggandiva_boolean_literal_node_new(gboolean value);
+gboolean
+ggandiva_boolean_literal_node_get_value(GGandivaBooleanLiteralNode *node);
+
+
+#define GGANDIVA_TYPE_INT8_LITERAL_NODE (ggandiva_int8_literal_node_get_type())
+G_DECLARE_DERIVABLE_TYPE(GGandivaInt8LiteralNode,
+ ggandiva_int8_literal_node,
+ GGANDIVA,
+ INT8_LITERAL_NODE,
+ GGandivaLiteralNode)
+struct _GGandivaInt8LiteralNodeClass
+{
+ GGandivaLiteralNodeClass parent_class;
+};
+
+GGandivaInt8LiteralNode *
+ggandiva_int8_literal_node_new(gint8 value);
+gint8
+ggandiva_int8_literal_node_get_value(GGandivaInt8LiteralNode *node);
+
+
+#define GGANDIVA_TYPE_UINT8_LITERAL_NODE (ggandiva_uint8_literal_node_get_type())
+G_DECLARE_DERIVABLE_TYPE(GGandivaUInt8LiteralNode,
+ ggandiva_uint8_literal_node,
+ GGANDIVA,
+ UINT8_LITERAL_NODE,
+ GGandivaLiteralNode)
+struct _GGandivaUInt8LiteralNodeClass
+{
+ GGandivaLiteralNodeClass parent_class;
+};
+
+GGandivaUInt8LiteralNode *
+ggandiva_uint8_literal_node_new(guint8 value);
+guint8
+ggandiva_uint8_literal_node_get_value(GGandivaUInt8LiteralNode *node);
+
+
+#define GGANDIVA_TYPE_INT16_LITERAL_NODE (ggandiva_int16_literal_node_get_type())
+G_DECLARE_DERIVABLE_TYPE(GGandivaInt16LiteralNode,
+ ggandiva_int16_literal_node,
+ GGANDIVA,
+ INT16_LITERAL_NODE,
+ GGandivaLiteralNode)
+struct _GGandivaInt16LiteralNodeClass
+{
+ GGandivaLiteralNodeClass parent_class;
+};
+
+GGandivaInt16LiteralNode *
+ggandiva_int16_literal_node_new(gint16 value);
+gint16
+ggandiva_int16_literal_node_get_value(GGandivaInt16LiteralNode *node);
+
+
+#define GGANDIVA_TYPE_UINT16_LITERAL_NODE (ggandiva_uint16_literal_node_get_type())
+G_DECLARE_DERIVABLE_TYPE(GGandivaUInt16LiteralNode,
+ ggandiva_uint16_literal_node,
+ GGANDIVA,
+ UINT16_LITERAL_NODE,
+ GGandivaLiteralNode)
+struct _GGandivaUInt16LiteralNodeClass
+{
+ GGandivaLiteralNodeClass parent_class;
+};
+
+GGandivaUInt16LiteralNode *
+ggandiva_uint16_literal_node_new(guint16 value);
+guint16
+ggandiva_uint16_literal_node_get_value(GGandivaUInt16LiteralNode *node);
+
+
+#define GGANDIVA_TYPE_INT32_LITERAL_NODE (ggandiva_int32_literal_node_get_type())
+G_DECLARE_DERIVABLE_TYPE(GGandivaInt32LiteralNode,
+ ggandiva_int32_literal_node,
+ GGANDIVA,
+ INT32_LITERAL_NODE,
+ GGandivaLiteralNode)
+struct _GGandivaInt32LiteralNodeClass
+{
+ GGandivaLiteralNodeClass parent_class;
+};
+
+GGandivaInt32LiteralNode *
+ggandiva_int32_literal_node_new(gint32 value);
+gint32
+ggandiva_int32_literal_node_get_value(GGandivaInt32LiteralNode *node);
+
+
+#define GGANDIVA_TYPE_UINT32_LITERAL_NODE (ggandiva_uint32_literal_node_get_type())
+G_DECLARE_DERIVABLE_TYPE(GGandivaUInt32LiteralNode,
+ ggandiva_uint32_literal_node,
+ GGANDIVA,
+ UINT32_LITERAL_NODE,
+ GGandivaLiteralNode)
+struct _GGandivaUInt32LiteralNodeClass
+{
+ GGandivaLiteralNodeClass parent_class;
+};
+
+GGandivaUInt32LiteralNode *
+ggandiva_uint32_literal_node_new(guint32 value);
+guint32
+ggandiva_uint32_literal_node_get_value(GGandivaUInt32LiteralNode *node);
+
+
+#define GGANDIVA_TYPE_INT64_LITERAL_NODE (ggandiva_int64_literal_node_get_type())
+G_DECLARE_DERIVABLE_TYPE(GGandivaInt64LiteralNode,
+ ggandiva_int64_literal_node,
+ GGANDIVA,
+ INT64_LITERAL_NODE,
+ GGandivaLiteralNode)
+struct _GGandivaInt64LiteralNodeClass
+{
+ GGandivaLiteralNodeClass parent_class;
+};
+
+GGandivaInt64LiteralNode *
+ggandiva_int64_literal_node_new(gint64 value);
+gint64
+ggandiva_int64_literal_node_get_value(GGandivaInt64LiteralNode *node);
+
+
+#define GGANDIVA_TYPE_UINT64_LITERAL_NODE (ggandiva_uint64_literal_node_get_type())
+G_DECLARE_DERIVABLE_TYPE(GGandivaUInt64LiteralNode,
+ ggandiva_uint64_literal_node,
+ GGANDIVA,
+ UINT64_LITERAL_NODE,
+ GGandivaLiteralNode)
+struct _GGandivaUInt64LiteralNodeClass
+{
+ GGandivaLiteralNodeClass parent_class;
+};
+
+GGandivaUInt64LiteralNode *
+ggandiva_uint64_literal_node_new(guint64 value);
+guint64
+ggandiva_uint64_literal_node_get_value(GGandivaUInt64LiteralNode *node);
+
+
+#define GGANDIVA_TYPE_FLOAT_LITERAL_NODE (ggandiva_float_literal_node_get_type())
+G_DECLARE_DERIVABLE_TYPE(GGandivaFloatLiteralNode,
+ ggandiva_float_literal_node,
+ GGANDIVA,
+ FLOAT_LITERAL_NODE,
+ GGandivaLiteralNode)
+struct _GGandivaFloatLiteralNodeClass
+{
+ GGandivaLiteralNodeClass parent_class;
+};
+
+GGandivaFloatLiteralNode *
+ggandiva_float_literal_node_new(gfloat value);
+gfloat
+ggandiva_float_literal_node_get_value(GGandivaFloatLiteralNode *node);
+
+
+#define GGANDIVA_TYPE_DOUBLE_LITERAL_NODE (ggandiva_double_literal_node_get_type())
+G_DECLARE_DERIVABLE_TYPE(GGandivaDoubleLiteralNode,
+ ggandiva_double_literal_node,
+ GGANDIVA,
+ DOUBLE_LITERAL_NODE,
+ GGandivaLiteralNode)
+struct _GGandivaDoubleLiteralNodeClass
+{
+ GGandivaLiteralNodeClass parent_class;
+};
+
+GGandivaDoubleLiteralNode *
+ggandiva_double_literal_node_new(gdouble value);
+gdouble
+ggandiva_double_literal_node_get_value(GGandivaDoubleLiteralNode *node);
+
+
+#define GGANDIVA_TYPE_BINARY_LITERAL_NODE (ggandiva_binary_literal_node_get_type())
+G_DECLARE_DERIVABLE_TYPE(GGandivaBinaryLiteralNode,
+ ggandiva_binary_literal_node,
+ GGANDIVA,
+ BINARY_LITERAL_NODE,
+ GGandivaLiteralNode)
+struct _GGandivaBinaryLiteralNodeClass
+{
+ GGandivaLiteralNodeClass parent_class;
+};
+
+GGandivaBinaryLiteralNode *
+ggandiva_binary_literal_node_new(const guint8 *value,
+ gsize size);
+GGandivaBinaryLiteralNode *
+ggandiva_binary_literal_node_new_bytes(GBytes *value);
+GBytes *
+ggandiva_binary_literal_node_get_value(GGandivaBinaryLiteralNode *node);
+
+
+#define GGANDIVA_TYPE_STRING_LITERAL_NODE (ggandiva_string_literal_node_get_type())
+G_DECLARE_DERIVABLE_TYPE(GGandivaStringLiteralNode,
+ ggandiva_string_literal_node,
+ GGANDIVA,
+ STRING_LITERAL_NODE,
+ GGandivaLiteralNode)
+struct _GGandivaStringLiteralNodeClass
+{
+ GGandivaLiteralNodeClass parent_class;
+};
+
+GGandivaStringLiteralNode *
+ggandiva_string_literal_node_new(const gchar *value);
+const gchar *
+ggandiva_string_literal_node_get_value(GGandivaStringLiteralNode *node);
+
G_END_DECLS
diff --git a/c_glib/gandiva-glib/node.hpp b/c_glib/gandiva-glib/node.hpp
index 953c214..7ff1360 100644
--- a/c_glib/gandiva-glib/node.hpp
+++ b/c_glib/gandiva-glib/node.hpp
@@ -21,6 +21,7 @@
#include <memory>
+#include <gandiva/node.h>
#include <gandiva/tree_expr_builder.h>
#include <gandiva-glib/node.h>
@@ -34,3 +35,5 @@ ggandiva_function_node_new_raw(std::shared_ptr<gandiva::Node> *gandiva_node,
const gchar *name,
GList *parameters,
GArrowDataType *return_type);
+GGandivaLiteralNode *
+ggandiva_literal_node_new_raw(std::shared_ptr<gandiva::Node> *gandiva_node);
diff --git a/ruby/red-gandiva/lib/gandiva/loader.rb b/c_glib/test/gandiva/test-binary-literal-node.rb
similarity index 62%
copy from ruby/red-gandiva/lib/gandiva/loader.rb
copy to c_glib/test/gandiva/test-binary-literal-node.rb
index 5a95897..93a54a3 100644
--- a/ruby/red-gandiva/lib/gandiva/loader.rb
+++ b/c_glib/test/gandiva/test-binary-literal-node.rb
@@ -15,12 +15,20 @@
# specific language governing permissions and limitations
# under the License.
-module Gandiva
- class Loader < GObjectIntrospection::Loader
- class << self
- def load
- super("Gandiva", Gandiva)
- end
- end
+class TestGandivaBinaryLiteralNode < Test::Unit::TestCase
+ def setup
+ omit("Gandiva is required") unless defined?(::Gandiva)
+ @value = "\x00\x01\x02\x03\x04"
+ end
+
+ def test_new
+ literal_node = Gandiva::BinaryLiteralNode.new(@value)
+ assert_equal(@value, literal_node.value.to_s)
+ end
+
+ def test_new_bytes
+ bytes_value = GLib::Bytes.new(@value)
+ literal_node = Gandiva::BinaryLiteralNode.new(bytes_value)
+ assert_equal(@value, literal_node.value.to_s)
end
end
diff --git a/ruby/red-gandiva/lib/gandiva/loader.rb b/c_glib/test/gandiva/test-boolean-literal-node.rb
similarity index 74%
copy from ruby/red-gandiva/lib/gandiva/loader.rb
copy to c_glib/test/gandiva/test-boolean-literal-node.rb
index 5a95897..3d1f10c 100644
--- a/ruby/red-gandiva/lib/gandiva/loader.rb
+++ b/c_glib/test/gandiva/test-boolean-literal-node.rb
@@ -15,12 +15,14 @@
# specific language governing permissions and limitations
# under the License.
-module Gandiva
- class Loader < GObjectIntrospection::Loader
- class << self
- def load
- super("Gandiva", Gandiva)
- end
- end
+class TestGandivaBooleanLiteralNode < Test::Unit::TestCase
+ def setup
+ omit("Gandiva is required") unless defined?(::Gandiva)
+ end
+
+ def test_value
+ value = true
+ literal_node = Gandiva::BooleanLiteralNode.new(value)
+ assert_equal(value, literal_node.value?)
end
end
diff --git a/ruby/red-gandiva/lib/gandiva/loader.rb b/c_glib/test/gandiva/test-double-literal-node.rb
similarity index 74%
copy from ruby/red-gandiva/lib/gandiva/loader.rb
copy to c_glib/test/gandiva/test-double-literal-node.rb
index 5a95897..fd4bd08 100644
--- a/ruby/red-gandiva/lib/gandiva/loader.rb
+++ b/c_glib/test/gandiva/test-double-literal-node.rb
@@ -15,12 +15,14 @@
# specific language governing permissions and limitations
# under the License.
-module Gandiva
- class Loader < GObjectIntrospection::Loader
- class << self
- def load
- super("Gandiva", Gandiva)
- end
- end
+class TestGandivaDoubleLiteralNode < Test::Unit::TestCase
+ def setup
+ omit("Gandiva is required") unless defined?(::Gandiva)
+ end
+
+ def test_value
+ value = 1.5
+ literal_node = Gandiva::DoubleLiteralNode.new(value)
+ assert_equal(value, literal_node.value)
end
end
diff --git a/ruby/red-gandiva/lib/gandiva/loader.rb b/c_glib/test/gandiva/test-float-literal-node.rb
similarity index 69%
copy from ruby/red-gandiva/lib/gandiva/loader.rb
copy to c_glib/test/gandiva/test-float-literal-node.rb
index 5a95897..202ec38 100644
--- a/ruby/red-gandiva/lib/gandiva/loader.rb
+++ b/c_glib/test/gandiva/test-float-literal-node.rb
@@ -15,12 +15,20 @@
# specific language governing permissions and limitations
# under the License.
-module Gandiva
- class Loader < GObjectIntrospection::Loader
- class << self
- def load
- super("Gandiva", Gandiva)
- end
+class TestGandivaFloatLiteralNode < Test::Unit::TestCase
+ def setup
+ omit("Gandiva is required") unless defined?(::Gandiva)
+ end
+
+ def test_new
+ assert_nothing_raised do
+ Gandiva::FloatLiteralNode.new(1.5)
end
end
+
+ def test_value
+ value = 1.5
+ literal_node = Gandiva::FloatLiteralNode.new(value)
+ assert_equal(value, literal_node.value)
+ end
end
diff --git a/ruby/red-gandiva/lib/gandiva/loader.rb b/c_glib/test/gandiva/test-int16-literal-node.rb
similarity index 74%
copy from ruby/red-gandiva/lib/gandiva/loader.rb
copy to c_glib/test/gandiva/test-int16-literal-node.rb
index 5a95897..9b5bb68 100644
--- a/ruby/red-gandiva/lib/gandiva/loader.rb
+++ b/c_glib/test/gandiva/test-int16-literal-node.rb
@@ -15,12 +15,14 @@
# specific language governing permissions and limitations
# under the License.
-module Gandiva
- class Loader < GObjectIntrospection::Loader
- class << self
- def load
- super("Gandiva", Gandiva)
- end
- end
+class TestGandivaInt16LiteralNode < Test::Unit::TestCase
+ def setup
+ omit("Gandiva is required") unless defined?(::Gandiva)
+ end
+
+ def test_value
+ value = -3
+ literal_node = Gandiva::Int16LiteralNode.new(value)
+ assert_equal(value, literal_node.value)
end
end
diff --git a/ruby/red-gandiva/lib/gandiva/loader.rb b/c_glib/test/gandiva/test-int32-literal-node.rb
similarity index 74%
copy from ruby/red-gandiva/lib/gandiva/loader.rb
copy to c_glib/test/gandiva/test-int32-literal-node.rb
index 5a95897..9c94cde 100644
--- a/ruby/red-gandiva/lib/gandiva/loader.rb
+++ b/c_glib/test/gandiva/test-int32-literal-node.rb
@@ -15,12 +15,14 @@
# specific language governing permissions and limitations
# under the License.
-module Gandiva
- class Loader < GObjectIntrospection::Loader
- class << self
- def load
- super("Gandiva", Gandiva)
- end
- end
+class TestGandivaInt32LiteralNode < Test::Unit::TestCase
+ def setup
+ omit("Gandiva is required") unless defined?(::Gandiva)
+ end
+
+ def test_value
+ value = -3
+ literal_node = Gandiva::Int32LiteralNode.new(value)
+ assert_equal(value, literal_node.value)
end
end
diff --git a/ruby/red-gandiva/lib/gandiva/loader.rb b/c_glib/test/gandiva/test-int64-literal-node.rb
similarity index 74%
copy from ruby/red-gandiva/lib/gandiva/loader.rb
copy to c_glib/test/gandiva/test-int64-literal-node.rb
index 5a95897..e1b4b91 100644
--- a/ruby/red-gandiva/lib/gandiva/loader.rb
+++ b/c_glib/test/gandiva/test-int64-literal-node.rb
@@ -15,12 +15,14 @@
# specific language governing permissions and limitations
# under the License.
-module Gandiva
- class Loader < GObjectIntrospection::Loader
- class << self
- def load
- super("Gandiva", Gandiva)
- end
- end
+class TestGandivaInt64LiteralNode < Test::Unit::TestCase
+ def setup
+ omit("Gandiva is required") unless defined?(::Gandiva)
+ end
+
+ def test_value
+ value = -3
+ literal_node = Gandiva::Int64LiteralNode.new(value)
+ assert_equal(value, literal_node.value)
end
end
diff --git a/ruby/red-gandiva/lib/gandiva/loader.rb b/c_glib/test/gandiva/test-int8-literal-node.rb
similarity index 75%
copy from ruby/red-gandiva/lib/gandiva/loader.rb
copy to c_glib/test/gandiva/test-int8-literal-node.rb
index 5a95897..30f11fc 100644
--- a/ruby/red-gandiva/lib/gandiva/loader.rb
+++ b/c_glib/test/gandiva/test-int8-literal-node.rb
@@ -15,12 +15,14 @@
# specific language governing permissions and limitations
# under the License.
-module Gandiva
- class Loader < GObjectIntrospection::Loader
- class << self
- def load
- super("Gandiva", Gandiva)
- end
- end
+class TestGandivaInt8LiteralNode < Test::Unit::TestCase
+ def setup
+ omit("Gandiva is required") unless defined?(::Gandiva)
+ end
+
+ def test_value
+ value = -3
+ literal_node = Gandiva::Int8LiteralNode.new(value)
+ assert_equal(value, literal_node.value)
end
end
diff --git a/ruby/red-gandiva/lib/gandiva/loader.rb b/c_glib/test/gandiva/test-string-literal-node.rb
similarity index 74%
copy from ruby/red-gandiva/lib/gandiva/loader.rb
copy to c_glib/test/gandiva/test-string-literal-node.rb
index 5a95897..a231f61 100644
--- a/ruby/red-gandiva/lib/gandiva/loader.rb
+++ b/c_glib/test/gandiva/test-string-literal-node.rb
@@ -15,12 +15,14 @@
# specific language governing permissions and limitations
# under the License.
-module Gandiva
- class Loader < GObjectIntrospection::Loader
- class << self
- def load
- super("Gandiva", Gandiva)
- end
- end
+class TestGandivaStringLiteralNode < Test::Unit::TestCase
+ def setup
+ omit("Gandiva is required") unless defined?(::Gandiva)
+ end
+
+ def test_value
+ value = "Hello"
+ literal_node = Gandiva::StringLiteralNode.new(value)
+ assert_equal(value, literal_node.value)
end
end
diff --git a/ruby/red-gandiva/lib/gandiva/loader.rb b/c_glib/test/gandiva/test-uint16-literal-node.rb
similarity index 74%
copy from ruby/red-gandiva/lib/gandiva/loader.rb
copy to c_glib/test/gandiva/test-uint16-literal-node.rb
index 5a95897..e8bdd30 100644
--- a/ruby/red-gandiva/lib/gandiva/loader.rb
+++ b/c_glib/test/gandiva/test-uint16-literal-node.rb
@@ -15,12 +15,14 @@
# specific language governing permissions and limitations
# under the License.
-module Gandiva
- class Loader < GObjectIntrospection::Loader
- class << self
- def load
- super("Gandiva", Gandiva)
- end
- end
+class TestGandivaUInt16LiteralNode < Test::Unit::TestCase
+ def setup
+ omit("Gandiva is required") unless defined?(::Gandiva)
+ end
+
+ def test_value
+ value = 3
+ literal_node = Gandiva::UInt16LiteralNode.new(value)
+ assert_equal(value, literal_node.value)
end
end
diff --git a/ruby/red-gandiva/lib/gandiva/loader.rb b/c_glib/test/gandiva/test-uint32-literal-node.rb
similarity index 74%
copy from ruby/red-gandiva/lib/gandiva/loader.rb
copy to c_glib/test/gandiva/test-uint32-literal-node.rb
index 5a95897..9d59957 100644
--- a/ruby/red-gandiva/lib/gandiva/loader.rb
+++ b/c_glib/test/gandiva/test-uint32-literal-node.rb
@@ -15,12 +15,14 @@
# specific language governing permissions and limitations
# under the License.
-module Gandiva
- class Loader < GObjectIntrospection::Loader
- class << self
- def load
- super("Gandiva", Gandiva)
- end
- end
+class TestGandivaUInt32LiteralNode < Test::Unit::TestCase
+ def setup
+ omit("Gandiva is required") unless defined?(::Gandiva)
+ end
+
+ def test_value
+ value = 3
+ literal_node = Gandiva::UInt32LiteralNode.new(value)
+ assert_equal(value, literal_node.value)
end
end
diff --git a/ruby/red-gandiva/lib/gandiva/loader.rb b/c_glib/test/gandiva/test-uint64-literal-node.rb
similarity index 74%
copy from ruby/red-gandiva/lib/gandiva/loader.rb
copy to c_glib/test/gandiva/test-uint64-literal-node.rb
index 5a95897..56c46db 100644
--- a/ruby/red-gandiva/lib/gandiva/loader.rb
+++ b/c_glib/test/gandiva/test-uint64-literal-node.rb
@@ -15,12 +15,14 @@
# specific language governing permissions and limitations
# under the License.
-module Gandiva
- class Loader < GObjectIntrospection::Loader
- class << self
- def load
- super("Gandiva", Gandiva)
- end
- end
+class TestGandivaUInt64LiteralNode < Test::Unit::TestCase
+ def setup
+ omit("Gandiva is required") unless defined?(::Gandiva)
+ end
+
+ def test_value
+ value = 3
+ literal_node = Gandiva::UInt64LiteralNode.new(value)
+ assert_equal(value, literal_node.value)
end
end
diff --git a/ruby/red-gandiva/lib/gandiva/loader.rb b/c_glib/test/gandiva/test-uint8-literal-node.rb
similarity index 74%
copy from ruby/red-gandiva/lib/gandiva/loader.rb
copy to c_glib/test/gandiva/test-uint8-literal-node.rb
index 5a95897..04f76cd 100644
--- a/ruby/red-gandiva/lib/gandiva/loader.rb
+++ b/c_glib/test/gandiva/test-uint8-literal-node.rb
@@ -15,12 +15,14 @@
# specific language governing permissions and limitations
# under the License.
-module Gandiva
- class Loader < GObjectIntrospection::Loader
- class << self
- def load
- super("Gandiva", Gandiva)
- end
- end
+class TestGandivaUInt8LiteralNode < Test::Unit::TestCase
+ def setup
+ omit("Gandiva is required") unless defined?(::Gandiva)
+ end
+
+ def test_value
+ value = 3
+ literal_node = Gandiva::UInt8LiteralNode.new(value)
+ assert_equal(value, literal_node.value)
end
end
diff --git a/ruby/red-gandiva/lib/gandiva/loader.rb b/ruby/red-gandiva/lib/gandiva/loader.rb
index 5a95897..845275c 100644
--- a/ruby/red-gandiva/lib/gandiva/loader.rb
+++ b/ruby/red-gandiva/lib/gandiva/loader.rb
@@ -22,5 +22,19 @@ module Gandiva
super("Gandiva", Gandiva)
end
end
+
+ private
+ def load_method_info(info, klass, method_name)
+ case klass.name
+ when "Gandiva::BooleanLiteralNode"
+ case method_name
+ when "value?"
+ method_name = "value"
+ end
+ super(info, klass, method_name)
+ else
+ super
+ end
+ end
end
end
diff --git a/ruby/red-gandiva/lib/gandiva/loader.rb b/ruby/red-gandiva/test/test-boolean-literal-node.rb
similarity index 80%
copy from ruby/red-gandiva/lib/gandiva/loader.rb
copy to ruby/red-gandiva/test/test-boolean-literal-node.rb
index 5a95897..d79f729 100644
--- a/ruby/red-gandiva/lib/gandiva/loader.rb
+++ b/ruby/red-gandiva/test/test-boolean-literal-node.rb
@@ -15,12 +15,10 @@
# specific language governing permissions and limitations
# under the License.
-module Gandiva
- class Loader < GObjectIntrospection::Loader
- class << self
- def load
- super("Gandiva", Gandiva)
- end
- end
+class TestBooleanLiteralNode < Test::Unit::TestCase
+ def test_value
+ value = true
+ literal_node = Gandiva::BooleanLiteralNode.new(value)
+ assert_equal(value, literal_node.value)
end
end