duckdb 0.3.5-dev2.0 → 0.3.5-dev22.0

package/package.json

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

package/src/duckdb.cpp

@@ -103872,44 +103872,74 @@ void BaseAppender::AppendValueInternal(T input) {
 		throw InvalidInputException("Too many appends for chunk!");
 	}
 	auto &col = chunk->data[column];
-	switch (col.GetType().InternalType()) {
-	case PhysicalType::BOOL:
+	switch (col.GetType().id()) {
+	case LogicalTypeId::BOOLEAN:
 		AppendValueInternal<T, bool>(col, input);
 		break;
-	case PhysicalType::UINT8:
+	case LogicalTypeId::UTINYINT:
 		AppendValueInternal<T, uint8_t>(col, input);
 		break;
-	case PhysicalType::INT8:
+	case LogicalTypeId::TINYINT:
 		AppendValueInternal<T, int8_t>(col, input);
 		break;
-	case PhysicalType::UINT16:
+	case LogicalTypeId::USMALLINT:
 		AppendValueInternal<T, uint16_t>(col, input);
 		break;
-	case PhysicalType::INT16:
+	case LogicalTypeId::SMALLINT:
 		AppendValueInternal<T, int16_t>(col, input);
 		break;
-	case PhysicalType::UINT32:
+	case LogicalTypeId::UINTEGER:
 		AppendValueInternal<T, uint32_t>(col, input);
 		break;
-	case PhysicalType::INT32:
+	case LogicalTypeId::INTEGER:
 		AppendValueInternal<T, int32_t>(col, input);
 		break;
-	case PhysicalType::UINT64:
+	case LogicalTypeId::UBIGINT:
 		AppendValueInternal<T, uint64_t>(col, input);
 		break;
-	case PhysicalType::INT64:
+	case LogicalTypeId::BIGINT:
 		AppendValueInternal<T, int64_t>(col, input);
 		break;
-	case PhysicalType::INT128:
+	case LogicalTypeId::HUGEINT:
 		AppendValueInternal<T, hugeint_t>(col, input);
 		break;
-	case PhysicalType::FLOAT:
+	case LogicalTypeId::FLOAT:
 		AppendValueInternal<T, float>(col, input);
 		break;
-	case PhysicalType::DOUBLE:
+	case LogicalTypeId::DOUBLE:
 		AppendValueInternal<T, double>(col, input);
 		break;
-	case PhysicalType::VARCHAR:
+	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);
+			break;
+		case PhysicalType::INT32:
+			AppendValueInternal<T, int32_t>(col, input);
+			break;
+		default:
+			AppendValueInternal<T, int64_t>(col, input);
+			break;
+		}
+		break;
+	case LogicalTypeId::DATE:
+		AppendValueInternal<T, date_t>(col, input);
+		break;
+	case LogicalTypeId::TIMESTAMP:
+	case LogicalTypeId::TIMESTAMP_TZ:
+		AppendValueInternal<T, timestamp_t>(col, input);
+		break;
+	case LogicalTypeId::TIME:
+	case LogicalTypeId::TIME_TZ:
+		AppendValueInternal<T, dtime_t>(col, input);
+		break;
+	case LogicalTypeId::INTERVAL:
+		AppendValueInternal<T, interval_t>(col, input);
+		break;
+	case LogicalTypeId::VARCHAR:
 		FlatVector::GetData<string_t>(col)[chunk->size()] = StringCast::Operation<T>(input, col);
 		break;
 	default:
