ruby-kuzu 0.0.1

data/ext/kuzu_ext/connection.c

@@ -0,0 +1,310 @@
+/*
+ *  connection.c - Kuzu::Connection class
+ *
+ */
+
+#include "kuzu.h"
+#include "kuzu_ext.h"
+#include "ruby/thread.h"
+
+#define CHECK_CONNECTION(self) ((rkuzu_connection *)rb_check_typeddata((self), &rkuzu_connection_type))
+// #define DEBUG_GC(msg, ptr) fprintf( stderr, msg, ptr )
+#define DEBUG_GC(msg, ptr)
+
+
+VALUE rkuzu_cKuzuConnection;
+
+static void rkuzu_connection_free( void * );
+static void rkuzu_connection_mark( void * );
+
+static const rb_data_type_t rkuzu_connection_type = {
+	.wrap_struct_name = "Kuzu::Connection",
+	.function = {
+		.dfree = rkuzu_connection_free,
+		.dmark = rkuzu_connection_mark,
+	},
+	.data = NULL,
+};
+
+
+rkuzu_connection *
+rkuzu_get_connection( VALUE conn_obj )
+{
+	return CHECK_CONNECTION( conn_obj );
+}
+
+
+static rkuzu_connection *
+rkuzu_connection_alloc( void )
+{
+	rkuzu_connection *ptr = ALLOC( rkuzu_connection );
+
+	ptr->database = Qnil;
+	ptr->queries = rb_ary_new();
+	ptr->statements = rb_ary_new();
+
+	return ptr;
+}
+
+
+static void
+rkuzu_connection_free( void *ptr )
+{
+	rkuzu_connection *conn_s = (rkuzu_connection *)ptr;
+
+	if ( ptr ) {
+		DEBUG_GC( ">>> freeing connection %p\n", ptr );
+
+		kuzu_connection_destroy( &conn_s->conn );
+
+		xfree( ptr );
+		ptr = NULL;
+	}
+}
+
+
+static void
+rkuzu_connection_mark( void *ptr )
+{
+	rkuzu_connection *conn_s = (rkuzu_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
+rkuzu_connection_s_allocate( VALUE klass )
+{
+	return TypedData_Wrap_Struct( klass, &rkuzu_connection_type, NULL );
+}
+
+
+
+/*
+ * call-seq:
+ *    new( database )   -> connection
+ *
+ * Create a Kuzu::Connection to the specified +database+.
+ *
+ */
+static VALUE
+rkuzu_connection_initialize( VALUE self, VALUE database )
+{
+	rkuzu_connection *ptr = CHECK_CONNECTION( self );
+
+	if ( !ptr ) {
+		rkuzu_database *dbobject = rkuzu_get_database( database );
+		ptr = rkuzu_connection_alloc();
+
+		if ( kuzu_connection_init(&dbobject->db, &ptr->conn) != KuzuSuccess ) {
+			xfree( ptr );
+			ptr = NULL;
+			rb_raise( rkuzu_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 {
+	kuzu_connection *conn;
+	const char *query_s;
+	kuzu_query_result *result;
+};
+
+
+static void *
+rkuzu_connection_do_query_without_gvl( void *ptr )
+{
+	struct query_call *qcall = (struct query_call *)ptr;
+	kuzu_state state;
+
+	state = kuzu_connection_query( qcall->conn, qcall->query_s, qcall->result );
+
+	return (void *)state;
+}
+
+
+static void
+rkuzu_connection_cancel_query( void *ptr )
+{
+	kuzu_connection *conn = (kuzu_connection *)ptr;
+	kuzu_connection_interrupt( conn );
+}
+
+
+static kuzu_query_result
+rkuzu_connection_do_query( VALUE self, VALUE query )
+{
+	rkuzu_connection *conn = CHECK_CONNECTION( self );
+	const char *query_s = StringValueCStr( query );
+	kuzu_query_result result;
+	kuzu_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(
+		rkuzu_connection_do_query_without_gvl, (void *)&qcall,
+		rkuzu_connection_cancel_query, (void *)&conn->conn );
+
+	query_state = (kuzu_state)result_ptr;
+
+	if ( query_state != KuzuSuccess ) {
+		char *err_detail = kuzu_query_result_get_error_message( &result );
+		char errmsg[ 4096 ] = "\0";
+
+		snprintf( errmsg, 4096, "Could not execute query `%s': %s.", query_s, err_detail );
+
+		kuzu_destroy_string( err_detail );
+		kuzu_query_result_destroy( &result );
+
+		rb_raise( rkuzu_eQueryError, "%s", errmsg );
+	}
+
+	return *qcall.result;
+}
+
+
+
+static VALUE
+rkuzu_connection__query( VALUE self, VALUE query )
+{
+	kuzu_query_result result = rkuzu_connection_do_query( self, query );
+	return rkuzu_result_from_query( rkuzu_cKuzuResult, self, query, result );
+}
+
+
+/*
+ * call-seq:
+ *    connection.query!( query_string )
+ *
+ * Execute the given +query_string+ and return `true` if the query was
+ * successful.
+ *
+ */
+static VALUE
+rkuzu_connection_query_bang( VALUE self, VALUE query )
+{
+	kuzu_query_result result = rkuzu_connection_do_query( self, query );
+	return kuzu_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
+rkuzu_connection_max_num_threads_for_exec( VALUE self )
+{
+	rkuzu_connection *ptr = CHECK_CONNECTION( self );
+	uint64_t count;
+
+	if ( kuzu_connection_get_max_num_thread_for_exec( &ptr->conn, &count ) != KuzuSuccess ) {
+		rb_raise( rkuzu_eError, "kuzu_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
+rkuzu_connection_max_num_threads_for_exec_eq( VALUE self, VALUE count )
+{
+	rkuzu_connection *ptr = CHECK_CONNECTION( self );
+	uint64_t thread_count = NUM2ULONG( count );
+
+	if ( kuzu_connection_set_max_num_thread_for_exec( &ptr->conn, thread_count ) != KuzuSuccess ) {
+		rb_raise( rkuzu_eError, "kuzu_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
+rkuzu_connection_query_timeout_eq( VALUE self, VALUE timeout )
+{
+	rkuzu_connection *ptr = CHECK_CONNECTION( self );
+	uint64_t timeout_in_ms = NUM2ULONG( timeout );
+
+	if ( kuzu_connection_set_query_timeout( &ptr->conn, timeout_in_ms ) != KuzuSuccess ) {
+		rb_raise( rkuzu_eError, "kuzu_connection_set_query_timeout failed" );
+	}
+
+	return Qtrue;
+}
+
+
+
+/*
+ * Document-class: Kuzu::Connection
+ */
+void
+rkuzu_init_connection( void )
+{
+#ifdef FOR_RDOC
+	rkuzu_mKuzu = rb_define_module( "Kuzu" );
+#endif
+
+	rkuzu_cKuzuConnection = rb_define_class_under( rkuzu_mKuzu, "Connection", rb_cObject );
+
+	rb_define_alloc_func( rkuzu_cKuzuConnection, rkuzu_connection_s_allocate );
+
+	rb_define_protected_method( rkuzu_cKuzuConnection, "initialize", rkuzu_connection_initialize, 1 );
+
+	rb_define_protected_method( rkuzu_cKuzuConnection, "_query", rkuzu_connection__query, 1 );
+	rb_define_method( rkuzu_cKuzuConnection, "query!", rkuzu_connection_query_bang, 1 );
+	rb_define_alias( rkuzu_cKuzuConnection, "run", "query!" );
+
+	rb_define_method( rkuzu_cKuzuConnection, "max_num_threads_for_exec",
+		rkuzu_connection_max_num_threads_for_exec, 0 );
+	rb_define_method( rkuzu_cKuzuConnection, "max_num_threads_for_exec=",
+		rkuzu_connection_max_num_threads_for_exec_eq, 1 );
+
+	rb_define_method( rkuzu_cKuzuConnection, "query_timeout=", rkuzu_connection_query_timeout_eq, 1 );
+
+	rb_require( "kuzu/connection" );
+}

data/ext/kuzu_ext/database.c

@@ -0,0 +1,196 @@
+/*
+ *  database.c - Kuzu::Database class
+ */
+
+#include "kuzu_ext.h"
+
+#define CHECK_DATABASE(self) ((rkuzu_database*)rb_check_typeddata((self), &rkuzu_database_type))
+// #define DEBUG_GC(msg, ptr) fprintf( stderr, msg, ptr )
+#define DEBUG_GC(msg, ptr)
+
+
+VALUE rkuzu_cKuzuDatabase;
+
+static void rkuzu_database_free( void * );
+static void rkuzu_database_mark( void * );
+
+static const rb_data_type_t rkuzu_database_type = {
+	.wrap_struct_name = "Kuzu::Database",
+	.function = {
+		.dmark = rkuzu_database_mark,
+		.dfree = rkuzu_database_free,
+	},
+	.data = NULL,
+};
+
+
+rkuzu_database *
+rkuzu_get_database( VALUE obj )
+{
+	return CHECK_DATABASE( obj );
+}
+
+
+/*
+ * Struct allocation/init function.
+ */
+static rkuzu_database *
+rkuzu_database_alloc( void )
+{
+	rkuzu_database *ptr = ALLOC( rkuzu_database );
+
+	ptr->path = Qnil;
+	ptr->config = Qnil;
+
+	return ptr;
+}
+
+
+/*
+ * Free function
+ */
+static void
+rkuzu_database_free( void *ptr )
+{
+	if ( ptr ) {
+		DEBUG_GC( ">>> freeing database %p\n", ptr );
+		rkuzu_database *database_s = (rkuzu_database *)ptr;
+
+		kuzu_database_destroy( &database_s->db );
+
+		database_s->path = Qnil;
+		database_s->config = Qnil;
+
+		xfree( ptr );
+		ptr = NULL;
+	}
+}
+
+
+/*
+ * Mark function
+ */
+static void
+rkuzu_database_mark( void *ptr )
+{
+	rkuzu_database *database_s = (rkuzu_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
+rkuzu_database_s_allocate( VALUE klass )
+{
+	return TypedData_Wrap_Struct( klass, &rkuzu_database_type, NULL );
+}
+
+
+/*
+ * call-seq:
+ *    database.new( path, **options )   -> database
+ *
+ * Create a new Datbase using the given +path+ and +options+.
+ *
+ */
+static VALUE
+rkuzu_database_initialize( int argc, VALUE *argv, VALUE self )
+{
+	rkuzu_database *ptr = CHECK_DATABASE( self );
+
+	if ( !ptr ) {
+		VALUE path, options, config;
+		VALUE config_argv[1];
+		kuzu_system_config *sysconfig;
+		char *database_path;
+
+		rb_scan_args( argc, argv, "1:", &path, &options );
+		config_argv[0] = options;
+		config = rb_funcallv_public_kw( rkuzu_cKuzuConfig, rb_intern("from_options"), 1,
+			config_argv, RB_PASS_KEYWORDS );
+
+		sysconfig = rkuzu_get_config( config );
+		database_path = StringValueCStr( path );
+
+		ptr = rkuzu_database_alloc();
+		if ( kuzu_database_init(database_path, *sysconfig, &ptr->db) != KuzuSuccess ) {
+			xfree( ptr );
+			ptr = NULL;
+
+			rb_raise( rkuzu_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 Kuzu::Config that reflects the config options the database
+ * was created with.
+ *
+ */
+static VALUE
+rkuzu_database_config( VALUE self )
+{
+	rkuzu_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
+rkuzu_database_path( VALUE self )
+{
+	rkuzu_database *ptr = CHECK_DATABASE( self );
+
+	if ( RSTRING_LEN(ptr->path) == 0 ) {
+		return Qnil;
+	} else {
+		return ptr->path;
+	}
+}
+
+
+void
+rkuzu_init_database( void )
+{
+	rkuzu_cKuzuDatabase = rb_define_class_under( rkuzu_mKuzu, "Database", rb_cObject );
+
+	rb_define_alloc_func( rkuzu_cKuzuDatabase, rkuzu_database_s_allocate );
+
+	rb_define_method( rkuzu_cKuzuDatabase, "initialize", rkuzu_database_initialize, -1 );
+
+	rb_define_method( rkuzu_cKuzuDatabase, "config", rkuzu_database_config, 0 );
+	rb_define_method( rkuzu_cKuzuDatabase, "path", rkuzu_database_path, 0 );
+
+	rb_require( "kuzu/database" );
+}

data/ext/kuzu_ext/extconf.rb

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

data/ext/kuzu_ext/kuzu_ext.c

@@ -0,0 +1,158 @@
+/*
+ *  kuzu_ext.c - Ruby binding for Kùzu
+ *
+ *  Authors:
+ *    * Michael Granger <ged@FaerieMUD.org>
+ *
+ *  Refs:
+ *  - https://docs.kuzudb.com/
+ *
+ */
+
+#include "kuzu_ext.h"
+
+VALUE rkuzu_mKuzu;
+
+VALUE rkuzu_eError;
+VALUE rkuzu_eDatabaseError;
+VALUE rkuzu_eConnectionError;
+VALUE rkuzu_eQueryError;
+VALUE rkuzu_eFinishedError;
+
+VALUE rkuzu_rb_cDate;
+VALUE rkuzu_rb_cOstruct;
+
+
+/* --------------------------------------------------------------
+ * Logging Functions
+ * -------------------------------------------------------------- */
+
+/*
+ * Log a message to the given +context+ object's logger.
+ */
+void
+#if HAVE_STDARG_PROTOTYPES
+rkuzu_log_obj( VALUE context, const char *level, const char *fmt, ... )
+#else
+rkuzu_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
+rkuzu_log( const char *level, const char *fmt, ... )
+#else
+rkuzu_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( rkuzu_mKuzu, rb_intern("logger"), 0 );
+	rb_funcall( logger, rb_intern(level), 1, message );
+
+	va_end( args );
+}
+
+
+
+/* --------------------------------------------------------------
+ * Module methods
+ * -------------------------------------------------------------- */
+
+/*
+ * call-seq:
+ *    Kuzu.kuzu_version   -> string
+ *
+ * Return the version of the underlying Kuzu library.
+ *
+ */
+static VALUE
+rkuzu_s_kuzu_version( VALUE _ )
+{
+	const char *version = kuzu_get_version();
+
+	return rb_str_new2( version );
+}
+
+
+/*
+ * call-seq:
+ *    Kuzu.storage_version   -> integer
+ *
+ * Return the storage version used by the underlying library.
+ *
+ */
+static VALUE
+rkuzu_s_storage_version( VALUE _ )
+{
+	const unsigned long long version = kuzu_get_storage_version();
+
+	return ULONG2NUM( version );
+}
+
+
+/*
+ * Kuzu extension init function
+ */
+void
+Init_kuzu_ext( void )
+{
+	rb_require( "date" );
+	rkuzu_rb_cDate = rb_const_get( rb_cObject, rb_intern("Date") );
+
+	rb_require( "ostruct" );
+	rkuzu_rb_cOstruct = rb_const_get( rb_cObject, rb_intern("OpenStruct") );
+
+	/*
+	 * Document-module: Kuzu
+	 *
+	 * The top level namespace for Kuzu classes.
+	 */
+	rkuzu_mKuzu = rb_define_module( "Kuzu" );
+
+	rb_define_singleton_method( rkuzu_mKuzu, "kuzu_version", rkuzu_s_kuzu_version, 0 );
+	rb_define_singleton_method( rkuzu_mKuzu, "storage_version", rkuzu_s_storage_version, 0 );
+
+	rkuzu_eError = rb_define_class_under( rkuzu_mKuzu, "Error", rb_eRuntimeError );
+	rkuzu_eDatabaseError = rb_define_class_under( rkuzu_mKuzu, "DatabaseError", rkuzu_eError );
+	rkuzu_eConnectionError = rb_define_class_under( rkuzu_mKuzu, "ConnectionError", rkuzu_eError );
+	rkuzu_eQueryError = rb_define_class_under( rkuzu_mKuzu, "QueryError", rkuzu_eError );
+	rkuzu_eFinishedError = rb_define_class_under( rkuzu_mKuzu, "FinishedError", rkuzu_eError );
+
+	rb_require( "kuzu" );
+
+	rkuzu_init_database();
+	rkuzu_init_config();
+	rkuzu_init_connection();
+	rkuzu_init_prepared_statement();
+	rkuzu_init_result();
+	rkuzu_init_query_summary();
+	rkuzu_init_node();
+	rkuzu_init_rel();
+	rkuzu_init_recursive_rel();
+}