ruby-ladybug 0.1.0

data/ext/ladybug_ext/types.c

@@ -0,0 +1,619 @@
+/*
+ *  types.c - Data type conversion functions
+ *
+ */
+
+#include "lbug.h"
+#include "ladybug_ext.h"
+#include "ruby/internal/intern/array.h"
+#include "ruby/internal/intern/hash.h"
+#include "ruby/internal/intern/object.h"
+
+
+#define CONVERT_CHECK( TYPE, CONVERSION ) \
+	do { if ( (CONVERSION) != LbugSuccess ) {\
+		rb_raise( rb_eTypeError, "couldn't convert " #TYPE ); }\
+	} while (0)
+
+
+static VALUE
+rlbug_convert_bool( lbug_value *value )
+{
+	bool typed_value;
+
+	CONVERT_CHECK( LBUG_BOOL, lbug_value_get_bool(value, &typed_value) );
+
+	return typed_value ? Qtrue : Qfalse;
+}
+
+
+static VALUE
+rlbug_convert_int64( lbug_value *value )
+{
+	int64_t typed_value;
+
+	CONVERT_CHECK( LBUG_INT64, lbug_value_get_int64(value, &typed_value) );
+
+	return LL2NUM( typed_value );
+}
+
+
+static VALUE
+rlbug_convert_int32( lbug_value *value )
+{
+	int32_t typed_value;
+
+	CONVERT_CHECK( LBUG_INT32, lbug_value_get_int32(value, &typed_value) );
+
+	return INT2FIX( typed_value );
+}
+
+
+static VALUE
+rlbug_convert_int16( lbug_value *value )
+{
+	int16_t typed_value;
+
+	CONVERT_CHECK( LBUG_INT16, lbug_value_get_int16(value, &typed_value) );
+
+	return INT2FIX( typed_value );
+}
+
+
+static VALUE
+rlbug_convert_int8( lbug_value *value )
+{
+	int8_t typed_value;
+
+	CONVERT_CHECK( LBUG_INT8, lbug_value_get_int8(value, &typed_value) );
+
+	return INT2FIX( typed_value );
+}
+
+
+static VALUE
+rlbug_convert_uint64( lbug_value *value )
+{
+	uint64_t typed_value;
+
+	CONVERT_CHECK( LBUG_UINT64, lbug_value_get_uint64(value, &typed_value) );
+
+	return ULL2NUM( typed_value );
+}
+
+
+static VALUE
+rlbug_convert_uint32( lbug_value *value )
+{
+	uint32_t typed_value;
+
+	CONVERT_CHECK( LBUG_UINT32, lbug_value_get_uint32(value, &typed_value) );
+
+	return UINT2NUM( typed_value );
+}
+
+
+static VALUE
+rlbug_convert_uint16( lbug_value *value )
+{
+	uint16_t typed_value;
+
+	CONVERT_CHECK( LBUG_UINT16, lbug_value_get_uint16(value, &typed_value) );
+
+	return UINT2NUM( typed_value );
+}
+
+
+static VALUE
+rlbug_convert_uint8( lbug_value *value )
+{
+	uint8_t typed_value;
+
+	CONVERT_CHECK( LBUG_UINT8, lbug_value_get_uint8(value, &typed_value) );
+
+	return UINT2NUM( typed_value );
+}
+
+
+static VALUE
+rlbug_convert_int128( lbug_value *value )
+{
+	lbug_int128_t typed_value;
+	char *int_string;
+	VALUE int_rb_string;
+
+	CONVERT_CHECK( LBUG_INT128, lbug_value_get_int128(value, &typed_value) );
+
+	lbug_int128_t_to_string( typed_value, &int_string );
+	int_rb_string = rb_str_new2( int_string );
+	lbug_destroy_string( int_string );
+
+	return rb_funcall( rb_mKernel, rb_intern("Integer"), 1, int_rb_string );
+}
+
+
+static VALUE
+rlbug_convert_double( lbug_value *value )
+{
+	double typed_value;
+
+	CONVERT_CHECK( LBUG_DOUBLE, lbug_value_get_double(value, &typed_value) );
+
+	return rb_float_new( typed_value );
+}
+
+
+static VALUE
+rlbug_convert_float( lbug_value *value )
+{
+	float typed_value;
+
+	CONVERT_CHECK( LBUG_FLOAT, lbug_value_get_float(value, &typed_value) );
+
+	return rb_float_new( typed_value );
+}
+
+
+static VALUE
+rlbug_convert_date( lbug_value *value )
+{
+	lbug_date_t typed_value;
+	struct tm time;
+	VALUE argv[3];
+
+	CONVERT_CHECK( LBUG_DATE, lbug_value_get_date(value, &typed_value) );
+
+	lbug_date_to_tm( typed_value, &time );
+
+	argv[0] = INT2FIX( time.tm_year + 1900 );
+	argv[1] = INT2FIX( time.tm_mon  + 1 );
+	argv[2] = INT2FIX( time.tm_mday );
+
+	return rb_class_new_instance( 3, argv, rlbug_rb_cDate );
+}
+
+
+static VALUE
+rlbug_convert_timestamp( lbug_value *value )
+{
+	lbug_timestamp_t typed_value;
+
+	CONVERT_CHECK( LBUG_TIMESTAMP, lbug_value_get_timestamp(value, &typed_value) );
+
+	return rb_funcall( rlbug_mLadybug, rb_intern("timestamp_from_timestamp_us"),
+		1, LL2NUM(typed_value.value) );
+}
+
+
+static VALUE
+rlbug_convert_timestamp_sec( lbug_value *value )
+{
+	lbug_timestamp_sec_t typed_value;
+
+	CONVERT_CHECK( LBUG_TIMESTAMP_SEC, lbug_value_get_timestamp_sec(value, &typed_value) );
+
+	return rb_funcall( rb_cTime, rb_intern("at"), 1, INT2FIX(typed_value.value) );
+}
+
+
+static VALUE
+rlbug_convert_timestamp_ms( lbug_value *value )
+{
+	lbug_timestamp_ms_t typed_value;
+
+	CONVERT_CHECK( LBUG_TIMESTAMP_MS, lbug_value_get_timestamp_ms(value, &typed_value) );
+	return rb_funcall( rlbug_mLadybug, rb_intern("timestamp_from_timestamp_ms"),
+		1, LL2NUM(typed_value.value) );
+}
+
+
+static VALUE
+rlbug_convert_timestamp_ns( lbug_value *value )
+{
+	lbug_timestamp_ns_t typed_value;
+
+	CONVERT_CHECK( LBUG_TIMESTAMP_NS, lbug_value_get_timestamp_ns(value, &typed_value) );
+
+	return rb_funcall( rlbug_mLadybug, rb_intern("timestamp_from_timestamp_ns"),
+		1, LL2NUM(typed_value.value) );
+}
+
+
+static VALUE
+rlbug_convert_timestamp_tz( lbug_value *value )
+{
+	lbug_timestamp_tz_t typed_value;
+
+	CONVERT_CHECK( LBUG_TIMESTAMP_TZ, lbug_value_get_timestamp_tz(value, &typed_value) );
+
+	return rb_funcall( rlbug_mLadybug, rb_intern("timestamp_from_timestamp_ms"),
+		2, LL2NUM(typed_value.value), INT2FIX(0) );
+}
+
+
+static VALUE
+rlbug_convert_decimal( lbug_value *value )
+{
+	char *decimal_as_string;
+	VALUE decimal_ruby_string;
+
+	CONVERT_CHECK( LBUG_DECIMAL, lbug_value_get_decimal_as_string(value, &decimal_as_string) );
+
+	decimal_ruby_string = rb_str_new2( decimal_as_string );
+	lbug_destroy_string( decimal_as_string );
+
+	return rb_funcall( rb_mKernel, rb_intern("Float"), 1, decimal_ruby_string );
+}
+
+
+static VALUE
+rlbug_convert_string( lbug_value *value )
+{
+	char *result_string;
+	VALUE rval;
+
+	CONVERT_CHECK( LBUG_STRING, lbug_value_get_string(value, &result_string) );
+
+	rval = rb_enc_str_new( result_string, strnlen(result_string, CHAR_MAX), rb_utf8_encoding() );
+	lbug_destroy_string( result_string );
+
+	return rb_obj_freeze( rval );
+}
+
+
+static VALUE
+rlbug_convert_uuid( lbug_value *value )
+{
+	char *result_string;
+	VALUE rval;
+
+	CONVERT_CHECK( LBUG_UUID, lbug_value_get_uuid(value, &result_string) );
+
+	rval = rb_enc_str_new( result_string, strnlen(result_string, CHAR_MAX), rb_utf8_encoding() );
+	rb_funcall( rval, rb_intern("downcase!"), 0 );
+	lbug_destroy_string( result_string );
+
+	return rb_obj_freeze( rval );
+}
+
+
+static VALUE
+rlbug_convert_interval( lbug_value *value )
+{
+	lbug_interval_t interval;
+	double interval_seconds = 0.0;
+	VALUE rval;
+
+	CONVERT_CHECK( LBUG_INTERVAL, lbug_value_get_interval(value, &interval) );
+	lbug_interval_to_difftime( interval, &interval_seconds );
+
+	rval = rb_float_new( interval_seconds );
+
+	return rval;
+}
+
+
+static VALUE
+rlbug_convert_blob( lbug_value *value )
+{
+	uint64_t blob_length = 0;
+	uint8_t *raw_blob;
+	VALUE rval;
+
+	CONVERT_CHECK( LBUG_BLOB, lbug_value_get_blob(value, &raw_blob, &blob_length) );
+
+	rval = rb_enc_str_new( (char *)raw_blob, blob_length, rb_ascii8bit_encoding() );
+
+	return rval;
+}
+
+
+static VALUE
+rlbug_convert_list( lbug_value *value )
+{
+	uint64_t count = 0;
+	lbug_value item_value;
+	lbug_logical_type item_type;
+	VALUE item;
+	VALUE rval = rb_ary_new();
+
+	if ( lbug_value_get_list_size(value, &count) != LbugSuccess ) {
+		rb_raise( rlbug_eError, "couldn't get list size!" );
+	}
+
+	for ( uint64_t i =  0 ; i < count ; i++ ) {
+		lbug_value_get_list_element( value, i, &item_value );
+		lbug_value_get_data_type( &item_value, &item_type );
+		item = rlbug_convert_logical_lbug_value_to_ruby( &item_type, &item_value );
+
+		rb_ary_push( rval, item );
+	}
+
+	return rval;
+}
+
+
+static VALUE
+rlbug_convert_array( lbug_value *value )
+{
+	uint64_t count = 0;
+	lbug_value item_value;
+	lbug_logical_type array_type, item_type;
+	VALUE item;
+	VALUE rval = rb_ary_new();
+
+	lbug_value_get_data_type( value, &array_type );
+
+	if ( lbug_data_type_get_num_elements_in_array(&array_type, &count) != LbugSuccess ) {
+		rb_raise( rlbug_eError, "couldn't get size of array type!" );
+	}
+
+	for ( uint64_t i =  0 ; i < count ; i++ ) {
+		lbug_value_get_list_element( value, i, &item_value );
+		lbug_value_get_data_type( &item_value, &item_type );
+		item = rlbug_convert_logical_lbug_value_to_ruby( &item_type, &item_value );
+
+		rb_ary_push( rval, item );
+	}
+
+	return rval;
+}
+
+
+static VALUE
+rlbug_convert_struct( lbug_value *value )
+{
+	uint64_t count = 0;
+	char *item_name;
+	lbug_value item_value;
+	lbug_logical_type item_type;
+	VALUE item, item_sym;
+	VALUE rval = rb_class_new_instance( 0, 0, rlbug_rb_cOstruct );
+
+	if ( lbug_value_get_struct_num_fields(value, &count) != LbugSuccess ) {
+		rb_raise( rlbug_eError, "couldn't fetch field count for a struct!" );
+	}
+
+	for ( uint64_t i =  0 ; i < count ; i++ ) {
+		lbug_value_get_struct_field_name( value, i, &item_name );
+		lbug_value_get_struct_field_value( value, i, &item_value );
+		lbug_value_get_data_type( &item_value, &item_type );
+		item = rlbug_convert_logical_lbug_value_to_ruby( &item_type, &item_value );
+		item_sym = rb_check_symbol_cstr( item_name, strnlen(item_name, CHAR_MAX),
+			rb_usascii_encoding() );
+
+		rb_funcall( rval, rb_intern("[]="), 2, item_sym, item );
+	}
+
+	return rval;
+}
+
+
+static VALUE
+rlbug_convert_map( lbug_value *map_value )
+{
+	uint64_t count = 0;
+	lbug_value key, value;
+	VALUE key_obj, value_obj;
+	VALUE rval = rb_hash_new();
+
+	if ( lbug_value_get_map_size(map_value, &count) != LbugSuccess ) {
+		rb_raise( rlbug_eError, "couldn't fetch map size!" );
+	}
+
+	for ( uint64_t i =  0 ; i < count ; i++ ) {
+		lbug_value_get_map_key( map_value, i, &key );
+		key_obj = rlbug_value_to_ruby( &key );
+
+		lbug_value_get_map_value( map_value, i, &value );
+		value_obj = rlbug_value_to_ruby( &value );
+
+		rb_hash_aset( rval, key_obj, value_obj );
+	}
+
+	return rval;
+}
+
+
+static VALUE
+rlbug_convert_node( lbug_value *value )
+{
+	uint64_t count = 0;
+	char *prop_name_str = NULL;
+	lbug_value id_value, label_value, prop_value_val;
+	VALUE id = Qnil,
+		label = Qnil,
+		prop_key = Qnil,
+		prop_val = Qnil,
+		properties = rb_hash_new();
+
+	lbug_node_val_get_id_val( value, &id_value );
+	id = rlbug_value_to_ruby( &id_value );
+
+	lbug_node_val_get_label_val( value, &label_value );
+	label = rlbug_value_to_ruby( &label_value );
+
+	if ( lbug_node_val_get_property_size(value, &count) != LbugSuccess ) {
+		rb_raise( rlbug_eError, "couldn't fetch property count for a node!" );
+	}
+
+	for ( uint64_t i =  0 ; i < count ; i++ ) {
+		lbug_node_val_get_property_name_at( value, i, &prop_name_str );
+		prop_key = ID2SYM( rb_intern(prop_name_str) );
+		// :TODO: lbug_destroy_string?
+
+		lbug_node_val_get_property_value_at( value, i, &prop_value_val );
+		prop_val = rlbug_value_to_ruby( &prop_value_val );
+
+		rb_hash_aset( properties, prop_key, prop_val );
+	}
+
+	const VALUE init_argv[3] = {id, label, properties};
+	return rb_class_new_instance_kw( 3, init_argv, rlbug_cLadybugNode, RB_PASS_KEYWORDS );
+}
+
+
+static VALUE
+rlbug_convert_rel( lbug_value *value )
+{
+	uint64_t count = 0;
+	char *prop_name_str = NULL;
+	lbug_value id_value, src_id_value, dst_id_value, label_value, prop_value_val;
+	VALUE id = Qnil,
+		src_id = Qnil,
+		dst_id = Qnil,
+		label = Qnil,
+		prop_key = Qnil,
+		prop_val = Qnil,
+		properties = rb_hash_new();
+
+	lbug_rel_val_get_id_val( value, &id_value );
+	id = rlbug_value_to_ruby( &id_value );
+
+	lbug_rel_val_get_src_id_val( value, &src_id_value );
+	src_id = rlbug_value_to_ruby( &src_id_value );
+
+	lbug_rel_val_get_dst_id_val( value, &dst_id_value );
+	dst_id = rlbug_value_to_ruby( &dst_id_value );
+
+	lbug_rel_val_get_label_val( value, &label_value );
+	label = rlbug_value_to_ruby( &label_value );
+
+	if ( lbug_rel_val_get_property_size(value, &count) != LbugSuccess ) {
+		rb_raise( rlbug_eError, "couldn't fetch property count for a rel!" );
+	}
+
+	for ( uint64_t i =  0 ; i < count ; i++ ) {
+		lbug_rel_val_get_property_name_at( value, i, &prop_name_str );
+		prop_key = ID2SYM( rb_intern(prop_name_str) );
+		// :TODO: lbug_destroy_string?
+
+		lbug_rel_val_get_property_value_at( value, i, &prop_value_val );
+		prop_val = rlbug_value_to_ruby( &prop_value_val );
+
+		rb_hash_aset( properties, prop_key, prop_val );
+	}
+
+	const VALUE init_argv[5] = {id, src_id, dst_id, label, properties};
+	return rb_class_new_instance_kw( 5, init_argv, rlbug_cLadybugRel, RB_PASS_KEYWORDS );
+}
+
+
+static VALUE
+rlbug_convert_recursive_rel( lbug_value *value )
+{
+	lbug_value node_list, rel_list;
+	VALUE argv[2];
+
+	if ( lbug_value_get_recursive_rel_node_list(value, &node_list) != LbugSuccess ) {
+		rb_raise( rlbug_eError, "couldn't fetch node list for recursive rel" );
+	}
+	if ( lbug_value_get_recursive_rel_rel_list(value, &rel_list) != LbugSuccess ) {
+		rb_raise( rlbug_eError, "couldn't fetch rel list for recursive rel" );
+	}
+
+	argv[0] = rlbug_value_to_ruby( &node_list );
+	argv[1] = rlbug_value_to_ruby( &rel_list );
+
+	return rb_class_new_instance( 2, argv, rlbug_cLadybugRecursiveRel );
+}
+
+
+static VALUE
+rlbug_convert_internal_id( lbug_value *value )
+{
+	lbug_internal_id_t internal_id;
+	VALUE rval = rb_ary_new_capa( 2 );
+
+	CONVERT_CHECK( LBUG_INTERNAL_ID, lbug_value_get_internal_id(value, &internal_id) );
+
+	// TODO: This is almost certainly not the RIGHT way to convert this, but it
+	// at least will allow valid comparison.
+	rb_ary_store( rval, 0, ULONG2NUM(internal_id.table_id) );
+	rb_ary_store( rval, 1, ULONG2NUM(internal_id.offset) );
+
+	rb_obj_freeze( rval );
+
+	return rval;
+}
+
+
+VALUE
+rlbug_convert_lbug_value_to_ruby( lbug_data_type_id type_id, lbug_value *value )
+{
+	if ( lbug_value_is_null(value) ) {
+		return Qnil;
+	}
+
+	switch( type_id ) {
+		case LBUG_BOOL: return rlbug_convert_bool( value );
+
+		case LBUG_INT64: return rlbug_convert_int64( value );
+		case LBUG_INT32: return rlbug_convert_int32( value );
+		case LBUG_INT16: return rlbug_convert_int16( value );
+		case LBUG_INT8: return rlbug_convert_int8( value );
+		case LBUG_UINT64: return rlbug_convert_uint64( value );
+		case LBUG_UINT32: return rlbug_convert_uint32( value );
+		case LBUG_UINT16: return rlbug_convert_uint16( value );
+		case LBUG_UINT8: return rlbug_convert_uint8( value );
+		case LBUG_INT128: return rlbug_convert_int128( value );
+
+		// Serials just come out as int64s
+		case LBUG_SERIAL: return rlbug_convert_int64( value );
+
+		case LBUG_DOUBLE: return rlbug_convert_double( value );
+		case LBUG_FLOAT: return rlbug_convert_float( value );
+
+		case LBUG_DATE: return rlbug_convert_date( value );
+
+		case LBUG_TIMESTAMP: return rlbug_convert_timestamp( value );
+		case LBUG_TIMESTAMP_SEC: return rlbug_convert_timestamp_sec( value );
+		case LBUG_TIMESTAMP_MS: return rlbug_convert_timestamp_ms( value );
+		case LBUG_TIMESTAMP_NS: return rlbug_convert_timestamp_ns( value );
+		case LBUG_TIMESTAMP_TZ: return rlbug_convert_timestamp_tz( value );
+
+		case LBUG_DECIMAL: return rlbug_convert_decimal( value );
+
+		case LBUG_STRING: return rlbug_convert_string( value );
+		case LBUG_UUID: return rlbug_convert_uuid( value );
+
+		case LBUG_INTERVAL: return rlbug_convert_interval( value );
+		case LBUG_BLOB: return rlbug_convert_blob( value );
+
+		case LBUG_LIST: return rlbug_convert_list( value );
+		case LBUG_ARRAY: return rlbug_convert_array( value );
+
+		case LBUG_STRUCT: return rlbug_convert_struct( value );
+
+		case LBUG_MAP: return rlbug_convert_map( value );
+
+		case LBUG_NODE: return rlbug_convert_node( value );
+		case LBUG_REL: return rlbug_convert_rel( value );
+		case LBUG_RECURSIVE_REL: return rlbug_convert_recursive_rel( value );
+		case LBUG_INTERNAL_ID: return rlbug_convert_internal_id( value );
+
+		case LBUG_UNION:
+		case LBUG_POINTER:
+
+		// Fallthrough
+		default:
+			rb_raise( rb_eTypeError, "Unhandled lbug data type: %d", type_id );
+	}
+}
+
+
+VALUE
+rlbug_convert_logical_lbug_value_to_ruby( lbug_logical_type *data_type, lbug_value *value )
+{
+	lbug_data_type_id type_id = lbug_data_type_get_id( data_type );
+	return rlbug_convert_lbug_value_to_ruby( type_id, value );
+}
+
+
+VALUE
+rlbug_value_to_ruby( lbug_value *value )
+{
+	lbug_logical_type lbug_type;
+	lbug_value_get_data_type( value, &lbug_type );
+	return rlbug_convert_logical_lbug_value_to_ruby( &lbug_type, value );
+}

data/lib/ladybug/config.rb

@@ -0,0 +1,70 @@
+### -*- ruby -*-
+
+require 'loggability'
+
+require 'ladybug' unless defined?( Ladybug )
+
+
+# Kùzu system config options container class.
+class Ladybug::Config
+	extend Loggability
+
+
+	# The detail fragments that make up the #inspect output, in the order
+	# they should appear.
+	INSPECT_PARTS = [
+		"buffer_pool_size:%d",
+		"max_num_threads:%d",
+		"enable_compression:%s",
+		"read_only:%s",
+		"max_db_size:%d",
+		"auto_checkpoint:%s",
+		"checkpoint_threshold:%d"
+	].freeze
+
+	# The printf pattern used for #inspect output
+	INSPECT_FORMAT = ' ' + INSPECT_PARTS.join( ' ' )
+
+
+	# Loggability API -- log to the Ladybug logger
+	log_to :ladybug
+
+
+	### Return a default Config object with the specified +options+ overridden. If
+	### +source_options+ is a Ladybug::Config, the returned object will be a clone of
+	### it with the +options+ applied.
+	def self::from_options( source_options=nil, **options )
+		config = source_options.dup || new()
+
+		config.set( **options )
+
+		return config
+	end
+
+
+	### Set one or more +options+.
+	def set( **options )
+		options.each do |opt, val|
+			self.public_send( "#{opt}=", val )
+		end
+	end
+
+
+	### Return a human-readable representation of the object suitable for debugging.
+	def inspect
+		details = INSPECT_FORMAT % [
+			self.buffer_pool_size,
+			self.max_num_threads,
+			self.enable_compression,
+			self.read_only,
+			self.max_db_size,
+			self.auto_checkpoint,
+			self.checkpoint_threshold,
+		]
+
+		default = super
+		return default.sub( />/, details + '>' )
+	end
+
+
+end # class Ladybug::Config