@@ -103995,17 +104025,17 @@ void BaseAppender::Append(double value) {
 
 template <>
 void BaseAppender::Append(date_t value) {
-	AppendValueInternal<int32_t>(value.days);
+	AppendValueInternal<date_t>(value);
 }
 
 template <>
 void BaseAppender::Append(dtime_t value) {
-	AppendValueInternal<int64_t>(value.micros);
+	AppendValueInternal<dtime_t>(value);
 }
 
 template <>
 void BaseAppender::Append(timestamp_t value) {
-	AppendValueInternal<int64_t>(value.value);
+	AppendValueInternal<timestamp_t>(value);
 }
 
 template <>
@@ -105104,6 +105134,24 @@ duckdb_logical_type duckdb_create_logical_type(duckdb_type type) {
 	return new duckdb::LogicalType(duckdb::ConvertCTypeToCPP(type));
 }
 
+duckdb_logical_type duckdb_create_list_type(duckdb_logical_type type) {
+	if (!type) {
+		return nullptr;
+	}
+	duckdb::LogicalType *ltype = new duckdb::LogicalType;
+	*ltype = duckdb::LogicalType::LIST(*(duckdb::LogicalType *)type);
+	return ltype;
+}
+
+duckdb_logical_type duckdb_create_map_type(duckdb_logical_type key_type, duckdb_logical_type value_type) {
+	if (!key_type || !value_type) {
+		return nullptr;
+	}
+	duckdb::LogicalType *mtype = new duckdb::LogicalType;
+	*mtype = duckdb::LogicalType::MAP(*(duckdb::LogicalType *)key_type, *(duckdb::LogicalType *)value_type);
+	return mtype;
+}
+
 duckdb_logical_type duckdb_create_decimal_type(uint8_t width, uint8_t scale) {
 	return new duckdb::LogicalType(duckdb::LogicalType::DECIMAL(width, scale));
 }
@@ -105223,6 +105271,28 @@ duckdb_logical_type duckdb_list_type_child_type(duckdb_logical_type type) {
 	return new duckdb::LogicalType(duckdb::ListType::GetChildType(ltype));
 }
 
+duckdb_logical_type duckdb_map_type_key_type(duckdb_logical_type type) {
+	if (!type) {
+		return nullptr;
+	}
+	auto &mtype = *((duckdb::LogicalType *)type);
+	if (mtype.id() != duckdb::LogicalTypeId::MAP) {
+		return nullptr;
+	}
+	return new duckdb::LogicalType(duckdb::MapType::KeyType(mtype));
+}
+
+duckdb_logical_type duckdb_map_type_value_type(duckdb_logical_type type) {
+	if (!type) {
+		return nullptr;
+	}
+	auto &mtype = *((duckdb::LogicalType *)type);
+	if (mtype.id() != duckdb::LogicalTypeId::MAP) {
+		return nullptr;
+	}
+	return new duckdb::LogicalType(duckdb::MapType::ValueType(mtype));
+}
+
 idx_t duckdb_struct_type_child_count(duckdb_logical_type type) {
 	if (!type) {
 		return 0;

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 "0c68c88e5"
-#define DUCKDB_VERSION "v0.3.5-dev2"
+#define DUCKDB_SOURCE_ID "339bd4003"
+#define DUCKDB_VERSION "v0.3.5-dev22"
 //===----------------------------------------------------------------------===//
 //                         DuckDB
 //
@@ -15975,6 +15975,24 @@ This should not be used with `DUCKDB_TYPE_DECIMAL`.
 */
 DUCKDB_API duckdb_logical_type duckdb_create_logical_type(duckdb_type type);
 
+/*!
+Creates a list type from its child type.
+The resulting type should be destroyed with `duckdb_destroy_logical_type`.
+
+* type: The child type of list type to create.
+* returns: The logical type.
+*/
+DUCKDB_API duckdb_logical_type duckdb_create_list_type(duckdb_logical_type type);
+
+/*!
+Creates a map type from its key type and value type.
+The resulting type should be destroyed with `duckdb_destroy_logical_type`.
+
+* type: The key type and value type of map type to create.
+* returns: The logical type.
+*/
+DUCKDB_API duckdb_logical_type duckdb_create_map_type(duckdb_logical_type key_type, duckdb_logical_type value_type);
+
 /*!
 Creates a `duckdb_logical_type` of type decimal with the specified width and scale
 The resulting type should be destroyed with `duckdb_destroy_logical_type`.
@@ -16054,6 +16072,26 @@ The result must be freed with `duckdb_destroy_logical_type`
 */
 DUCKDB_API duckdb_logical_type duckdb_list_type_child_type(duckdb_logical_type type);
 
+/*!
+Retrieves the key type of the given map type.
+
+The result must be freed with `duckdb_destroy_logical_type`
+
+* type: The logical type object
+* returns: The key type of the map type. Must be destroyed with `duckdb_destroy_logical_type`.
+*/
+DUCKDB_API duckdb_logical_type duckdb_map_type_key_type(duckdb_logical_type type);
+
+/*!
+Retrieves the value type of the given map type.
+
+The result must be freed with `duckdb_destroy_logical_type`
+
+* type: The logical type object
+* returns: The value type of the map type. Must be destroyed with `duckdb_destroy_logical_type`.
+*/
+DUCKDB_API duckdb_logical_type duckdb_map_type_value_type(duckdb_logical_type type);
+
 /*!
 Returns the number of children of a struct type.