duckdb 2.0.0.0 → 2.0.0.1

data/ext/duckdb/connection.c

@@ -251,6 +251,17 @@ static VALUE connection__get_table_names(VALUE self, VALUE query, VALUE qualifie
     return rbduckdb_value_new(table_names);
 }
 
+static VALUE connection_check_registered(VALUE self, duckdb_state state, VALUE obj, const char *kind) {
+    if (state == DuckDBError) {
+        rb_raise(eDuckDBError, "Failed to register %s", kind);
+    }
+
+    /* Keep reference alive as long as the database can call it */
+    connection_retain_registered(self, obj);
+
+    return self;
+}
+
 /* :nodoc: */
 static VALUE connection__register_logical_type(VALUE self, VALUE logical_type) {
     rubyDuckDBConnection *ctxcon;
@@ -261,15 +272,7 @@ static VALUE connection__register_logical_type(VALUE self, VALUE logical_type) {
     ctxlt = rbduckdb_get_struct_logical_type(logical_type);
 
     state = duckdb_register_logical_type(ctxcon->con, ctxlt->logical_type, NULL);
-
-    if (state == DuckDBError) {
-        rb_raise(eDuckDBError, "Failed to register logical type");
-    }
-
-    /* Keep reference alive as long as the database can call it */
-    connection_retain_registered(self, logical_type);
-
-    return self;
+    return connection_check_registered(self, state, logical_type, "logical type");
 }
 
 /* :nodoc: */
@@ -282,15 +285,7 @@ static VALUE connection__register_scalar_function(VALUE self, VALUE scalar_funct
     ctxsf = rbduckdb_get_struct_scalar_function(scalar_function);
 
     state = duckdb_register_scalar_function(ctxcon->con, ctxsf->scalar_function);
-
-    if (state == DuckDBError) {
-        rb_raise(eDuckDBError, "Failed to register scalar function");
-    }
-
-    /* Keep reference alive as long as the database can call it */
-    connection_retain_registered(self, scalar_function);
-
-    return self;
+    return connection_check_registered(self, state, scalar_function, "scalar function");
 }
 
 /* :nodoc: */
@@ -303,15 +298,7 @@ static VALUE connection__register_scalar_function_set(VALUE self, VALUE scalar_f
     ctxsfs = rbduckdb_get_struct_scalar_function_set(scalar_function_set);
 
     state = duckdb_register_scalar_function_set(ctxcon->con, ctxsfs->scalar_function_set);
-
-    if (state == DuckDBError) {
-        rb_raise(eDuckDBError, "Failed to register scalar function set");
-    }
-
-    /* Keep reference alive as long as the database can call it */
-    connection_retain_registered(self, scalar_function_set);
-
-    return self;
+    return connection_check_registered(self, state, scalar_function_set, "scalar function set");
 }
 
 /* :nodoc: */
@@ -324,15 +311,7 @@ static VALUE connection__register_aggregate_function(VALUE self, VALUE aggregate
     ctxaf = rbduckdb_get_struct_aggregate_function(aggregate_function);
 
     state = duckdb_register_aggregate_function(ctxcon->con, ctxaf->aggregate_function);
-
-    if (state == DuckDBError) {
-        rb_raise(eDuckDBError, "Failed to register aggregate function");
-    }
-
-    /* Keep reference alive as long as the database can call it */
-    connection_retain_registered(self, aggregate_function);
-
-    return self;
+    return connection_check_registered(self, state, aggregate_function, "aggregate function");
 }
 
 /* :nodoc: */
@@ -345,15 +324,7 @@ static VALUE connection__register_aggregate_function_set(VALUE self, VALUE aggre
     ctxafs = rbduckdb_get_struct_aggregate_function_set(aggregate_function_set);
 
     state = duckdb_register_aggregate_function_set(ctxcon->con, ctxafs->aggregate_function_set);
-
-    if (state == DuckDBError) {
-        rb_raise(eDuckDBError, "Failed to register aggregate function set");
-    }
-
-    /* Keep reference alive as long as the database can call it */
-    connection_retain_registered(self, aggregate_function_set);
-
-    return self;
+    return connection_check_registered(self, state, aggregate_function_set, "aggregate function set");
 }
 
 static VALUE connection__register_table_function(VALUE self, VALUE table_function) {
@@ -365,15 +336,7 @@ static VALUE connection__register_table_function(VALUE self, VALUE table_functio
     ctxtf = rbduckdb_get_struct_table_function(table_function);
 
     state = duckdb_register_table_function(ctxcon->con, ctxtf->table_function);
-
-    if (state == DuckDBError) {
-        rb_raise(eDuckDBError, "Failed to register table function");
-    }
-
-    /* Keep reference alive as long as the database can call it */
-    connection_retain_registered(self, table_function);
-
-    return self;
+    return connection_check_registered(self, state, table_function, "table function");
 }
 
 void rbduckdb_init_connection(void) {

data/ext/duckdb/conveter.c

@@ -17,49 +17,8 @@ ID id__to_time_from_duckdb_timestamp_tz;
 ID id__to_infinity;
 ID id__decimal_to_unscaled;
 
-static VALUE infinite_date_value(duckdb_date date) {
-    if (duckdb_is_finite_date(date) == false) {
-        return rb_funcall(mDuckDBConverter, id__to_infinity, 1,
-                          INT2NUM(date.days)
-                         );
-    }
-    return Qnil;
-}
-
-static VALUE infinite_timestamp_value(duckdb_timestamp timestamp) {
-    if (duckdb_is_finite_timestamp(timestamp) == false) {
-        return rb_funcall(mDuckDBConverter, id__to_infinity, 1,
-                          LL2NUM(timestamp.micros)
-                         );
-    }
-    return Qnil;
-}
-
-static VALUE infinite_timestamp_s_value(duckdb_timestamp_s timestamp_s) {
-    if (duckdb_is_finite_timestamp_s(timestamp_s) == false) {
-        return rb_funcall(mDuckDBConverter, id__to_infinity, 1,
-                          LL2NUM(timestamp_s.seconds)
-                         );
-    }
-    return Qnil;
-}
-
-static VALUE infinite_timestamp_ms_value(duckdb_timestamp_ms timestamp_ms) {
-    if (duckdb_is_finite_timestamp_ms(timestamp_ms) == false) {
-        return rb_funcall(mDuckDBConverter, id__to_infinity, 1,
-                          LL2NUM(timestamp_ms.millis)
-                         );
-    }
-    return Qnil;
-}
-
-static VALUE infinite_timestamp_ns_value(duckdb_timestamp_ns timestamp_ns) {
-    if (duckdb_is_finite_timestamp_ns(timestamp_ns) == false) {
-        return rb_funcall(mDuckDBConverter, id__to_infinity, 1,
-                          LL2NUM(timestamp_ns.nanos)
-                         );
-    }
-    return Qnil;
+static VALUE ruby_infinity(VALUE raw) {
+    return rb_funcall(mDuckDBConverter, id__to_infinity, 1, raw);
 }
 
 #define DUCKDB_UUID_SIGN_BIT 0x8000000000000000ULL
@@ -256,9 +215,8 @@ VALUE rbduckdb_uhugeint_to_ruby(duckdb_uhugeint h) {
 }
 
 VALUE rbduckdb_timestamp_s_to_ruby(duckdb_timestamp_s ts) {
-    VALUE obj = infinite_timestamp_s_value(ts);
-    if (obj != Qnil) {
-        return obj;
+    if (!duckdb_is_finite_timestamp_s(ts)) {
+        return ruby_infinity(LL2NUM(ts.seconds));
     }
     return rb_funcall(mDuckDBConverter, id__to_time_from_duckdb_timestamp_s, 1,
                       LL2NUM(ts.seconds)
@@ -266,9 +224,8 @@ VALUE rbduckdb_timestamp_s_to_ruby(duckdb_timestamp_s ts) {
 }
 
 VALUE rbduckdb_timestamp_ms_to_ruby(duckdb_timestamp_ms ts) {
-    VALUE obj = infinite_timestamp_ms_value(ts);
-    if (obj != Qnil) {
-        return obj;
+    if (!duckdb_is_finite_timestamp_ms(ts)) {
+        return ruby_infinity(LL2NUM(ts.millis));
     }
     return rb_funcall(mDuckDBConverter, id__to_time_from_duckdb_timestamp_ms, 1,
                       LL2NUM(ts.millis)
@@ -276,9 +233,8 @@ VALUE rbduckdb_timestamp_ms_to_ruby(duckdb_timestamp_ms ts) {
 }
 
 VALUE rbduckdb_timestamp_ns_to_ruby(duckdb_timestamp_ns ts) {
-    VALUE obj = infinite_timestamp_ns_value(ts);
-    if (obj != Qnil) {
-        return obj;
+    if (!duckdb_is_finite_timestamp_ns(ts)) {
+        return ruby_infinity(LL2NUM(ts.nanos));
     }
     return rb_funcall(mDuckDBConverter, id__to_time_from_duckdb_timestamp_ns, 1,
                       LL2NUM(ts.nanos)
@@ -319,35 +275,42 @@ VALUE rbduckdb_time_to_ruby(duckdb_time t) {
 }
 
 VALUE rbduckdb_date_to_ruby(duckdb_date date) {
-    VALUE obj = infinite_date_value(date);
-
-    if (obj == Qnil) {
-        duckdb_date_struct date_st = duckdb_from_date(date);
-        obj = rb_funcall(mDuckDBConverter, id__to_date, 3,
-                         INT2FIX(date_st.year),
-                         INT2FIX(date_st.month),
-                         INT2FIX(date_st.day)
-                         );
+    duckdb_date_struct date_st;
+
+    if (!duckdb_is_finite_date(date)) {
+        return ruby_infinity(INT2NUM(date.days));
     }
-    return obj;
+    date_st = duckdb_from_date(date);
+    return rb_funcall(mDuckDBConverter, id__to_date, 3,
+                      INT2FIX(date_st.year),
+                      INT2FIX(date_st.month),
+                      INT2FIX(date_st.day)
+                      );
 }
 
 VALUE rbduckdb_timestamp_to_ruby(duckdb_timestamp ts) {
-    VALUE obj = infinite_timestamp_value(ts);
-
-    if (obj == Qnil) {
-        duckdb_timestamp_struct data_st = duckdb_from_timestamp(ts);
-        obj = rb_funcall(mDuckDBConverter, id__to_time, 7,
-                         INT2FIX(data_st.date.year),
-                         INT2FIX(data_st.date.month),
-                         INT2FIX(data_st.date.day),
-                         INT2FIX(data_st.time.hour),
-                         INT2FIX(data_st.time.min),
-                         INT2FIX(data_st.time.sec),
-                         INT2NUM(data_st.time.micros)
-                         );
+    duckdb_timestamp_struct data_st;
+
+    if (!duckdb_is_finite_timestamp(ts)) {
+        return ruby_infinity(LL2NUM(ts.micros));
     }
-    return obj;
+    /*
+     * duckdb_from_timestamp throws a C++ exception below this value
+     * (days * MICROS_PER_DAY overflows int64), which would abort the process.
+     */
+    if (ts.micros < -9223372022400000000LL) {
+        rb_raise(rb_eRangeError, "timestamp out of range: %lld microseconds", (long long)ts.micros);
+    }
+    data_st = duckdb_from_timestamp(ts);
+    return rb_funcall(mDuckDBConverter, id__to_time, 7,
+                      INT2FIX(data_st.date.year),
+                      INT2FIX(data_st.date.month),
+                      INT2FIX(data_st.date.day),
+                      INT2FIX(data_st.time.hour),
+                      INT2FIX(data_st.time.min),
+                      INT2FIX(data_st.time.sec),
+                      INT2NUM(data_st.time.micros)
+                      );
 }
 
 void rbduckdb_init_converter(void) {