ruby-ladybug 0.1.0

data/ext/ladybug_ext/ladybug_ext.h

@@ -0,0 +1,132 @@
+/*
+ *  ladybug_ext.h - Ruby binding for LadybugDB
+ *
+ *  Authors:
+ *    * Michael Granger <ged@FaerieMUD.org>
+ *
+ */
+
+#ifndef LBUG_EXT_H_AA9CC4A5
+#define LBUG_EXT_H_AA9CC4A5
+
+#include "extconf.h"
+
+#include <ruby.h>
+#include <ruby/encoding.h>
+#include <ruby/intern.h>
+#include <ruby/thread.h>
+#include <ruby/version.h>
+
+#include <stdbool.h>
+
+#include "lbug.h"
+
+/* --------------------------------------------------------------
+ * Declarations
+ * -------------------------------------------------------------- */
+
+#ifdef HAVE_STDARG_PROTOTYPES
+#include <stdarg.h>
+#define va_init_list(a, b) va_start (a, b)
+void rlbug_log_obj (VALUE, const char *, const char *, ...)
+	__attribute__ ((format (printf, 2, 0)));
+void rlbug_log (const char *, const char *, ...)
+	__attribute__ ((format (printf, 1, 0)));
+#else
+#include <varargs.h>
+#define va_init_list(a, b) va_start (a)
+void rlbug_log_obj (VALUE, const char *, const char *, va_dcl);
+void rlbug_log (const char *, const char *, va_dcl);
+#endif
+
+/* --------------------------------------------------------------
+ * Structs
+ * -------------------------------------------------------------- */
+
+typedef struct {
+    lbug_database db;
+    VALUE path;
+    VALUE config;
+} rlbug_database;
+
+typedef struct {
+    lbug_connection conn;
+    VALUE database;
+    VALUE queries;
+    VALUE statements;
+} rlbug_connection;
+
+typedef struct {
+    lbug_query_result result;
+    VALUE connection;
+    VALUE query;
+    VALUE statement;
+    VALUE previous_result;
+    VALUE next_result;
+    bool finished;
+} rlbug_query_result;
+
+typedef struct {
+    lbug_prepared_statement statement;
+    VALUE connection;
+    VALUE query;
+    bool finished;
+} rlbug_prepared_statement;
+
+
+/* -------------------------------------------------------
+ * Globals
+ * ------------------------------------------------------- */
+
+// Modules and classes
+extern VALUE rlbug_mLadybug;
+extern VALUE rlbug_cLadybugDatabase;
+extern VALUE rlbug_cLadybugConfig;
+extern VALUE rlbug_cLadybugConnection;
+extern VALUE rlbug_cLadybugPreparedStatement;
+extern VALUE rlbug_cLadybugResult;
+extern VALUE rlbug_cLadybugQuerySummary;
+extern VALUE rlbug_cLadybugNode;
+extern VALUE rlbug_cLadybugRecursiveRel;
+extern VALUE rlbug_cLadybugRel;
+
+// Exception types
+extern VALUE rlbug_eError;
+extern VALUE rlbug_eDatabaseError;
+extern VALUE rlbug_eConnectionError;
+extern VALUE rlbug_eQueryError;
+extern VALUE rlbug_eFinishedError;
+
+// Internal refs to external classes
+extern VALUE rlbug_rb_cDate;
+extern VALUE rlbug_rb_cOstruct;
+
+
+/* -------------------------------------------------------
+ * Initializer functions
+ * ------------------------------------------------------- */
+extern void Init_ladybug_ext _ ((void));
+
+extern void rlbug_init_database _ ((void));
+extern void rlbug_init_config _ ((void));
+extern void rlbug_init_connection _ ((void));
+extern void rlbug_init_prepared_statement _ ((void));
+extern void rlbug_init_result _ ((void));
+extern void rlbug_init_query_summary _ ((void));
+extern void rlbug_init_node _ ((void));
+extern void rlbug_init_rel _ ((void));
+extern void rlbug_init_recursive_rel _ ((void));
+
+extern rlbug_database *rlbug_get_database _ ((VALUE));
+extern lbug_system_config *rlbug_get_config _ ((VALUE));
+extern rlbug_connection *rlbug_get_connection _ ((VALUE));
+extern rlbug_prepared_statement *rlbug_get_prepared_statement _ ((VALUE));
+extern rlbug_query_result *rlbug_get_result _ ((VALUE));
+
+extern VALUE rlbug_convert_lbug_value_to_ruby _ ((lbug_data_type_id, lbug_value *));
+extern VALUE rlbug_convert_logical_lbug_value_to_ruby _ ((lbug_logical_type *, lbug_value *));
+extern VALUE rlbug_value_to_ruby _ (( lbug_value * ));
+extern VALUE rlbug_result_from_query _ ((VALUE, VALUE, VALUE, lbug_query_result));
+extern VALUE rlbug_result_from_prepared_statement _ ((VALUE, VALUE, VALUE, lbug_query_result));
+
+#endif /* end of include guard: LBUG_EXT_H_AA9CC4A5 */

