duckdb 0.6.1-dev5.0 → 0.6.1-dev71.0

package/package.json

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

package/src/duckdb.cpp

@@ -6493,6 +6493,9 @@ AllocatedData::AllocatedData() : allocator(nullptr), pointer(nullptr), allocated
 
 AllocatedData::AllocatedData(Allocator &allocator, data_ptr_t pointer, idx_t allocated_size)
     : allocator(&allocator), pointer(pointer), allocated_size(allocated_size) {
+	if (!pointer) {
+		throw InternalException("AllocatedData object constructed with nullptr");
+	}
 }
 AllocatedData::~AllocatedData() {
 	Reset();
@@ -6584,11 +6587,19 @@ Allocator::~Allocator() {
 
 data_ptr_t Allocator::AllocateData(idx_t size) {
 	D_ASSERT(size > 0);
+	if (size >= MAXIMUM_ALLOC_SIZE) {
+		D_ASSERT(false);
+		throw InternalException("Requested allocation size of %llu is out of range - maximum allocation size is %llu",
+		                        size, MAXIMUM_ALLOC_SIZE);
+	}
 	auto result = allocate_function(private_data.get(), size);
 #ifdef DEBUG
 	D_ASSERT(private_data);
 	private_data->debug_info->AllocateData(result, size);
 #endif
+	if (!result) {
+		throw std::bad_alloc();
+	}
 	return result;
 }
 
@@ -6608,11 +6619,20 @@ data_ptr_t Allocator::ReallocateData(data_ptr_t pointer, idx_t old_size, idx_t s
 	if (!pointer) {
 		return nullptr;
 	}
+	if (size >= MAXIMUM_ALLOC_SIZE) {
+		D_ASSERT(false);
+		throw InternalException(
+		    "Requested re-allocation size of %llu is out of range - maximum allocation size is %llu", size,
+		    MAXIMUM_ALLOC_SIZE);
+	}
 	auto new_pointer = reallocate_function(private_data.get(), pointer, old_size, size);
 #ifdef DEBUG
 	D_ASSERT(private_data);
 	private_data->debug_info->ReallocateData(pointer, new_pointer, old_size, size);
 #endif
+	if (!new_pointer) {
+		throw std::bad_alloc();
+	}
 	return new_pointer;
 }
 
@@ -18593,6 +18613,7 @@ FileType FileHandle::GetType() {
 
 
 
+
 #include <limits>
 #include <cstring>
 #include <cmath>
@@ -22487,6 +22508,7 @@ unique_ptr<FileSystem> FileSystem::CreateLocal() {
 
 
 
+
 namespace duckdb {
 
 struct ConvertToString {
@@ -24109,8 +24131,11 @@ string_t StringCastFromDecimal::Operation(hugeint_t input, uint8_t width, uint8_
 
 
 
+
 namespace duckdb {
 
+struct interval_t;
+
 struct MultiplyOperator {
 	template <class TA, class TB, class TR>
 	static inline TR Operation(TA left, TB right) {
@@ -45487,6 +45512,7 @@ string Decimal::ToString(hugeint_t value, uint8_t width, uint8_t scale) {
 
 
 
+
 #include <functional>
 #include <cmath>
 
@@ -45627,6 +45653,7 @@ hash_t Hash(uint8_t *val, size_t size) {
 
 
 
+
 #include <cmath>
 #include <limits>
 
@@ -46121,6 +46148,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);
@@ -46720,6 +46754,7 @@ DUCKDB_API DatePartSpecifier GetDatePartSpecifier(const string &specifier);
 
 
 
+
 namespace duckdb {
 
 struct AddOperator {
@@ -46847,8 +46882,14 @@ dtime_t AddTimeOperator::Operation(interval_t left, dtime_t right);
 
 
 
+
 namespace duckdb {
 
+struct interval_t;
+struct date_t;
+struct timestamp_t;
+struct dtime_t;
+
 struct SubtractOperator {
 	template <class TA, class TB, class TR>
 	static inline TR Operation(TA left, TB right) {
@@ -82307,6 +82348,7 @@ public:
 
 
 
+
 namespace duckdb {
 
 PhysicalBatchInsert::PhysicalBatchInsert(vector<LogicalType> types, TableCatalogEntry *table,
@@ -82349,22 +82391,9 @@ public:
 		if (Empty()) {
 			return nullptr;
 		}
-		unique_ptr<RowGroupCollection> new_collection;
-		if (current_collections.size() == 1) {
-			// we have gathered only one row group collection: merge it directly
-			new_collection = move(current_collections[0]);
-		} else {
+		unique_ptr<RowGroupCollection> new_collection = move(current_collections[0]);
+		if (current_collections.size() > 1) {
 			// we have gathered multiple collections: create one big collection and merge that
-			// find the biggest collection
-			idx_t biggest_index = 0;
-			for (idx_t i = 1; i < current_collections.size(); i++) {
-				D_ASSERT(current_collections[i]);
-				if (current_collections[i]->GetTotalRows() > current_collections[biggest_index]->GetTotalRows()) {
-					biggest_index = i;
-				}
-			}
-			// now append all the other collections to this collection
-			new_collection = move(current_collections[biggest_index]);
 			auto &types = new_collection->GetTypes();
 			TableAppendState append_state;
 			new_collection->InitializeAppend(append_state);
@@ -106724,16 +106753,16 @@ struct StructDatePart {
 				const auto idx = rdata.sel->get_index(i);
 				if (arg_valid.RowIsValid(idx)) {
 					if (Value::IsFinite(tdata[idx])) {
-						DatePart::StructOperator::Operation(part_values.data(), tdata[idx], idx, part_mask);
+						DatePart::StructOperator::Operation(part_values.data(), tdata[idx], i, part_mask);
 					} else {
 						for (auto &child_entry : child_entries) {
-							FlatVector::Validity(*child_entry).SetInvalid(idx);
+							FlatVector::Validity(*child_entry).SetInvalid(i);
 						}
 					}
 				} else {
-					res_valid.SetInvalid(idx);
+					res_valid.SetInvalid(i);
 					for (auto &child_entry : child_entries) {
-						FlatVector::Validity(*child_entry).SetInvalid(idx);
+						FlatVector::Validity(*child_entry).SetInvalid(i);
 					}
 				}
 			}
@@ -131298,14 +131327,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();
 }
 
@@ -131325,7 +131356,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() {
@@ -131333,7 +131365,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
@@ -131377,6 +131409,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()) {
@@ -131422,18 +131475,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:
@@ -138304,12 +138359,19 @@ public:
 	//! Creates and caches a new DB Instance (Fails if a cached instance already exists)
 	shared_ptr<DuckDB> CreateInstance(const string &database, DBConfig &config_dict, bool cache_instance = true);
 
+	//! Creates and caches a new DB Instance (Fails if a cached instance already exists)
+	shared_ptr<DuckDB> GetOrCreateInstance(const string &database, DBConfig &config_dict, bool cache_instance);
+
 private:
 	//! A map with the cached instances <absolute_path/instance>
 	unordered_map<string, weak_ptr<DuckDB>> db_instances;
 
 	//! Lock to alter cache
 	mutex cache_lock;
+
+private:
+	shared_ptr<DuckDB> GetInstanceInternal(const string &database, const DBConfig &config_dict);
+	shared_ptr<DuckDB> CreateInstanceInternal(const string &database, DBConfig &config_dict, bool cache_instance);
 };
 } // namespace duckdb
 
@@ -138330,8 +138392,7 @@ string GetDBAbsolutePath(const string &database) {
 	return FileSystem::JoinPath(FileSystem::GetWorkingDirectory(), database);
 }
 
-shared_ptr<DuckDB> DBInstanceCache::GetInstance(const string &database, const DBConfig &config) {
-	lock_guard<mutex> l(cache_lock);
+shared_ptr<DuckDB> DBInstanceCache::GetInstanceInternal(const string &database, const DBConfig &config) {
 	shared_ptr<DuckDB> db_instance;
 	auto abs_database_path = GetDBAbsolutePath(database);
 	if (db_instances.find(abs_database_path) != db_instances.end()) {
@@ -138350,8 +138411,13 @@ shared_ptr<DuckDB> DBInstanceCache::GetInstance(const string &database, const DB
 	return db_instance;
 }
 
-shared_ptr<DuckDB> DBInstanceCache::CreateInstance(const string &database, DBConfig &config, bool cache_instance) {
+shared_ptr<DuckDB> DBInstanceCache::GetInstance(const string &database, const DBConfig &config) {
 	lock_guard<mutex> l(cache_lock);
+	return GetInstanceInternal(database, config);
+}
+
+shared_ptr<DuckDB> DBInstanceCache::CreateInstanceInternal(const string &database, DBConfig &config,
+                                                           bool cache_instance) {
 	auto abs_database_path = GetDBAbsolutePath(database);
 	if (db_instances.find(abs_database_path) != db_instances.end()) {
 		throw duckdb::Exception(ExceptionType::CONNECTION,
@@ -138369,6 +138435,23 @@ shared_ptr<DuckDB> DBInstanceCache::CreateInstance(const string &database, DBCon
 	return db_instance;
 }
 
+shared_ptr<DuckDB> DBInstanceCache::CreateInstance(const string &database, DBConfig &config, bool cache_instance) {
+	lock_guard<mutex> l(cache_lock);
+	return CreateInstanceInternal(database, config, cache_instance);
+}
+
+shared_ptr<DuckDB> DBInstanceCache::GetOrCreateInstance(const string &database, DBConfig &config_dict,
+                                                        bool cache_instance) {
+	lock_guard<mutex> l(cache_lock);
+	if (cache_instance) {
+		auto instance = GetInstanceInternal(database, config_dict);
+		if (instance) {
+			return instance;
+		}
+	}
+	return CreateInstanceInternal(database, config_dict, cache_instance);
+}
+
 } // namespace duckdb
 
 
@@ -155444,7 +155527,6 @@ unique_ptr<LogicalOperator> FilterPullup::PullupJoin(unique_ptr<LogicalOperator>
 	case JoinType::LEFT:
 	case JoinType::ANTI:
 	case JoinType::SEMI: {
-		can_add_column = true;
 		return PullupFromLeft(move(op));
 	}
 	default:
@@ -157982,6 +158064,8 @@ unique_ptr<LogicalOperator> FilterPullup::PullupBothSide(unique_ptr<LogicalOpera
 	FilterPullup right_pullup(true, can_add_column);
 	op->children[0] = left_pullup.Rewrite(move(op->children[0]));
 	op->children[1] = right_pullup.Rewrite(move(op->children[1]));
+	D_ASSERT(left_pullup.can_add_column == can_add_column);
+	D_ASSERT(right_pullup.can_add_column == can_add_column);
 
 	// merging filter expressions
 	for (idx_t i = 0; i < right_pullup.filters_expr_pullup.size(); ++i) {
@@ -158764,6 +158848,9 @@ unique_ptr<LogicalOperator> FilterPushdown::PushdownSetOperation(unique_ptr<Logi
 	D_ASSERT(op->children.size() == 2);
 	auto left_bindings = op->children[0]->GetColumnBindings();
 	auto right_bindings = op->children[1]->GetColumnBindings();
+	if (left_bindings.size() != right_bindings.size()) {
+		throw InternalException("Filter pushdown - set operation LHS and RHS have incompatible counts");
+	}
 
 	// pushdown into set operation, we can duplicate the condition and pushdown the expressions into both sides
 	FilterPushdown left_pushdown(optimizer), right_pushdown(optimizer);
@@ -182824,6 +182911,7 @@ bool Transformer::TransformGroupBy(duckdb_libpgquery::PGList *group, SelectNode
 
 
 
+
 namespace duckdb {
 
 bool Transformer::TransformOrderBy(duckdb_libpgquery::PGList *order, vector<OrderByNode> &result) {
@@ -182857,6 +182945,13 @@ bool Transformer::TransformOrderBy(duckdb_libpgquery::PGList *order, vector<Orde
 				throw NotImplementedException("Unimplemented order by type");
 			}
 			auto order_expression = TransformExpression(target);
+			if (order_expression->GetExpressionClass() == ExpressionClass::STAR) {
+				auto &star_expr = (StarExpression &)*order_expression;
+				D_ASSERT(star_expr.relation_name.empty());
+				if (star_expr.columns) {
+					throw ParserException("COLUMNS expr is not supported in ORDER BY");
+				}
+			}
 			result.emplace_back(type, null_order, move(order_expression));
 		} else {
 			throw NotImplementedException("ORDER BY list member type %d\n", temp->type);