duckdb 0.6.1-dev30.0 → 0.6.1-dev38.0

package/package.json

@@ -2,7 +2,7 @@
   "name": "duckdb",
   "main": "./lib/duckdb.js",
   "types": "./lib/duckdb.d.ts",
-  "version": "0.6.1-dev30.0",
+  "version": "0.6.1-dev38.0",
   "description": "DuckDB node.js API",
   "gypfile": true,
   "dependencies": {

package/src/duckdb.cpp

@@ -45633,6 +45633,7 @@ hash_t Hash(uint8_t *val, size_t size) {
 
 
 
+
 #include <cmath>
 #include <limits>
 
@@ -46127,6 +46128,13 @@ bool Hugeint::TryConvert(int8_t value, hugeint_t &result) {
 	return true;
 }
 
+template <>
+bool Hugeint::TryConvert(const char *value, hugeint_t &result) {
+	auto len = strlen(value);
+	string_t string_val(value, len);
+	return TryCast::Operation<string_t, hugeint_t>(string_val, result, true);
+}
+
 template <>
 bool Hugeint::TryConvert(int16_t value, hugeint_t &result) {
 	result = HugeintConvertInteger<int16_t>(value);
@@ -131311,14 +131319,16 @@ void UDFWrapper::RegisterAggrFunction(AggregateFunction aggr_function, ClientCon
 
 
 
+
 namespace duckdb {
 
-BaseAppender::BaseAppender(Allocator &allocator) : allocator(allocator), column(0) {
+BaseAppender::BaseAppender(Allocator &allocator, AppenderType type_p)
+    : allocator(allocator), column(0), appender_type(type_p) {
 }
 
-BaseAppender::BaseAppender(Allocator &allocator_p, vector<LogicalType> types_p)
+BaseAppender::BaseAppender(Allocator &allocator_p, vector<LogicalType> types_p, AppenderType type_p)
     : allocator(allocator_p), types(move(types_p)), collection(make_unique<ColumnDataCollection>(allocator, types)),
-      column(0) {
+      column(0), appender_type(type_p) {
 	InitializeChunk();
 }
 
@@ -131338,7 +131348,8 @@ void BaseAppender::Destructor() {
 }
 
 InternalAppender::InternalAppender(ClientContext &context_p, TableCatalogEntry &table_p)
-    : BaseAppender(Allocator::DefaultAllocator(), table_p.GetTypes()), context(context_p), table(table_p) {
+    : BaseAppender(Allocator::DefaultAllocator(), table_p.GetTypes(), AppenderType::PHYSICAL), context(context_p),
+      table(table_p) {
 }
 
 InternalAppender::~InternalAppender() {
@@ -131346,7 +131357,7 @@ InternalAppender::~InternalAppender() {
 }
 
 Appender::Appender(Connection &con, const string &schema_name, const string &table_name)
-    : BaseAppender(Allocator::DefaultAllocator()), context(con.context) {
+    : BaseAppender(Allocator::DefaultAllocator(), AppenderType::LOGICAL), context(con.context) {
 	description = con.TableInfo(schema_name, table_name);
 	if (!description) {
 		// table could not be found
@@ -131390,6 +131401,27 @@ void BaseAppender::AppendValueInternal(Vector &col, SRC input) {
 	FlatVector::GetData<DST>(col)[chunk.size()] = Cast::Operation<SRC, DST>(input);
 }
 
+template <class SRC, class DST>
+void BaseAppender::AppendDecimalValueInternal(Vector &col, SRC input) {
+	switch (appender_type) {
+	case AppenderType::LOGICAL: {
+		auto &type = col.GetType();
+		D_ASSERT(type.id() == LogicalTypeId::DECIMAL);
+		auto width = DecimalType::GetWidth(type);
+		auto scale = DecimalType::GetScale(type);
+		TryCastToDecimal::Operation<SRC, DST>(input, FlatVector::GetData<DST>(col)[chunk.size()], nullptr, width,
+		                                      scale);
+		return;
+	}
+	case AppenderType::PHYSICAL: {
+		AppendValueInternal<SRC, DST>(col, input);
+		return;
+	}
+	default:
+		throw InternalException("Type not implemented for AppenderType");
+	}
+}
+
 template <class T>
 void BaseAppender::AppendValueInternal(T input) {
 	if (column >= types.size()) {
@@ -131435,18 +131467,20 @@ void BaseAppender::AppendValueInternal(T input) {
 		break;
 	case LogicalTypeId::DECIMAL:
 		switch (col.GetType().InternalType()) {
-		case PhysicalType::INT8:
-			AppendValueInternal<T, int8_t>(col, input);
-			break;
 		case PhysicalType::INT16:
-			AppendValueInternal<T, int16_t>(col, input);
+			AppendDecimalValueInternal<T, int16_t>(col, input);
 			break;
 		case PhysicalType::INT32:
-			AppendValueInternal<T, int32_t>(col, input);
+			AppendDecimalValueInternal<T, int32_t>(col, input);
 			break;
-		default:
-			AppendValueInternal<T, int64_t>(col, input);
+		case PhysicalType::INT64:
+			AppendDecimalValueInternal<T, int64_t>(col, input);
 			break;
+		case PhysicalType::INT128:
+			AppendDecimalValueInternal<T, hugeint_t>(col, input);
+			break;
+		default:
+			throw InternalException("Internal type not recognized for Decimal");
 		}
 		break;
 	case LogicalTypeId::DATE:

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 "7f70cbe4c6"
-#define DUCKDB_VERSION "v0.6.1-dev30"
+#define DUCKDB_SOURCE_ID "bce33302a9"
+#define DUCKDB_VERSION "v0.6.1-dev38"
 //===----------------------------------------------------------------------===//
 //                         DuckDB
 //
@@ -8269,6 +8269,8 @@ template <>
 bool Hugeint::TryConvert(double value, hugeint_t &result);
 template <>
 bool Hugeint::TryConvert(long double value, hugeint_t &result);
+template <>
+bool Hugeint::TryConvert(const char *value, hugeint_t &result);
 
 } // namespace duckdb
 
@@ -21706,6 +21708,11 @@ class DuckDB;
 class TableCatalogEntry;
 class Connection;
 
+enum class AppenderType : uint8_t {
+	LOGICAL, // Cast input -> LogicalType
+	PHYSICAL // Cast input -> PhysicalType
+};
+
 //! The Appender class can be used to append elements to a table.
 class BaseAppender {
 protected:
@@ -21721,10 +21728,14 @@ protected:
 	DataChunk chunk;
 	//! The current column to append to
 	idx_t column = 0;
+	//! The type of the appender
+	AppenderType appender_type;
+
+protected:
+	DUCKDB_API BaseAppender(Allocator &allocator, AppenderType type);
+	DUCKDB_API BaseAppender(Allocator &allocator, vector<LogicalType> types, AppenderType type);
 
 public:
-	DUCKDB_API BaseAppender(Allocator &allocator);
-	DUCKDB_API BaseAppender(Allocator &allocator, vector<LogicalType> types);
 	DUCKDB_API virtual ~BaseAppender();
 
 	//! Begins a new row append, after calling this the other AppendX() functions
@@ -21772,6 +21783,8 @@ protected:
 	void AppendValueInternal(T value);
 	template <class SRC, class DST>
 	void AppendValueInternal(Vector &vector, SRC input);
+	template <class SRC, class DST>
+	void AppendDecimalValueInternal(Vector &vector, SRC input);
 
 	void AppendRowRecursive() {
 		EndRow();