duckdb 0.2.8.0 → 0.3.2.0

data/ext/duckdb/database.c

@@ -7,28 +7,26 @@ static void deallocate(void * ctx);
 static VALUE allocate(VALUE klass);
 static VALUE duckdb_database_s_open(int argc, VALUE *argv, VALUE cDuckDBDatabase);
 static VALUE duckdb_database_s_open_ext(int argc, VALUE *argv, VALUE cDuckDBDatabase);
+static VALUE duckdb_database_connect(VALUE self);
+static VALUE duckdb_database_close(VALUE self);
 
-static void close_database(rubyDuckDB *p)
-{
+static void close_database(rubyDuckDB *p) {
     duckdb_close(&(p->db));
 }
 
-static void deallocate(void * ctx)
-{
+static void deallocate(void * ctx) {
     rubyDuckDB *p = (rubyDuckDB *)ctx;
 
     close_database(p);
     xfree(p);
 }
 
-static VALUE allocate(VALUE klass)
-{
+static VALUE allocate(VALUE klass) {
     rubyDuckDB *ctx = xcalloc((size_t)1, sizeof(rubyDuckDB));
     return Data_Wrap_Struct(klass, NULL, deallocate, ctx);
 }
 
-static VALUE duckdb_database_s_open(int argc, VALUE *argv, VALUE cDuckDBDatabase)
-{
+static VALUE duckdb_database_s_open(int argc, VALUE *argv, VALUE cDuckDBDatabase) {
     rubyDuckDB *ctx;
     VALUE obj;
 
@@ -50,8 +48,7 @@ static VALUE duckdb_database_s_open(int argc, VALUE *argv, VALUE cDuckDBDatabase
 }
 
 #ifdef HAVE_DUCKDB_OPEN_EXT
-static VALUE duckdb_database_s_open_ext(int argc, VALUE *argv, VALUE cDuckDBDatabase)
-{
+static VALUE duckdb_database_s_open_ext(int argc, VALUE *argv, VALUE cDuckDBDatabase) {
     rubyDuckDB *ctx;
     VALUE obj;
     rubyDuckDBConfig *ctx_config;
@@ -86,8 +83,7 @@ static VALUE duckdb_database_s_open_ext(int argc, VALUE *argv, VALUE cDuckDBData
 }
 #endif /* HAVE_DUCKDB_OPEN_EXT */
 
-static VALUE duckdb_database_connect(VALUE self)
-{
+static VALUE duckdb_database_connect(VALUE self) {
     return create_connection(self);
 }
 
@@ -97,16 +93,14 @@ static VALUE duckdb_database_connect(VALUE self)
  *
  *  closes DuckDB database.
  */
-static VALUE duckdb_database_close(VALUE self)
-{
+static VALUE duckdb_database_close(VALUE self) {
     rubyDuckDB *ctx;
     Data_Get_Struct(self, rubyDuckDB, ctx);
     close_database(ctx);
     return self;
 }
 
-void init_duckdb_database(void)
-{
+void init_duckdb_database(void) {
     cDuckDBDatabase = rb_define_class_under(mDuckDB, "Database", rb_cObject);
     rb_define_alloc_func(cDuckDBDatabase, allocate);
     rb_define_singleton_method(cDuckDBDatabase, "_open", duckdb_database_s_open, -1);

data/ext/duckdb/duckdb.c

@@ -3,8 +3,7 @@
 VALUE mDuckDB;
 
 void
-Init_duckdb_native(void)
-{
+Init_duckdb_native(void) {
     mDuckDB = rb_define_module("DuckDB");
 
     init_duckdb_error();
@@ -12,13 +11,8 @@ Init_duckdb_native(void)
     init_duckdb_connection();
     init_duckdb_result();
     init_duckdb_prepared_statement();
-
-#ifdef HAVE_DUCKDB_VALUE_BLOB
-
     init_duckdb_blob();
 
-#endif /* HAVE_DUCKDB_VALUE_BLOB */
-
 #ifdef HAVE_DUCKDB_APPENDER_CREATE
 
     init_duckdb_appender();

data/ext/duckdb/error.c

@@ -2,7 +2,6 @@
 
 VALUE eDuckDBError;
 
-void init_duckdb_error(void)
-{
+void init_duckdb_error(void) {
     eDuckDBError = rb_define_class_under(mDuckDB, "Error", rb_eStandardError);
 }

data/ext/duckdb/extconf.rb

@@ -1,12 +1,33 @@
 require 'mkmf'
 
 dir_config('duckdb')
-if have_library('duckdb')
-  have_func('duckdb_value_blob', 'duckdb.h')
-  have_func('duckdb_bind_blob', 'duckdb.h')
-  have_func('duckdb_appender_create', 'duckdb.h')
-  have_func('duckdb_free', 'duckdb.h')
-  have_func('duckdb_create_config', 'duckdb.h')
-  have_func('duckdb_open_ext', 'duckdb.h')
-  create_makefile('duckdb/duckdb_native')
+
+raise 'duckdb library is not found. Install duckdb library file and header file.' unless have_library('duckdb')
+
+raise 'duckdb >= 0.2.9 is required. Install duckdb >= 0.2.9' unless have_func('duckdb_value_is_null', 'duckdb.h')
+
+if have_func('duckdb_nparams(NULL)', 'duckdb.h')
+  $defs << '-DHAVE_DUCKDB_NPARAMS_029'
+elsif have_func('duckdb_nparams(NULL, NULL)', 'duckdb.h')
+  $defs << '-DHAVE_DUCKDB_NPARAMS_028'
 end
+
+have_func('duckdb_appender_create', 'duckdb.h')
+have_func('duckdb_free', 'duckdb.h')
+
+have_func('duckdb_create_config', 'duckdb.h')
+have_func('duckdb_open_ext', 'duckdb.h')
+have_func('duckdb_prepare_error', 'duckdb.h')
+
+have_func('duckdb_append_date', 'duckdb.h')
+have_func('duckdb_append_interval', 'duckdb.h')
+have_func('duckdb_append_time', 'duckdb.h')
+have_func('duckdb_append_timestamp', 'duckdb.h')
+have_func('duckdb_append_hugeint', 'duckdb.h')
+
+have_func('duckdb_bind_date', 'duckdb.h')
+have_func('duckdb_bind_time', 'duckdb.h')
+have_func('duckdb_bind_timestamp', 'duckdb.h')
+have_func('duckdb_bind_interval', 'duckdb.h')
+
+create_makefile('duckdb/duckdb_native')

data/ext/duckdb/prepared_statement.c

@@ -2,22 +2,53 @@
 
 static VALUE cDuckDBPreparedStatement;
 
-static void deallocate(void *ctx)
-{
+static void deallocate(void *ctx);
+static VALUE allocate(VALUE klass);
+static VALUE duckdb_prepared_statement_initialize(VALUE self, VALUE con, VALUE query);
+static VALUE duckdb_prepared_statement_nparams(VALUE self);
+static VALUE duckdb_prepared_statement_execute(VALUE self);
+static idx_t check_index(VALUE vidx);
+static VALUE duckdb_prepared_statement_bind_bool(VALUE self, VALUE vidx, VALUE val);
+static VALUE duckdb_prepared_statement_bind_int8(VALUE self, VALUE vidx, VALUE val);
+static VALUE duckdb_prepared_statement_bind_int16(VALUE self, VALUE vidx, VALUE val);
+static VALUE duckdb_prepared_statement_bind_int32(VALUE self, VALUE vidx, VALUE val);
+static VALUE duckdb_prepared_statement_bind_int64(VALUE self, VALUE vidx, VALUE val);
+static VALUE duckdb_prepared_statement_bind_float(VALUE self, VALUE vidx, VALUE val);
+static VALUE duckdb_prepared_statement_bind_double(VALUE self, VALUE vidx, VALUE val);
+static VALUE duckdb_prepared_statement_bind_varchar(VALUE self, VALUE vidx, VALUE str);
+static VALUE duckdb_prepared_statement_bind_blob(VALUE self, VALUE vidx, VALUE blob);
+static VALUE duckdb_prepared_statement_bind_null(VALUE self, VALUE vidx);
+
+#ifdef HAVE_DUCKDB_BIND_DATE
+static VALUE duckdb_prepared_statement__bind_date(VALUE self, VALUE vidx, VALUE year, VALUE month, VALUE day);
+#endif
+
+#ifdef HAVE_DUCKDB_BIND_TIME
+static VALUE duckdb_prepared_statement__bind_time(VALUE self, VALUE vidx, VALUE hour, VALUE min, VALUE sec, VALUE micros);
+#endif
+
+#ifdef HAVE_DUCKDB_BIND_TIMESTAMP
+static VALUE duckdb_prepared_statement__bind_timestamp(VALUE self, VALUE vidx, VALUE year, VALUE month, VALUE day, VALUE hour, VALUE min, VALUE sec, VALUE micros);
+#endif
+
+#ifdef HAVE_DUCKDB_BIND_INTERVAL
+static VALUE duckdb_prepared_statement__bind_interval(VALUE self, VALUE vidx, VALUE months, VALUE days, VALUE micros);
+#endif
+
+
+static void deallocate(void *ctx) {
     rubyDuckDBPreparedStatement *p = (rubyDuckDBPreparedStatement *)ctx;
 
     duckdb_destroy_prepare(&(p->prepared_statement));
     xfree(p);
 }
 
-static VALUE allocate(VALUE klass)
-{
+static VALUE allocate(VALUE klass) {
     rubyDuckDBPreparedStatement *ctx = xcalloc((size_t)1, sizeof(rubyDuckDBPreparedStatement));
     return Data_Wrap_Struct(klass, NULL, deallocate, ctx);
 }
 
-static VALUE duckdb_prepared_statement_initialize(VALUE self, VALUE con, VALUE query)
-{
+static VALUE duckdb_prepared_statement_initialize(VALUE self, VALUE con, VALUE query) {
     rubyDuckDBConnection *ctxcon;
     rubyDuckDBPreparedStatement *ctx;
 
@@ -29,26 +60,32 @@ static VALUE duckdb_prepared_statement_initialize(VALUE self, VALUE con, VALUE q
     Data_Get_Struct(con, rubyDuckDBConnection, ctxcon);
 
     if (duckdb_prepare(ctxcon->con, StringValuePtr(query), &(ctx->prepared_statement)) == DuckDBError) {
+#ifdef HAVE_DUCKDB_PREPARE_ERROR
+        const char *error = duckdb_prepare_error(ctx->prepared_statement);
+        rb_raise(eDuckDBError, "%s", error);
+#else
         /* TODO: include query parameter information in error message. */
         rb_raise(eDuckDBError, "failed to prepare statement");
+#endif
     }
     return self;
 }
 
-static VALUE duckdb_prepared_statement_nparams(VALUE self)
-{
+static VALUE duckdb_prepared_statement_nparams(VALUE self) {
     rubyDuckDBPreparedStatement *ctx;
     Data_Get_Struct(self, rubyDuckDBPreparedStatement, ctx);
-
+#ifdef HAVE_DUCKDB_NPARAMS_029
+    return rb_int2big(duckdb_nparams(ctx->prepared_statement));
+#else
     if (duckdb_nparams(ctx->prepared_statement, &(ctx->nparams)) == DuckDBError) {
         rb_raise(eDuckDBError, "failed to get number of parameters");
     }
     return rb_int2big(ctx->nparams);
+#endif
 }
 
 
-static VALUE duckdb_prepared_statement_execute(VALUE self)
-{
+static VALUE duckdb_prepared_statement_execute(VALUE self) {
     rubyDuckDBPreparedStatement *ctx;
     rubyDuckDBResult *ctxr;
     VALUE result = create_result();
@@ -56,13 +93,12 @@ static VALUE duckdb_prepared_statement_execute(VALUE self)
     Data_Get_Struct(self, rubyDuckDBPreparedStatement, ctx);
     Data_Get_Struct(result, rubyDuckDBResult, ctxr);
     if (duckdb_execute_prepared(ctx->prepared_statement, &(ctxr->result)) == DuckDBError) {
-        rb_raise(eDuckDBError, "%s", ctxr->result.error_message);
+        rb_raise(eDuckDBError, "%s", duckdb_result_error(&(ctxr->result)));
     }
     return result;
 }
 
-static idx_t check_index(VALUE vidx)
-{
+static idx_t check_index(VALUE vidx) {
     idx_t idx = FIX2INT(vidx);
     if (idx <= 0) {
         rb_raise(rb_eArgError, "index of parameter must be greater than 0");
@@ -70,8 +106,7 @@ static idx_t check_index(VALUE vidx)
     return idx;
 }
 
-static VALUE duckdb_prepared_statement_bind_bool(VALUE self, VALUE vidx, VALUE val)
-{
+static VALUE duckdb_prepared_statement_bind_bool(VALUE self, VALUE vidx, VALUE val) {
     rubyDuckDBPreparedStatement *ctx;
     idx_t idx = check_index(vidx);
 
@@ -86,8 +121,7 @@ static VALUE duckdb_prepared_statement_bind_bool(VALUE self, VALUE vidx, VALUE v
     return self;
 }
 
-static VALUE duckdb_prepared_statement_bind_int8(VALUE self, VALUE vidx, VALUE val)
-{
+static VALUE duckdb_prepared_statement_bind_int8(VALUE self, VALUE vidx, VALUE val) {
     rubyDuckDBPreparedStatement *ctx;
     idx_t idx = check_index(vidx);
     int8_t i8val = (int8_t)NUM2INT(val);
@@ -100,8 +134,7 @@ static VALUE duckdb_prepared_statement_bind_int8(VALUE self, VALUE vidx, VALUE v
     return self;
 }
 
-static VALUE duckdb_prepared_statement_bind_int16(VALUE self, VALUE vidx, VALUE val)
-{
+static VALUE duckdb_prepared_statement_bind_int16(VALUE self, VALUE vidx, VALUE val) {
     rubyDuckDBPreparedStatement *ctx;
     idx_t idx = check_index(vidx);
     int16_t i16val = NUM2INT(val);
@@ -114,8 +147,7 @@ static VALUE duckdb_prepared_statement_bind_int16(VALUE self, VALUE vidx, VALUE
     return self;
 }
 
-static VALUE duckdb_prepared_statement_bind_int32(VALUE self, VALUE vidx, VALUE val)
-{
+static VALUE duckdb_prepared_statement_bind_int32(VALUE self, VALUE vidx, VALUE val) {
     rubyDuckDBPreparedStatement *ctx;
     idx_t idx = check_index(vidx);
     int32_t i32val = NUM2INT(val);
@@ -128,8 +160,7 @@ static VALUE duckdb_prepared_statement_bind_int32(VALUE self, VALUE vidx, VALUE
     return self;
 }
 
-static VALUE duckdb_prepared_statement_bind_int64(VALUE self, VALUE vidx, VALUE val)
-{
+static VALUE duckdb_prepared_statement_bind_int64(VALUE self, VALUE vidx, VALUE val) {
     rubyDuckDBPreparedStatement *ctx;
     idx_t idx = check_index(vidx);
     int64_t i64val = NUM2LL(val);
@@ -142,8 +173,7 @@ static VALUE duckdb_prepared_statement_bind_int64(VALUE self, VALUE vidx, VALUE
     return self;
 }
 
-static VALUE duckdb_prepared_statement_bind_float(VALUE self, VALUE vidx, VALUE val)
-{
+static VALUE duckdb_prepared_statement_bind_float(VALUE self, VALUE vidx, VALUE val) {
     rubyDuckDBPreparedStatement *ctx;
     idx_t idx = check_index(vidx);
     double dbl = NUM2DBL(val);
@@ -156,8 +186,7 @@ static VALUE duckdb_prepared_statement_bind_float(VALUE self, VALUE vidx, VALUE
     return self;
 }
 
-static VALUE duckdb_prepared_statement_bind_double(VALUE self, VALUE vidx, VALUE val)
-{
+static VALUE duckdb_prepared_statement_bind_double(VALUE self, VALUE vidx, VALUE val) {
     rubyDuckDBPreparedStatement *ctx;
     idx_t idx = check_index(vidx);
     double dbl = NUM2DBL(val);
@@ -170,8 +199,7 @@ static VALUE duckdb_prepared_statement_bind_double(VALUE self, VALUE vidx, VALUE
     return self;
 }
 
-static VALUE duckdb_prepared_statement_bind_varchar(VALUE self, VALUE vidx, VALUE str)
-{
+static VALUE duckdb_prepared_statement_bind_varchar(VALUE self, VALUE vidx, VALUE str) {
     rubyDuckDBPreparedStatement *ctx;
     idx_t idx = check_index(vidx);
 
@@ -182,9 +210,7 @@ static VALUE duckdb_prepared_statement_bind_varchar(VALUE self, VALUE vidx, VALU
     return self;
 }
 
-#ifdef HAVE_DUCKDB_VALUE_BLOB
-static VALUE duckdb_prepared_statement_bind_blob(VALUE self, VALUE vidx, VALUE blob)
-{
+static VALUE duckdb_prepared_statement_bind_blob(VALUE self, VALUE vidx, VALUE blob) {
     rubyDuckDBPreparedStatement *ctx;
     idx_t idx = check_index(vidx);
 
@@ -194,10 +220,8 @@ static VALUE duckdb_prepared_statement_bind_blob(VALUE self, VALUE vidx, VALUE b
     }
     return self;
 }
-#endif /* HAVE_DUCKDB_VALUE_BLOB */
 
-static VALUE duckdb_prepared_statement_bind_null(VALUE self, VALUE vidx)
-{
+static VALUE duckdb_prepared_statement_bind_null(VALUE self, VALUE vidx) {
     rubyDuckDBPreparedStatement *ctx;
     idx_t idx = check_index(vidx);
 
@@ -208,8 +232,72 @@ static VALUE duckdb_prepared_statement_bind_null(VALUE self, VALUE vidx)
     return self;
 }
 
-void init_duckdb_prepared_statement(void)
-{
+#ifdef HAVE_DUCKDB_BIND_DATE
+static VALUE duckdb_prepared_statement__bind_date(VALUE self, VALUE vidx, VALUE year, VALUE month, VALUE day) {
+    rubyDuckDBPreparedStatement *ctx;
+    duckdb_date dt;
+    idx_t idx = check_index(vidx);
+
+    dt = to_duckdb_date_from_value(year, month, day);
+
+    Data_Get_Struct(self, rubyDuckDBPreparedStatement, ctx);
+    if (duckdb_bind_date(ctx->prepared_statement, idx, dt) == DuckDBError) {
+        rb_raise(eDuckDBError, "fail to bind %llu parameter", (unsigned long long)idx);
+    }
+    return self;
+}
+#endif
+
+#ifdef HAVE_DUCKDB_BIND_TIME
+static VALUE duckdb_prepared_statement__bind_time(VALUE self, VALUE vidx, VALUE hour, VALUE min, VALUE sec, VALUE micros){
+    rubyDuckDBPreparedStatement *ctx;
+    duckdb_time time;
+
+    idx_t idx = check_index(vidx);
+
+    time = to_duckdb_time_from_value(hour, min, sec, micros);
+
+    Data_Get_Struct(self, rubyDuckDBPreparedStatement, ctx);
+    if (duckdb_bind_time(ctx->prepared_statement, idx, time) == DuckDBError) {
+        rb_raise(eDuckDBError, "fail to bind %llu parameter", (unsigned long long)idx);
+    }
+    return self;
+}
+#endif
+
+#ifdef HAVE_DUCKDB_BIND_TIMESTAMP
+static VALUE duckdb_prepared_statement__bind_timestamp(VALUE self, VALUE vidx, VALUE year, VALUE month, VALUE day, VALUE hour, VALUE min, VALUE sec, VALUE micros) {
+    duckdb_timestamp timestamp;
+    rubyDuckDBPreparedStatement *ctx;
+    idx_t idx = check_index(vidx);
+
+    timestamp = to_duckdb_timestamp_from_value(year, month, day, hour, min, sec, micros);
+    Data_Get_Struct(self, rubyDuckDBPreparedStatement, ctx);
+
+    if (duckdb_bind_timestamp(ctx->prepared_statement, idx, timestamp) == DuckDBError) {
+        rb_raise(eDuckDBError, "fail to bind %llu parameter", (unsigned long long)idx);
+    }
+    return self;
+}
+#endif
+
+#ifdef HAVE_DUCKDB_BIND_INTERVAL
+static VALUE duckdb_prepared_statement__bind_interval(VALUE self, VALUE vidx, VALUE months, VALUE days, VALUE micros) {
+    duckdb_interval interval;
+    rubyDuckDBPreparedStatement *ctx;
+    idx_t idx = check_index(vidx);
+
+    Data_Get_Struct(self, rubyDuckDBPreparedStatement, ctx);
+    to_duckdb_interval_from_value(&interval, months, days, micros);
+
+    if (duckdb_bind_interval(ctx->prepared_statement, idx, interval) == DuckDBError) {
+        rb_raise(eDuckDBError, "fail to bind %llu parameter", (unsigned long long)idx);
+    }
+    return self;
+}
+#endif
+
+void init_duckdb_prepared_statement(void) {
     cDuckDBPreparedStatement = rb_define_class_under(mDuckDB, "PreparedStatement", rb_cObject);
 
     rb_define_alloc_func(cDuckDBPreparedStatement, allocate);
@@ -225,8 +313,16 @@ void init_duckdb_prepared_statement(void)
     rb_define_method(cDuckDBPreparedStatement, "bind_float", duckdb_prepared_statement_bind_float, 2);
     rb_define_method(cDuckDBPreparedStatement, "bind_double", duckdb_prepared_statement_bind_double, 2);
     rb_define_method(cDuckDBPreparedStatement, "bind_varchar", duckdb_prepared_statement_bind_varchar, 2);
-#ifdef HAVE_DUCKDB_VALUE_BLOB
     rb_define_method(cDuckDBPreparedStatement, "bind_blob", duckdb_prepared_statement_bind_blob, 2);
-#endif /* HAVE_DUCKDB_VALUE_BLOB */
     rb_define_method(cDuckDBPreparedStatement, "bind_null", duckdb_prepared_statement_bind_null, 1);
+    rb_define_private_method(cDuckDBPreparedStatement, "_bind_date", duckdb_prepared_statement__bind_date, 4);
+#ifdef HAVE_DUCKDB_BIND_TIME
+    rb_define_private_method(cDuckDBPreparedStatement, "_bind_time", duckdb_prepared_statement__bind_time, 5);
+#endif
+#ifdef HAVE_DUCKDB_BIND_TIMESTAMP
+    rb_define_private_method(cDuckDBPreparedStatement, "_bind_timestamp", duckdb_prepared_statement__bind_timestamp, 8);
+#endif
+#ifdef HAVE_DUCKDB_BIND_INTERVAL
+    rb_define_private_method(cDuckDBPreparedStatement, "_bind_interval", duckdb_prepared_statement__bind_interval, 4);
+#endif
 }

data/ext/duckdb/result.c

@@ -2,59 +2,64 @@
 
 static VALUE cDuckDBResult;
 
-static void deallocate(void *ctx)
-{
+static void deallocate(void *ctx);
+static VALUE allocate(VALUE klass);
+static VALUE to_ruby_obj_boolean(duckdb_result *result, idx_t col_idx, idx_t row_idx);
+static VALUE to_ruby_obj_smallint(duckdb_result *result, idx_t col_idx, idx_t row_idx);
+static VALUE to_ruby_obj_integer(duckdb_result *result, idx_t col_idx, idx_t row_idx);
+static VALUE to_ruby_obj_bigint(duckdb_result *result, idx_t col_idx, idx_t row_idx);
+static VALUE to_ruby_obj_float(duckdb_result *result, idx_t col_idx, idx_t row_idx);
+static VALUE to_ruby_obj_double(duckdb_result *result, idx_t col_idx, idx_t row_idx);
+static VALUE to_ruby_obj_string_from_blob(duckdb_result *result, idx_t col_idx, idx_t row_idx);
+static VALUE to_ruby_obj(duckdb_result *result, idx_t col_idx, idx_t row_idx);
+static VALUE row_array(rubyDuckDBResult *ctx, idx_t row_idx);
+static VALUE duckdb_result_row_size(VALUE oDuckDBResult, VALUE args, VALUE obj);
+static VALUE duckdb_result_each(VALUE oDuckDBResult);
+static VALUE duckdb_result_rows_changed(VALUE oDuckDBResult);
+
+static void deallocate(void *ctx) {
     rubyDuckDBResult *p = (rubyDuckDBResult *)ctx;
 
     duckdb_destroy_result(&(p->result));
     xfree(p);
 }
 
-static VALUE allocate(VALUE klass)
-{
+static VALUE allocate(VALUE klass) {
     rubyDuckDBResult *ctx = xcalloc((size_t)1, sizeof(rubyDuckDBResult));
     return Data_Wrap_Struct(klass, NULL, deallocate, ctx);
 }
 
-static VALUE to_ruby_obj_boolean(duckdb_result *result, idx_t col_idx, idx_t row_idx)
-{
+static VALUE to_ruby_obj_boolean(duckdb_result *result, idx_t col_idx, idx_t row_idx) {
     bool bval = duckdb_value_boolean(result, col_idx, row_idx);
     return bval ? Qtrue : Qnil;
 }
 
-static VALUE to_ruby_obj_smallint(duckdb_result *result, idx_t col_idx, idx_t row_idx)
-{
+static VALUE to_ruby_obj_smallint(duckdb_result *result, idx_t col_idx, idx_t row_idx) {
     int16_t i16val = duckdb_value_int16(result, col_idx, row_idx);
     return INT2FIX(i16val);
 }
 
-static VALUE to_ruby_obj_integer(duckdb_result *result, idx_t col_idx, idx_t row_idx)
-{
+static VALUE to_ruby_obj_integer(duckdb_result *result, idx_t col_idx, idx_t row_idx) {
     int32_t i32val = duckdb_value_int32(result, col_idx, row_idx);
     return INT2NUM(i32val);
 }
 
-static VALUE to_ruby_obj_bigint(duckdb_result *result, idx_t col_idx, idx_t row_idx)
-{
+static VALUE to_ruby_obj_bigint(duckdb_result *result, idx_t col_idx, idx_t row_idx) {
     int64_t i64val = duckdb_value_int64(result, col_idx, row_idx);
     return rb_int2big(i64val);
 }
 
-static VALUE to_ruby_obj_float(duckdb_result *result, idx_t col_idx, idx_t row_idx)
-{
+static VALUE to_ruby_obj_float(duckdb_result *result, idx_t col_idx, idx_t row_idx) {
     float fval = duckdb_value_float(result, col_idx, row_idx);
     return DBL2NUM(fval);
 }
 
-static VALUE to_ruby_obj_double(duckdb_result *result, idx_t col_idx, idx_t row_idx)
-{
+static VALUE to_ruby_obj_double(duckdb_result *result, idx_t col_idx, idx_t row_idx) {
     double dval = duckdb_value_double(result, col_idx, row_idx);
     return DBL2NUM(dval);
 }
 
-#ifdef HAVE_DUCKDB_VALUE_BLOB
-static VALUE to_ruby_obj_string_from_blob(duckdb_result *result, idx_t col_idx, idx_t row_idx)
-{
+static VALUE to_ruby_obj_string_from_blob(duckdb_result *result, idx_t col_idx, idx_t row_idx) {
     VALUE str;
     duckdb_blob bval = duckdb_value_blob(result, col_idx, row_idx);
     str = rb_str_new(bval.data, bval.size);
@@ -69,16 +74,14 @@ static VALUE to_ruby_obj_string_from_blob(duckdb_result *result, idx_t col_idx,
 
     return str;
 }
-#endif /* HAVE_DUCKDB_VALUE_BLOB */
 
-static VALUE to_ruby_obj(duckdb_result *result, idx_t col_idx, idx_t row_idx)
-{
+static VALUE to_ruby_obj(duckdb_result *result, idx_t col_idx, idx_t row_idx) {
     char *p;
     VALUE obj = Qnil;
-    if (result->columns[col_idx].nullmask[row_idx]) {
+    if (duckdb_value_is_null(result, col_idx, row_idx)) {
         return obj;
     }
-    switch(result->columns[col_idx].type) {
+    switch(duckdb_column_type(result, col_idx)) {
     case DUCKDB_TYPE_BOOLEAN:
         return to_ruby_obj_boolean(result, col_idx, row_idx);
     case DUCKDB_TYPE_SMALLINT:
@@ -91,10 +94,8 @@ static VALUE to_ruby_obj(duckdb_result *result, idx_t col_idx, idx_t row_idx)
         return to_ruby_obj_float(result, col_idx, row_idx);
     case DUCKDB_TYPE_DOUBLE:
         return to_ruby_obj_double(result, col_idx, row_idx);
-#ifdef HAVE_DUCKDB_VALUE_BLOB
     case DUCKDB_TYPE_BLOB:
         return to_ruby_obj_string_from_blob(result, col_idx, row_idx);
-#endif /* HAVE_DUCKDB_VALUE_BLOB */
     default:
         p = duckdb_value_varchar(result, col_idx, row_idx);
         if (p) {
@@ -104,7 +105,7 @@ static VALUE to_ruby_obj(duckdb_result *result, idx_t col_idx, idx_t row_idx)
 #else
             free(p);
 #endif /* HAVE_DUCKDB_FREE */
-            if (result->columns[col_idx].type == DUCKDB_TYPE_HUGEINT) {
+            if (duckdb_column_type(result, col_idx) == DUCKDB_TYPE_HUGEINT) {
                 obj = rb_funcall(obj, rb_intern("to_i"), 0);
             }
         }
@@ -112,47 +113,75 @@ static VALUE to_ruby_obj(duckdb_result *result, idx_t col_idx, idx_t row_idx)
     return obj;
 }
 
-static VALUE row_array(rubyDuckDBResult *ctx, idx_t row_idx)
-{
+static VALUE row_array(rubyDuckDBResult *ctx, idx_t row_idx) {
     idx_t col_idx;
-    VALUE ary = rb_ary_new2(ctx->result.column_count);
-    for(col_idx = 0; col_idx < ctx->result.column_count; col_idx++) {
+    idx_t column_count = duckdb_column_count(&(ctx->result));
+
+    VALUE ary = rb_ary_new2(column_count);
+    for(col_idx = 0; col_idx < column_count; col_idx++) {
         rb_ary_store(ary, col_idx, to_ruby_obj(&(ctx->result), col_idx, row_idx));
     }
     return ary;
 }
 
-static VALUE duckdb_result_row_size(VALUE oDuckDBResult, VALUE args, VALUE obj)
-{
+static VALUE duckdb_result_row_size(VALUE oDuckDBResult, VALUE args, VALUE obj) {
     rubyDuckDBResult *ctx;
     Data_Get_Struct(oDuckDBResult, rubyDuckDBResult, ctx);
 
-    return LONG2FIX(ctx->result.row_count);
+    return LONG2FIX(duckdb_row_count(&(ctx->result)));
 }
 
-static VALUE duckdb_result_each(VALUE oDuckDBResult)
-{
+static VALUE duckdb_result_each(VALUE oDuckDBResult) {
     rubyDuckDBResult *ctx;
     idx_t row_idx = 0;
+    idx_t row_count = 0;
 
     RETURN_SIZED_ENUMERATOR(oDuckDBResult, 0, 0, duckdb_result_row_size);
 
     Data_Get_Struct(oDuckDBResult, rubyDuckDBResult, ctx);
-    for (row_idx = 0; row_idx < ctx->result.row_count; row_idx++) {
+    row_count = duckdb_row_count(&(ctx->result));
+    for (row_idx = 0; row_idx < row_count; row_idx++) {
         rb_yield(row_array(ctx, row_idx));
     }
     return oDuckDBResult;
 }
 
-VALUE create_result(void)
-{
+/*
+ *  call-seq:
+ *    result.rows_changed -> integer
+ *
+ *  Returns the count of rows changed.
+ *
+ *    DuckDB::Database.open do |db|
+ *      db.connect do |con|
+ *        r = con.query('CREATE TABLE t2 (id INT)')
+ *        r.rows_changed # => 0
+ *        r = con.query('INSERT INTO t2 VALUES (1), (2), (3)')
+ *        r.rows_changed # => 3
+ *        r = con.query('UPDATE t2 SET id = id + 1 WHERE id > 1')
+ *        r.rows_changed # => 2
+ *        r = con.query('DELETE FROM t2 WHERE id = 0')
+ *        r.rows_changed # => 0
+ *        r = con.query('DELETE FROM t2 WHERE id = 4')
+ *        r.rows_changed # => 1
+ *      end
+ *    end
+ *
+ */
+static VALUE duckdb_result_rows_changed(VALUE oDuckDBResult) {
+    rubyDuckDBResult *ctx;
+    Data_Get_Struct(oDuckDBResult, rubyDuckDBResult, ctx);
+    return LL2NUM(duckdb_rows_changed(&(ctx->result)));
+}
+
+VALUE create_result(void) {
     return allocate(cDuckDBResult);
 }
 
-void init_duckdb_result(void)
-{
+void init_duckdb_result(void) {
     cDuckDBResult = rb_define_class_under(mDuckDB, "Result", rb_cObject);
     rb_define_alloc_func(cDuckDBResult, allocate);
 
     rb_define_method(cDuckDBResult, "each", duckdb_result_each, 0);
+    rb_define_method(cDuckDBResult, "rows_changed", duckdb_result_rows_changed, 0);
 }