duckdb 0.3.3-dev432.0 → 0.3.3-dev440.0

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "duckdb",
   "main": "./lib/duckdb.js",
-  "version": "0.3.3-dev432.0",
+  "version": "0.3.3-dev440.0",
   "description": "DuckDB node.js API",
   "gypfile": true,
   "dependencies": {

package/src/duckdb.cpp

@@ -100336,6 +100336,7 @@ void BaseAppender::Close() {
 
 
 
+
 #include <cstring>
 #include <cassert>
 
@@ -100370,6 +100371,10 @@ duckdb_type ConvertCPPTypeToC(const LogicalType &type);
 idx_t GetCTypeSize(duckdb_type type);
 duckdb_state duckdb_translate_result(MaterializedQueryResult *result, duckdb_result *out);
 
+struct DuckDBColumnData {
+	LogicalType type;
+};
+
 } // namespace duckdb
 
 
@@ -100915,6 +100920,8 @@ duckdb_type ConvertCPPTypeToC(const LogicalType &sql_type) {
 		return DUCKDB_TYPE_BLOB;
 	case LogicalTypeId::INTERVAL:
 		return DUCKDB_TYPE_INTERVAL;
+	case LogicalTypeId::DECIMAL:
+		return DUCKDB_TYPE_DECIMAL;
 	default: // LCOV_EXCL_START
 		D_ASSERT(0);
 		return DUCKDB_TYPE_INVALID;
@@ -100958,6 +100965,8 @@ idx_t GetCTypeSize(duckdb_type type) {
 		return sizeof(duckdb_blob);
 	case DUCKDB_TYPE_INTERVAL:
 		return sizeof(duckdb_interval);
+	case DUCKDB_TYPE_DECIMAL:
+		return sizeof(duckdb_hugeint);
 	default: // LCOV_EXCL_START
 		// unsupported type
 		D_ASSERT(0);
@@ -100977,6 +100986,8 @@ void duckdb_free(void *ptr) {
 
 
 
+
+
 using duckdb::Hugeint;
 using duckdb::hugeint_t;
 using duckdb::Value;
@@ -101001,6 +101012,15 @@ duckdb_hugeint duckdb_double_to_hugeint(double val) {
 	return result;
 }
 
+double duckdb_decimal_to_double(duckdb_decimal val) {
+	double result;
+	hugeint_t value;
+	value.lower = val.value.lower;
+	value.upper = val.value.upper;
+	duckdb::TryCastFromDecimal::Operation<hugeint_t, double>(value, result, nullptr, val.width, val.scale);
+	return result;
+}
+
 
 
 
@@ -101238,6 +101258,9 @@ duckdb_state duckdb_translate_result(MaterializedQueryResult *result, duckdb_res
 	// zero initialize the columns (so we can cleanly delete it in case a malloc fails)
 	memset(out->__deprecated_columns, 0, sizeof(duckdb_column) * out->__deprecated_column_count);
 	for (idx_t i = 0; i < out->__deprecated_column_count; i++) {
+		auto column_data = new DuckDBColumnData();
+		column_data->type = result->types[i];
+		out->__deprecated_columns[i].internal_data = column_data;
 		out->__deprecated_columns[i].__deprecated_type = ConvertCPPTypeToC(result->types[i]);
 		out->__deprecated_columns[i].__deprecated_name = strdup(result->names[i].c_str());
 		out->__deprecated_columns[i].__deprecated_nullmask =
@@ -101400,9 +101423,72 @@ duckdb_state duckdb_translate_result(MaterializedQueryResult *result, duckdb_res
 			}
 			break;
 		}
+		case LogicalTypeId::DECIMAL: {
+			// get data
+			idx_t row = 0;
+			auto target = (hugeint_t *)out->__deprecated_columns[col].__deprecated_data;
+			switch (result->types[col].InternalType()) {
+			case PhysicalType::INT16: {
+				for (auto &chunk : result->collection.Chunks()) {
+					auto source = FlatVector::GetData<int16_t>(chunk->data[col]);
+					for (idx_t k = 0; k < chunk->size(); k++) {
+						if (!FlatVector::IsNull(chunk->data[col], k)) {
+							target[row].lower = source[k];
+							target[row].upper = 0;
+						}
+						row++;
+					}
+				}
+				break;
+			}
+			case PhysicalType::INT32: {
+				for (auto &chunk : result->collection.Chunks()) {
+					auto source = FlatVector::GetData<int32_t>(chunk->data[col]);
+					for (idx_t k = 0; k < chunk->size(); k++) {
+						if (!FlatVector::IsNull(chunk->data[col], k)) {
+							target[row].lower = source[k];
+							target[row].upper = 0;
+						}
+						row++;
+					}
+				}
+				break;
+			}
+			case PhysicalType::INT64: {
+				for (auto &chunk : result->collection.Chunks()) {
+					auto source = FlatVector::GetData<int64_t>(chunk->data[col]);
+					for (idx_t k = 0; k < chunk->size(); k++) {
+						if (!FlatVector::IsNull(chunk->data[col], k)) {
+							target[row].lower = source[k];
+							target[row].upper = 0;
+						}
+						row++;
+					}
+				}
+				break;
+			}
+			case PhysicalType::INT128: {
+				for (auto &chunk : result->collection.Chunks()) {
+					auto source = FlatVector::GetData<hugeint_t>(chunk->data[col]);
+					for (idx_t k = 0; k < chunk->size(); k++) {
+						if (!FlatVector::IsNull(chunk->data[col], k)) {
+							target[row].lower = source[k].lower;
+							target[row].upper = source[k].upper;
+						}
+						row++;
+					}
+				}
+				break;
+			}
+			default:
+				throw std::runtime_error("Unsupported physical type for Decimal" +
+				                         TypeIdToString(result->types[col].InternalType()));
+			}
+			break;
+		}
 		default: // LCOV_EXCL_START
-			// unsupported type for C API
-			D_ASSERT(0);
+			std::string err_msg = "Unsupported type for C API: " + result->types[col].ToString();
+			out->__deprecated_error_message = strdup(err_msg.c_str());
 			return DuckDBError;
 		} // LCOV_EXCL_STOP
 	}
@@ -101438,6 +101524,10 @@ static void DuckdbDestroyColumn(duckdb_column column, idx_t count) {
 	if (column.__deprecated_name) {
 		duckdb_free(column.__deprecated_name);
 	}
+	if (column.internal_data) {
+		auto column_data = (duckdb::DuckDBColumnData *)column.internal_data;
+		delete column_data;
+	}
 }
 
 void duckdb_destroy_result(duckdb_result *result) {
@@ -101652,7 +101742,12 @@ using duckdb::UnsafeFetch;
 template <class SOURCE_TYPE, class RESULT_TYPE, class OP>
 RESULT_TYPE TryCastCInternal(duckdb_result *result, idx_t col, idx_t row) {
 	RESULT_TYPE result_value;
-	if (!OP::template Operation<SOURCE_TYPE, RESULT_TYPE>(UnsafeFetch<SOURCE_TYPE>(result, col, row), result_value)) {
+	try {
+		if (!OP::template Operation<SOURCE_TYPE, RESULT_TYPE>(UnsafeFetch<SOURCE_TYPE>(result, col, row),
+		                                                      result_value)) {
+			return FetchDefaultValue::Operation<RESULT_TYPE>();
+		}
+	} catch (...) {
 		return FetchDefaultValue::Operation<RESULT_TYPE>();
 	}
 	return result_value;
@@ -101704,6 +101799,8 @@ static RESULT_TYPE GetInternalCValue(duckdb_result *result, idx_t col, idx_t row
 		return TryCastCInternal<timestamp_t, RESULT_TYPE, OP>(result, col, row);
 	case DUCKDB_TYPE_HUGEINT:
 		return TryCastCInternal<hugeint_t, RESULT_TYPE, OP>(result, col, row);
+	case DUCKDB_TYPE_DECIMAL:
+		return TryCastCInternal<hugeint_t, RESULT_TYPE, OP>(result, col, row);
 	case DUCKDB_TYPE_INTERVAL:
 		return TryCastCInternal<interval_t, RESULT_TYPE, OP>(result, col, row);
 	case DUCKDB_TYPE_VARCHAR:
@@ -101740,6 +101837,18 @@ int64_t duckdb_value_int64(duckdb_result *result, idx_t col, idx_t row) {
 	return GetInternalCValue<int64_t>(result, col, row);
 }
 
+duckdb_decimal duckdb_value_decimal(duckdb_result *result, idx_t col, idx_t row) {
+	duckdb_decimal result_value;
+
+	auto column_data = (duckdb::DuckDBColumnData *)result->__deprecated_columns[col].internal_data;
+	column_data->type.GetDecimalProperties(result_value.width, result_value.scale);
+
+	auto internal_value = GetInternalCValue<hugeint_t>(result, col, row);
+	result_value.value.lower = internal_value.lower;
+	result_value.value.upper = internal_value.upper;
+	return result_value;
+}
+
 duckdb_hugeint duckdb_value_hugeint(duckdb_result *result, idx_t col, idx_t row) {
 	duckdb_hugeint result_value;
 	auto internal_value = GetInternalCValue<hugeint_t>(result, col, row);
@@ -101833,6 +101942,7 @@ bool duckdb_value_is_null(duckdb_result *result, idx_t col, idx_t row) {
 	return result->__deprecated_columns[col].__deprecated_nullmask[row];
 }
 
+
 //===----------------------------------------------------------------------===//
 //                         DuckDB
 //

package/src/duckdb.hpp

@@ -11,8 +11,8 @@ THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLI
 #pragma once
 #define DUCKDB_AMALGAMATION 1
 #define DUCKDB_AMALGAMATION_EXTENDED 1
-#define DUCKDB_SOURCE_ID "851e8cfd3"
-#define DUCKDB_VERSION "v0.3.3-dev432"
+#define DUCKDB_SOURCE_ID "f7a783d93"
+#define DUCKDB_VERSION "v0.3.3-dev440"
 //===----------------------------------------------------------------------===//
 //                         DuckDB
 //
@@ -12070,7 +12070,9 @@ typedef enum DUCKDB_TYPE {
 	// const char*
 	DUCKDB_TYPE_VARCHAR,
 	// duckdb_blob
-	DUCKDB_TYPE_BLOB
+	DUCKDB_TYPE_BLOB,
+	// decimal
+	DUCKDB_TYPE_DECIMAL
 } duckdb_type;
 
 //! Days are stored as days since 1970-01-01
@@ -12123,6 +12125,13 @@ typedef struct {
 	int64_t upper;
 } duckdb_hugeint;
 
+typedef struct {
+	uint8_t width;
+	uint8_t scale;
+
+	duckdb_hugeint value;
+} duckdb_decimal;
+
 typedef struct {
 	void *data;
 	idx_t size;
@@ -12457,6 +12466,11 @@ DUCKDB_API int64_t duckdb_value_int64(duckdb_result *result, idx_t col, idx_t ro
  */
 DUCKDB_API duckdb_hugeint duckdb_value_hugeint(duckdb_result *result, idx_t col, idx_t row);
 
+/*!
+ * returns: The duckdb_decimal value at the specified location, or 0 if the value cannot be converted.
+ */
+DUCKDB_API duckdb_decimal duckdb_value_decimal(duckdb_result *result, idx_t col, idx_t row);
+
 /*!
  * returns: The uint8_t value at the specified location, or 0 if the value cannot be converted.
  */
@@ -12623,6 +12637,17 @@ If the conversion fails because the double value is too big the result will be 0
 */
 DUCKDB_API duckdb_hugeint duckdb_double_to_hugeint(double val);
 
+//===--------------------------------------------------------------------===//
+// Decimal Helpers
+//===--------------------------------------------------------------------===//
+/*!
+Converts a duckdb_decimal object (as obtained from a `DUCKDB_TYPE_DECIMAL` column) into a double.
+
+* val: The decimal value.
+* returns: The converted `double` element.
+*/
+DUCKDB_API double duckdb_decimal_to_double(duckdb_decimal val);
+
 //===--------------------------------------------------------------------===//
 // Prepared Statements
 //===--------------------------------------------------------------------===//