ruby-ladybug 0.1.0

data/ext/ladybug_ext/connection.c

@@ -0,0 +1,331 @@
+/*
+ *  connection.c - Ladybug::Connection class
+ *
+ */
+
+#include "lbug.h"
+#include "ladybug_ext.h"
+#include "ruby/thread.h"
+
+#define CHECK_CONNECTION(self) ((rlbug_connection *)rb_check_typeddata((self), &rlbug_connection_type))
+// #define DEBUG_GC(msg, ptr) fprintf( stderr, msg, ptr )
+#define DEBUG_GC(msg, ptr)
+
+
+VALUE rlbug_cLadybugConnection;
+
+static void rlbug_connection_free( void * );
+static void rlbug_connection_mark( void * );
+
+static const rb_data_type_t rlbug_connection_type = {
+	.wrap_struct_name = "Ladybug::Connection",
+	.function = {
+		.dfree = rlbug_connection_free,
+		.dmark = rlbug_connection_mark,
+	},
+	.data = NULL,
+};
+
+
+rlbug_connection *
+rlbug_get_connection( VALUE conn_obj )
+{
+	return CHECK_CONNECTION( conn_obj );
+}
+
+
+static rlbug_connection *
+rlbug_connection_alloc( void )
+{
+	rlbug_connection *ptr = ALLOC( rlbug_connection );
+
+	ptr->database = Qnil;
+	ptr->queries = rb_ary_new();
+	ptr->statements = rb_ary_new();
+
+	return ptr;
+}
+
+
+static void
+rlbug_connection_free( void *ptr )
+{
+	rlbug_connection *conn_s = (rlbug_connection *)ptr;
+
+	if ( ptr ) {
+		DEBUG_GC( ">>> freeing connection %p\n", ptr );
+
+		lbug_connection_destroy( &conn_s->conn );
+
+		xfree( ptr );
+		ptr = NULL;
+	}
+}
+
+
+static void
+rlbug_connection_mark( void *ptr )
+{
+	rlbug_connection *conn_s = (rlbug_connection *)ptr;
+
+	if ( ptr ) {
+		DEBUG_GC( ">>> marking connection %p\n", ptr );
+		rb_gc_mark( conn_s->database );
+		rb_gc_mark( conn_s->statements );
+		rb_gc_mark( conn_s->queries );
+	}
+}
+
+
+/*
+ * ::allocate function
+ */
+static VALUE
+rlbug_connection_s_allocate( VALUE klass )
+{
+	return TypedData_Wrap_Struct( klass, &rlbug_connection_type, NULL );
+}
+
+
+
+/*
+ * call-seq:
+ *    new( database )   -> connection
+ *
+ * Create a Ladybug::Connection to the specified +database+.
+ *
+ */
+static VALUE
+rlbug_connection_initialize( VALUE self, VALUE database )
+{
+	rlbug_connection *ptr = CHECK_CONNECTION( self );
+
+	if ( !ptr ) {
+		rlbug_database *dbobject = rlbug_get_database( database );
+		ptr = rlbug_connection_alloc();
+
+		if ( lbug_connection_init(&dbobject->db, &ptr->conn) != LbugSuccess ) {
+			xfree( ptr );
+			ptr = NULL;
+			rb_raise( rlbug_eConnectionError, "Failed to connect!" );
+		}
+
+		DEBUG_GC( ">>> allocated connection %p\n", ptr );
+		RTYPEDDATA_DATA( self ) = ptr;
+
+		ptr->database = database;
+
+	} else {
+		rb_raise( rb_eRuntimeError, "cannot reinit connection" );
+	}
+
+	rb_call_super( 0, 0 );
+
+	return Qtrue;
+}
+
+
+struct query_call {
+	lbug_connection *conn;
+	const char *query_s;
+	lbug_query_result *result;
+};
+
+
+static void *
+rlbug_connection_do_query_without_gvl( void *ptr )
+{
+	struct query_call *qcall = (struct query_call *)ptr;
+	lbug_state state;
+
+	state = lbug_connection_query( qcall->conn, qcall->query_s, qcall->result );
+
+	return (void *)state;
+}
+
+
+static void
+rlbug_connection_cancel_query( void *ptr )
+{
+	lbug_connection *conn = (lbug_connection *)ptr;
+	lbug_connection_interrupt( conn );
+}
+
+
+static lbug_query_result
+rlbug_connection_do_query( VALUE self, VALUE query )
+{
+	rlbug_connection *conn = CHECK_CONNECTION( self );
+	const char *query_s = StringValueCStr( query );
+	lbug_query_result result;
+	lbug_state query_state;
+	struct query_call qcall;
+	void *result_ptr;
+
+	qcall.conn = &conn->conn;
+	qcall.query_s = query_s;
+	qcall.result = &result;
+
+	result_ptr = rb_thread_call_without_gvl(
+		rlbug_connection_do_query_without_gvl, (void *)&qcall,
+		rlbug_connection_cancel_query, (void *)&conn->conn );
+
+	_Pragma("GCC diagnostic push")
+	_Pragma("GCC diagnostic ignored \"-Wvoid-pointer-to-enum-cast\"")
+	query_state = (lbug_state)result_ptr;
+	_Pragma("GCC diagnostic pop")
+
+	if ( query_state != LbugSuccess ) {
+		char *err_detail = lbug_query_result_get_error_message( &result );
+		char errmsg[ 4096 ] = "\0";
+
+		snprintf( errmsg, 4096, "Could not execute query `%s': %s.", query_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_connection__query( VALUE self, VALUE query )
+{
+	lbug_query_result result = rlbug_connection_do_query( self, query );
+	return rlbug_result_from_query( rlbug_cLadybugResult, self, query, result );
+}
+
+
+/*
+ * call-seq:
+ *    connection.query!( query_string )
+ *
+ * Execute the given +query_string+ and return `true` if the query was
+ * successful.
+ *
+ */
+static VALUE
+rlbug_connection_query_bang( VALUE self, VALUE query )
+{
+	lbug_query_result result = rlbug_connection_do_query( self, query );
+	return lbug_query_result_is_success( &result ) ? Qtrue : Qfalse;
+}
+
+
+/*
+ * call-seq:
+ *    connection.max_num_threads_for_exec   -> integer
+ *
+ * Returns the maximum number of threads of the connection to use for
+ * executing queries.
+ *
+ */
+static VALUE
+rlbug_connection_max_num_threads_for_exec( VALUE self )
+{
+	rlbug_connection *ptr = CHECK_CONNECTION( self );
+	uint64_t count;
+
+	if ( lbug_connection_get_max_num_thread_for_exec( &ptr->conn, &count ) != LbugSuccess ) {
+		rb_raise( rlbug_eError, "lbug_connection_get_max_num_thread_for_exec failed" );
+	}
+
+	return ULONG2NUM( count );
+}
+
+
+/*
+ * call-seq:
+ *    connection.max_num_threads_for_exec = integer
+ *
+ * Sets the maximum number of threads of the connection to use for
+ * executing queries.
+ *
+ */
+static VALUE
+rlbug_connection_max_num_threads_for_exec_eq( VALUE self, VALUE count )
+{
+	rlbug_connection *ptr = CHECK_CONNECTION( self );
+	uint64_t thread_count = NUM2ULONG( count );
+
+	if ( lbug_connection_set_max_num_thread_for_exec( &ptr->conn, thread_count ) != LbugSuccess ) {
+		rb_raise( rlbug_eError, "lbug_connection_set_max_num_thread_for_exec failed" );
+	}
+
+	return Qtrue;
+}
+
+
+/*
+ * call-seq:
+ *    connection.query_timeout = integer
+ *
+ * Sets query timeout value in milliseconds for the connection.
+ *
+ */
+static VALUE
+rlbug_connection_query_timeout_eq( VALUE self, VALUE timeout )
+{
+	rlbug_connection *ptr = CHECK_CONNECTION( self );
+	uint64_t timeout_in_ms = NUM2ULONG( timeout );
+
+	if ( lbug_connection_set_query_timeout( &ptr->conn, timeout_in_ms ) != LbugSuccess ) {
+		rb_raise( rlbug_eError, "lbug_connection_set_query_timeout failed" );
+	}
+
+	return Qtrue;
+}
+
+
+/*
+ * call-seq:
+ *    connection.database              -> database
+ *
+ * Return the database object the connection belongs to (a Ladybug::Database).
+ *
+ */
+static VALUE
+rlbug_connection_database( VALUE self )
+{
+	rlbug_connection *ptr = CHECK_CONNECTION( self );
+	return ptr->database;
+}
+
+
+
+/*
+ * Document-class: Ladybug::Connection
+ */
+void
+rlbug_init_connection( void )
+{
+#ifdef FOR_RDOC
+	rlbug_mLadybug = rb_define_module( "ladybug" );
+#endif
+
+	rlbug_cLadybugConnection = rb_define_class_under( rlbug_mLadybug, "Connection", rb_cObject );
+
+	rb_define_alloc_func( rlbug_cLadybugConnection, rlbug_connection_s_allocate );
+
+	rb_define_protected_method( rlbug_cLadybugConnection, "initialize", rlbug_connection_initialize, 1 );
+
+	rb_define_protected_method( rlbug_cLadybugConnection, "_query", rlbug_connection__query, 1 );
+	rb_define_method( rlbug_cLadybugConnection, "query!", rlbug_connection_query_bang, 1 );
+	rb_define_alias( rlbug_cLadybugConnection, "run", "query!" );
+
+	rb_define_method( rlbug_cLadybugConnection, "max_num_threads_for_exec",
+		rlbug_connection_max_num_threads_for_exec, 0 );
+	rb_define_method( rlbug_cLadybugConnection, "max_num_threads_for_exec=",
+		rlbug_connection_max_num_threads_for_exec_eq, 1 );
+
+	rb_define_method( rlbug_cLadybugConnection, "query_timeout=", rlbug_connection_query_timeout_eq, 1 );
+
+	rb_define_method( rlbug_cLadybugConnection, "database", rlbug_connection_database, 0 );
+	rb_define_alias( rlbug_cLadybugConnection, "db", "database" );
+
+	rb_require( "ladybug/connection" );
+}

data/ext/ladybug_ext/database.c

@@ -0,0 +1,197 @@
+/*
+ *  database.c - Ladybug::Database class
+ */
+
+#include "ladybug_ext.h"
+
+#define CHECK_DATABASE(self) ((rlbug_database*)rb_check_typeddata((self), &rlbug_database_type))
+// #define DEBUG_GC(msg, ptr) fprintf( stderr, msg, ptr )
+#define DEBUG_GC(msg, ptr)
+
+
+VALUE rlbug_cLadybugDatabase;
+
+static void rlbug_database_free( void * );
+static void rlbug_database_mark( void * );
+
+static const rb_data_type_t rlbug_database_type = {
+	.wrap_struct_name = "Ladybug::Database",
+	.function = {
+		.dmark = rlbug_database_mark,
+		.dfree = rlbug_database_free,
+	},
+	.data = NULL,
+};
+
+
+rlbug_database *
+rlbug_get_database( VALUE obj )
+{
+	return CHECK_DATABASE( obj );
+}
+
+
+/*
+ * Struct allocation/init function.
+ */
+static rlbug_database *
+rlbug_database_alloc( void )
+{
+	rlbug_database *ptr = ALLOC( rlbug_database );
+
+	ptr->path = Qnil;
+	ptr->config = Qnil;
+
+	return ptr;
+}
+
+
+/*
+ * Free function
+ */
+static void
+rlbug_database_free( void *ptr )
+{
+	if ( ptr ) {
+		DEBUG_GC( ">>> freeing database %p\n", ptr );
+		rlbug_database *database_s = (rlbug_database *)ptr;
+
+		lbug_database_destroy( &database_s->db );
+
+		database_s->path = Qnil;
+		database_s->config = Qnil;
+
+		xfree( ptr );
+		ptr = NULL;
+	}
+}
+
+
+/*
+ * Mark function
+ */
+static void
+rlbug_database_mark( void *ptr )
+{
+	rlbug_database *database_s = (rlbug_database *)ptr;
+
+	DEBUG_GC( ">>> marking database %p\n", ptr );
+
+	rb_gc_mark( database_s->path );
+	rb_gc_mark( database_s->config );
+}
+
+
+
+/*
+ * ::allocate function
+ */
+static VALUE
+rlbug_database_s_allocate( VALUE klass )
+{
+	return TypedData_Wrap_Struct( klass, &rlbug_database_type, NULL );
+}
+
+
+/*
+ * call-seq:
+ *    database.new( path, **options )   -> database
+ *
+ * Create a new Database using the given +path+ and +options+.
+ *
+ */
+static VALUE
+rlbug_database_initialize( int argc, VALUE *argv, VALUE self )
+{
+	rlbug_database *ptr = CHECK_DATABASE( self );
+
+	if ( !ptr ) {
+		VALUE path, options, config;
+		VALUE config_argv[1];
+		lbug_system_config *sysconfig;
+		char *database_path;
+
+		rb_scan_args( argc, argv, "1:", &path, &options );
+		if ( options == Qnil ) options = rb_hash_new();
+		config_argv[0] = options;
+		config = rb_funcallv_public_kw( rlbug_cLadybugConfig, rb_intern("from_options"), 1,
+			config_argv, RB_PASS_KEYWORDS );
+
+		sysconfig = rlbug_get_config( config );
+		database_path = StringValueCStr( path );
+
+		ptr = rlbug_database_alloc();
+		if ( lbug_database_init(database_path, *sysconfig, &ptr->db) != LbugSuccess ) {
+			xfree( ptr );
+			ptr = NULL;
+
+			rb_raise( rlbug_eDatabaseError, "Couldn't create database!" );
+		}
+
+		DEBUG_GC( ">>> allocated database %p\n", ptr );
+		RTYPEDDATA_DATA( self ) = ptr;
+
+		ptr->path = rb_obj_freeze( rb_obj_dup(path) );
+		ptr->config = rb_obj_freeze( config );
+	} else {
+		rb_raise( rb_eRuntimeError, "cannot reinit database" );
+	}
+
+	rb_call_super( 0, 0 );
+
+	return Qtrue;
+}
+
+
+/*
+ * call-seq:
+ *    database.config()   -> config
+ *
+ * Return the Ladybug::Config that reflects the config options the database
+ * was created with.
+ *
+ */
+static VALUE
+rlbug_database_config( VALUE self )
+{
+	rlbug_database *ptr = CHECK_DATABASE( self );
+	return ptr->config;
+}
+
+
+
+/*
+ * call-seq:
+ *    database.path()   -> string or nil
+ *
+ * Return the path the database was created with, or +nil+ if it was
+ * created in memory.
+ *
+ */
+static VALUE
+rlbug_database_path( VALUE self )
+{
+	rlbug_database *ptr = CHECK_DATABASE( self );
+
+	if ( RSTRING_LEN(ptr->path) == 0 ) {
+		return Qnil;
+	} else {
+		return ptr->path;
+	}
+}
+
+
+void
+rlbug_init_database( void )
+{
+	rlbug_cLadybugDatabase = rb_define_class_under( rlbug_mLadybug, "Database", rb_cObject );
+
+	rb_define_alloc_func( rlbug_cLadybugDatabase, rlbug_database_s_allocate );
+
+	rb_define_method( rlbug_cLadybugDatabase, "initialize", rlbug_database_initialize, -1 );
+
+	rb_define_method( rlbug_cLadybugDatabase, "config", rlbug_database_config, 0 );
+	rb_define_method( rlbug_cLadybugDatabase, "path", rlbug_database_path, 0 );
+
+	rb_require( "ladybug/database" );
+}

data/ext/ladybug_ext/extconf.rb

@@ -0,0 +1,20 @@
+#!/usr/bin/env ruby
+
+require 'rbconfig'
+require 'mkmf'
+
+dir_config( 'ladybug' )
+
+have_library( 'lbug' ) or
+	abort "No ladybug library!"
+
+have_header( 'lbug.h' ) or
+	abort "No lbug.h header!"
+have_header( 'ruby/thread.h' ) or
+	abort "Your Ruby is too old!"
+
+have_func( 'lbug_database_init', 'lbug.h' )
+
+create_header()
+create_makefile( 'ladybug_ext' )
+

data/ext/ladybug_ext/ladybug_ext.c

@@ -0,0 +1,158 @@
+/*
+ *  ladybug_ext.c - Ruby binding for LadybugDB.
+ *
+ *  Authors:
+ *    * Michael Granger <ged@FaerieMUD.org>
+ *
+ *  Refs:
+ *  - https://docs.ladybugdb.com
+ *
+ */
+
+#include "ladybug_ext.h"
+
+VALUE rlbug_mLadybug;
+
+VALUE rlbug_eError;
+VALUE rlbug_eDatabaseError;
+VALUE rlbug_eConnectionError;
+VALUE rlbug_eQueryError;
+VALUE rlbug_eFinishedError;
+
+VALUE rlbug_rb_cDate;
+VALUE rlbug_rb_cOstruct;
+
+
+/* --------------------------------------------------------------
+ * Logging Functions
+ * -------------------------------------------------------------- */
+
+/*
+ * Log a message to the given +context+ object's logger.
+ */
+void
+#if HAVE_STDARG_PROTOTYPES
+rlbug_log_obj( VALUE context, const char *level, const char *fmt, ... )
+#else
+rlbug_log_obj( VALUE context, const char *level, const char *fmt, va_dcl )
+#endif
+{
+	char buf[BUFSIZ];
+	va_list	args;
+	VALUE logger = Qnil;
+	VALUE message = Qnil;
+
+	va_init_list( args, fmt );
+	vsnprintf( buf, BUFSIZ, fmt, args );
+	message = rb_str_new2( buf );
+
+	logger = rb_funcall( context, rb_intern("log"), 0 );
+	rb_funcall( logger, rb_intern(level), 1, message );
+
+	va_end( args );
+}
+
+
+/*
+ * Log a message to the global logger.
+ */
+void
+#if HAVE_STDARG_PROTOTYPES
+rlbug_log( const char *level, const char *fmt, ... )
+#else
+rlbug_log( const char *level, const char *fmt, va_dcl )
+#endif
+{
+	char buf[BUFSIZ];
+	va_list	args;
+	VALUE logger = Qnil;
+	VALUE message = Qnil;
+
+	va_init_list( args, fmt );
+	vsnprintf( buf, BUFSIZ, fmt, args );
+	message = rb_str_new2( buf );
+
+	logger = rb_funcall( rlbug_mLadybug, rb_intern("logger"), 0 );
+	rb_funcall( logger, rb_intern(level), 1, message );
+
+	va_end( args );
+}
+
+
+
+/* --------------------------------------------------------------
+ * Module methods
+ * -------------------------------------------------------------- */
+
+/*
+ * call-seq:
+ *    Ladybug.ladybug_version   -> string
+ *
+ * Return the version of the underlying LadybugDB library.
+ *
+ */
+static VALUE
+rlbug_s_ladybug_version( VALUE _ )
+{
+	const char *version = lbug_get_version();
+
+	return rb_str_new2( version );
+}
+
+
+/*
+ * call-seq:
+ *    Ladybug.storage_version   -> integer
+ *
+ * Return the storage version used by the underlying library.
+ *
+ */
+static VALUE
+rlbug_s_storage_version( VALUE _ )
+{
+	const unsigned long long version = lbug_get_storage_version();
+
+	return ULONG2NUM( version );
+}
+
+
+/*
+ * ladybug extension init function
+ */
+void
+Init_ladybug_ext( void )
+{
+	rb_require( "date" );
+	rlbug_rb_cDate = rb_const_get( rb_cObject, rb_intern("Date") );
+
+	rb_require( "ostruct" );
+	rlbug_rb_cOstruct = rb_const_get( rb_cObject, rb_intern("OpenStruct") );
+
+	/*
+	 * Document-module: Ladybug
+	 *
+	 * The top level namespace for Ladybug classes.
+	 */
+	rlbug_mLadybug = rb_define_module( "Ladybug" );
+
+	rb_define_singleton_method( rlbug_mLadybug, "ladybug_version", rlbug_s_ladybug_version, 0 );
+	rb_define_singleton_method( rlbug_mLadybug, "storage_version", rlbug_s_storage_version, 0 );
+
+	rlbug_eError = rb_define_class_under( rlbug_mLadybug, "Error", rb_eRuntimeError );
+	rlbug_eDatabaseError = rb_define_class_under( rlbug_mLadybug, "DatabaseError", rlbug_eError );
+	rlbug_eConnectionError = rb_define_class_under( rlbug_mLadybug, "ConnectionError", rlbug_eError );
+	rlbug_eQueryError = rb_define_class_under( rlbug_mLadybug, "QueryError", rlbug_eError );
+	rlbug_eFinishedError = rb_define_class_under( rlbug_mLadybug, "FinishedError", rlbug_eError );
+
+	rb_require( "ladybug" );
+
+	rlbug_init_database();
+	rlbug_init_config();
+	rlbug_init_connection();
+	rlbug_init_prepared_statement();
+	rlbug_init_result();
+	rlbug_init_query_summary();
+	rlbug_init_node();
+	rlbug_init_rel();
+	rlbug_init_recursive_rel();
+}