data/ext/ladybug_ext/node.c

@@ -0,0 +1,24 @@
+/*
+ *  node.c - Ladybug::Node class
+ *
+ */
+
+#include "ladybug_ext.h"
+
+VALUE rlbug_cLadybugNode;
+
+
+/*
+ * Document-class: Ladybug::Node
+ */
+void
+rlbug_init_node( void )
+{
+#ifdef FOR_RDOC
+	rlbug_mLadybug = rb_define_module( "ladybug" );
+#endif
+
+	rlbug_cLadybugNode = rb_define_class_under( rlbug_mLadybug, "Node", rb_cObject );
+
+	rb_require( "ladybug/node" );
+}

data/ext/ladybug_ext/prepared_statement.c

@@ -0,0 +1,396 @@
+/*
+ *  prepared_statement.c - Ladybug::PreparedStatement class
+ *
+ */
+
+#include "lbug.h"
+#include "ladybug_ext.h"
+
+#define CHECK_PREPARED_STATEMENT( self ) \
+	((rlbug_prepared_statement *)rb_check_typeddata( (self), &rlbug_prepared_statement_type) )
+// #define DEBUG_GC(msg, ptr) fprintf( stderr, msg, ptr )
+#define DEBUG_GC(msg, ptr)
+
+
+VALUE rlbug_cLadybugPreparedStatement;
+
+static void rlbug_prepared_statement_free( void * );
+static void rlbug_prepared_statement_mark( void * );
+static void rlbug_bind_string( rlbug_prepared_statement *, const char *, VALUE );
+
+static const rb_data_type_t rlbug_prepared_statement_type = {
+	.wrap_struct_name = "Ladybug::PreparedStatement",
+	.function = {
+		.dfree = rlbug_prepared_statement_free,
+		.dmark = rlbug_prepared_statement_mark,
+	},
+	.data = NULL,
+};
+
+
+
+/*
+ * Fetch function
+ */
+rlbug_prepared_statement *
+rlbug_get_prepared_statement( VALUE prepared_statement_obj )
+{
+	return CHECK_PREPARED_STATEMENT( prepared_statement_obj );
+}
+
+
+/*
+ * Allocation function
+ */
+static rlbug_prepared_statement *
+rlbug_prepared_statement_alloc( void )
+{
+	rlbug_prepared_statement *ptr = ALLOC( rlbug_prepared_statement );
+
+	ptr->connection = Qnil;
+	ptr->query = Qnil;
+
+	return ptr;
+}
+
+
+/*
+ * dmark function
+ */
+static void
+rlbug_prepared_statement_mark( void *ptr )
+{
+	rlbug_prepared_statement *prepared_statement_s = (rlbug_prepared_statement *)ptr;
+
+	if ( ptr ) {
+		rb_gc_mark( prepared_statement_s->connection );
+		rb_gc_mark( prepared_statement_s->query );
+	}
+}
+
+
+/*
+ * dfree function
+ */
+static void
+rlbug_prepared_statement_free( void *ptr )
+{
+	if ( ptr ) {
+		DEBUG_GC( ">>> freeing prepared statement %p\n", ptr );
+		// Can't lbug_prepared_statement_destroy here because the database or connection
+		// might already have been destroyed.
+		xfree( ptr );
+		ptr = NULL;
+	}
+}
+
+
+/*
+ * ::allocate function
+ */
+static VALUE
+rlbug_prepared_statement_s_allocate( VALUE klass )
+{
+	return TypedData_Wrap_Struct( klass, &rlbug_prepared_statement_type, NULL );
+}
+
+
+static VALUE
+rlbug_prepared_statement_initialize( VALUE self, VALUE connection, VALUE query )
+{
+	rlbug_prepared_statement *stmt = CHECK_PREPARED_STATEMENT( self );
+
+	if ( !stmt ) {
+		rlbug_connection *conn = rlbug_get_connection( connection );
+		const char *query_s = StringValueCStr( query );
+
+		stmt = rlbug_prepared_statement_alloc();
+
+		if ( lbug_connection_prepare(&conn->conn, query_s, &stmt->statement) != LbugSuccess ) {
+			char *err_detail = lbug_prepared_statement_get_error_message( &stmt->statement );
+			char errmsg[ 4096 ] = "\0";
+
+			snprintf( errmsg, 4096, "Could not prepare query `%s': %s.", query_s, err_detail );
+
+			xfree( stmt );
+			stmt = NULL;
+			lbug_destroy_string( err_detail );
+
+			rb_raise( rlbug_eQueryError, "%s", errmsg );
+		}
+
+		DEBUG_GC( ">>> allocated prepared statement %p\n", stmt );
+		RTYPEDDATA_DATA( self ) = stmt;
+
+		stmt->connection = connection;
+		stmt->query = query;
+
+	} else {
+		rb_raise( rb_eRuntimeError, "cannot reinit prepared statement" );
+	}
+
+	rb_call_super( 0, 0 );
+
+	return Qtrue;
+}
+
+
+struct execute_call {
+	lbug_connection *conn;
+	lbug_prepared_statement *stmt;
+	lbug_query_result *result;
+};
+
+
+static void *
+rlbug_connection_do_execute_without_gvl( void *ptr )
+{
+	struct execute_call *qcall = (struct execute_call *)ptr;
+	lbug_state state;
+
+	state = lbug_connection_execute( qcall->conn, qcall->stmt, qcall->result );
+
+	return (void *)state;
+}
+
+
+static void
+rlbug_connection_cancel_execute( void *ptr )
+{
+	lbug_connection *conn = (lbug_connection *)ptr;
+	lbug_connection_interrupt( conn );
+}
+
+
+// Inner prepared statement constructor
+static lbug_query_result
+rlbug_prepared_statement_do_execute( VALUE self )
+{
+	rlbug_prepared_statement *stmt = CHECK_PREPARED_STATEMENT( self );
+	VALUE connection = stmt->connection;
+	rlbug_connection *conn = rlbug_get_connection( connection );
+	lbug_query_result result;
+	struct execute_call qcall;
+	lbug_state execute_state;
+	void *result_ptr;
+
+	qcall.conn = &conn->conn;
+	qcall.stmt = &stmt->statement;
+	qcall.result = &result;
+
+	result_ptr = rb_thread_call_without_gvl(
+		rlbug_connection_do_execute_without_gvl, (void *)&qcall,
+		rlbug_connection_cancel_execute, (void *)&conn->conn );
+
+	_Pragma("GCC diagnostic push")
+	_Pragma("GCC diagnostic ignored \"-Wvoid-pointer-to-enum-cast\"")
+	execute_state = (lbug_state)result_ptr;
+	_Pragma("GCC diagnostic pop")
+
+	if ( execute_state != LbugSuccess ) {
+		char *err_detail = lbug_query_result_get_error_message( &result );
+		char errmsg[ 4096 ] = "\0";
+
+		snprintf( errmsg, 4096, "Could not execute prepared statement: %s.", err_detail );
+
+		lbug_destroy_string( err_detail );
+		lbug_query_result_destroy( &result );
+
+		rb_raise( rlbug_eQueryError, "%s", errmsg );
+	}
+
+	return *qcall.result;
+}
+
+
+static VALUE
+rlbug_prepared_statement__execute( VALUE self )
+{
+	rlbug_prepared_statement *stmt = CHECK_PREPARED_STATEMENT( self );
+	lbug_query_result result = rlbug_prepared_statement_do_execute( self );
+
+	return rlbug_result_from_prepared_statement( rlbug_cLadybugResult, stmt->connection, self, result );
+}
+
+
+static VALUE
+rlbug_prepared_statement__execute_bang( VALUE self )
+{
+	lbug_query_result result = rlbug_prepared_statement_do_execute( self );
+	return lbug_query_result_is_success( &result ) ? Qtrue : Qfalse;
+}
+
+
+/*
+ * call-seq:
+ *    statement.success?   -> true or false
+ *
+ * Returns +true+ if the query was prepared successfully.
+ *
+ */
+static VALUE
+rlbug_prepared_statement_success_p( VALUE self )
+{
+	rlbug_prepared_statement *stmt = CHECK_PREPARED_STATEMENT( self );
+
+	if ( lbug_prepared_statement_is_success(&stmt->statement) ) {
+		return Qtrue;
+	} else {
+		return Qfalse;
+	}
+}
+
+
+/*
+ * call-seq:
+ *    statement.bind_variable( name, value )
+ *
+ * Binds the given +value+ to the given parameter +name+ in the prepared statement
+ *
+ */
+static VALUE
+rlbug_prepared_statement_bind_variable( VALUE self, VALUE name, VALUE value )
+{
+	rlbug_prepared_statement *stmt = CHECK_PREPARED_STATEMENT( self );
+	VALUE name_string = rb_funcall( name, rb_intern("to_s"), 0 );
+	const char *name_s = StringValueCStr( name_string );
+	lbug_value *null_value;
+
+	switch (TYPE(value)) {
+		case T_TRUE:
+		case T_FALSE:
+			lbug_prepared_statement_bind_bool( &stmt->statement, name_s, RTEST(value) );
+			break;
+
+		// fallthrough
+		case T_FLOAT:
+			lbug_prepared_statement_bind_float( &stmt->statement, name_s, NUM2DBL(value) );
+			break;
+
+		case T_BIGNUM:
+			lbug_prepared_statement_bind_int64( &stmt->statement, name_s, NUM2LL(value) );
+			break;
+
+		case T_FIXNUM:
+			lbug_prepared_statement_bind_int32( &stmt->statement, name_s, NUM2INT(value) );
+			break;
+
+		case T_SYMBOL:
+			rb_notimplement();
+			break; // not reached
+
+		case T_NIL:
+			null_value = lbug_value_create_null();
+			lbug_prepared_statement_bind_value( &stmt->statement, name_s, null_value );
+			lbug_value_destroy( null_value );
+			break;
+
+		case T_OBJECT:
+		case T_CLASS:
+		case T_MODULE:
+		case T_REGEXP:
+		case T_ARRAY:
+		case T_HASH:
+		case T_STRUCT:
+		case T_COMPLEX:
+		case T_RATIONAL:
+		case T_FILE:
+		case T_DATA:
+		case T_STRING:
+		default:
+			rlbug_bind_string( stmt, name_s, value );
+			break;
+
+			// lbug_prepared_statement_bind_int8
+			// lbug_prepared_statement_bind_int16
+			// lbug_prepared_statement_bind_uint64
+			// lbug_prepared_statement_bind_uint32
+			// lbug_prepared_statement_bind_uint16
+			// lbug_prepared_statement_bind_uint8
+
+			// lbug_prepared_statement_bind_double
+			// lbug_prepared_statement_bind_date
+			// lbug_prepared_statement_bind_timestamp_ns
+			// lbug_prepared_statement_bind_timestamp_sec
+			// lbug_prepared_statement_bind_timestamp_tz
+			// lbug_prepared_statement_bind_timestamp_ms
+			// lbug_prepared_statement_bind_timestamp
+			// lbug_prepared_statement_bind_interval
+			// lbug_prepared_statement_bind_value
+	}
+
+	return Qtrue;
+}
+
+
+static void
+rlbug_bind_string( rlbug_prepared_statement *stmt, const char *name_s, VALUE value )
+{
+	const char *value_s = StringValueCStr( value );
+	lbug_prepared_statement_bind_string( &stmt->statement, name_s, value_s );
+}
+
+
+/*
+ * call-seq:
+ *    statement.connection   -> conn
+ *
+ * Return the Ladybug::Connection used to run this statement.
+ *
+ */
+static VALUE
+rlbug_prepared_statement_connection( VALUE self )
+{
+	rlbug_prepared_statement *statement_s = rlbug_get_prepared_statement( self );
+	return statement_s->connection;
+}
+
+
+/*
+ * call-seq:
+ *    statement.query   -> string
+ *
+ * Return the query string used to build this statement.
+ *
+ */
+static VALUE
+rlbug_prepared_statement_query( VALUE self )
+{
+	rlbug_prepared_statement *statement_s = rlbug_get_prepared_statement( self );
+	return statement_s->query;
+}
+
+
+
+/*
+ * Document-class: Ladybug::PreparedStatement
+ */
+void
+rlbug_init_prepared_statement( void )
+{
+#ifdef FOR_RDOC
+	rlbug_mLadybug = rb_define_module( "ladybug" );
+#endif
+
+	rlbug_cLadybugPreparedStatement = rb_define_class_under( rlbug_mLadybug, "PreparedStatement", rb_cObject );
+
+	rb_define_alloc_func( rlbug_cLadybugPreparedStatement, rlbug_prepared_statement_s_allocate );
+
+	rb_define_protected_method( rlbug_cLadybugPreparedStatement, "initialize",
+		rlbug_prepared_statement_initialize, 2 );
+	rb_define_protected_method( rlbug_cLadybugPreparedStatement, "_execute",
+		rlbug_prepared_statement__execute, 0 );
+	rb_define_protected_method( rlbug_cLadybugPreparedStatement, "_execute!",
+		rlbug_prepared_statement__execute_bang, 0 );
+
+	rb_define_method( rlbug_cLadybugPreparedStatement, "connection",
+		rlbug_prepared_statement_connection, 0 );
+	rb_define_method( rlbug_cLadybugPreparedStatement, "query",
+		rlbug_prepared_statement_query, 0 );
+
+	rb_define_method( rlbug_cLadybugPreparedStatement, "success?", rlbug_prepared_statement_success_p, 0 );
+	rb_define_method( rlbug_cLadybugPreparedStatement, "bind_variable",
+		rlbug_prepared_statement_bind_variable, 2 );
+
+	rb_require( "ladybug/prepared_statement" );
+}

data/ext/ladybug_ext/query_summary.c

@@ -0,0 +1,140 @@
+/*
+ *  query_summary.c - Ladybug::QuerySummary class
+ *
+ */
+
+#include "ladybug_ext.h"
+
+#define CHECK_QUERY_SUMMARY(self) \
+	((lbug_query_summary*)rb_check_typeddata((self), &rlbug_query_summary_type))
+// #define DEBUG_GC(msg, ptr) fprintf( stderr, msg, ptr )
+#define DEBUG_GC(msg, ptr)
+
+
+VALUE rlbug_cLadybugQuerySummary;
+
+static void rlbug_query_summary_free( void * );
+
+static const rb_data_type_t rlbug_query_summary_type = {
+	.wrap_struct_name = "Ladybug::QuerySummary",
+	.function = {
+		.dfree = rlbug_query_summary_free,
+	},
+	.data = NULL,
+};
+
+
+static void
+rlbug_query_summary_free( void *ptr )
+{
+	lbug_query_summary *query_summary = (lbug_query_summary *)ptr;
+
+	if ( ptr ) {
+		DEBUG_GC( ">>> freeing query summary %p\n", ptr );
+		lbug_query_summary_destroy( query_summary );
+		xfree( ptr );
+	}
+}
+
+
+/*
+ * ::allocate function
+ */
+static VALUE
+rlbug_query_summary_s_allocate( VALUE klass )
+{
+	return TypedData_Wrap_Struct( klass, &rlbug_query_summary_type, NULL );
+}
+
+
+/*
+ * call-seq:
+ *    Ladybug::QuerySummary.from_result( result )   -> query_summary
+ *
+ * Return a Ladybug::QuerySummary from a Ladybug::Result.
+ *
+ */
+static VALUE
+rlbug_query_summary_s_from_result( VALUE klass, VALUE query_result )
+{
+	rlbug_query_result *result = rlbug_get_result( query_result );
+
+	lbug_query_summary *query_summary = ALLOC( lbug_query_summary );
+	VALUE query_summary_obj = rb_class_new_instance( 0, 0, klass );
+
+	/*
+		TODO Release the GIL
+	*/
+	if ( lbug_query_result_get_query_summary(&result->result, query_summary) != LbugSuccess ) {
+		xfree( query_summary );
+		query_summary = NULL;
+		rb_raise( rlbug_eQueryError, "Could not fetch the query summary." );
+	}
+
+	DEBUG_GC( ">>> allocated query summary %p\n", query_summary );
+	RTYPEDDATA_DATA( query_summary_obj ) = query_summary;
+
+	return query_summary_obj;
+}
+
+
+/**
+ * call-seq:
+ *    summary.compiling_time             -> float
+ *
+ * Returns the compilation time of the given query summary in milliseconds.
+ *
+ */
+static VALUE
+rlbug_query_summary_compiling_time( VALUE self )
+{
+	lbug_query_summary *summary = CHECK_QUERY_SUMMARY( self );
+	double result = lbug_query_summary_get_compiling_time( summary );
+
+	return rb_float_new( result );
+}
+
+
+/**
+ * call-seq:
+ *    summary.execution_time             -> float
+ *
+ * Returns the execution time of the given query summary in milliseconds.
+ *
+ */
+static VALUE
+rlbug_query_summary_execution_time( VALUE self )
+{
+	lbug_query_summary *summary = CHECK_QUERY_SUMMARY( self );
+	double result = lbug_query_summary_get_execution_time( summary );
+
+	return rb_float_new( result );
+}
+
+
+/*
+ * Document-class: Ladybug::QuerySummary
+ */
+void
+rlbug_init_query_summary( void )
+{
+#ifdef FOR_RDOC
+	rlbug_mLadybug = rb_define_module( "ladybug" );
+#endif
+
+	rlbug_cLadybugQuerySummary = rb_define_class_under( rlbug_mLadybug, "QuerySummary", rb_cObject );
+
+	rb_define_alloc_func( rlbug_cLadybugQuerySummary, rlbug_query_summary_s_allocate );
+	rb_undef_method( CLASS_OF(rlbug_cLadybugQuerySummary), "new" );
+
+	rb_define_singleton_method( rlbug_cLadybugQuerySummary, "from_result",
+		rlbug_query_summary_s_from_result, 1 );
+	rb_define_alias( CLASS_OF(rlbug_cLadybugQuerySummary), "from_query_result", "from_result" );
+
+	rb_define_method( rlbug_cLadybugQuerySummary, "compiling_time",
+		rlbug_query_summary_compiling_time, 0 );
+	rb_define_method( rlbug_cLadybugQuerySummary, "execution_time",
+		rlbug_query_summary_execution_time, 0 );
+
+	rb_require( "ladybug/query_summary" );
+}

data/ext/ladybug_ext/recursive_rel.c

@@ -0,0 +1,24 @@
+/*
+ *  recursive_rel.c - Ladybug::RecursiveRel class
+ *
+ */
+
+#include "ladybug_ext.h"
+
+VALUE rlbug_cLadybugRecursiveRel;
+
+
+/*
+ * Document-class: Ladybug::RecursiveRel
+ */
+void
+rlbug_init_recursive_rel( void )
+{
+#ifdef FOR_RDOC
+	rlbug_mLadybug = rb_define_module( "ladybug" );
+#endif
+
+	rlbug_cLadybugRecursiveRel = rb_define_class_under( rlbug_mLadybug, "RecursiveRel", rb_cObject );
+
+	rb_require( "ladybug/recursive_rel" );
+}