duckdb 0.8.1-dev0.0 → 0.8.1-dev23.0

package/package.json

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

package/src/duckdb/src/catalog/catalog.cpp

@@ -532,10 +532,6 @@ CatalogEntryLookup Catalog::LookupEntry(ClientContext &context, CatalogType type
 	reference_set_t<SchemaCatalogEntry> schemas;
 	if (IsInvalidSchema(schema)) {
 		// try all schemas for this catalog
-		auto catalog_name = GetName();
-		if (catalog_name == DatabaseManager::GetDefaultDatabase(context)) {
-			catalog_name = INVALID_CATALOG;
-		}
 		auto entries = GetCatalogEntries(context, GetName(), INVALID_SCHEMA);
 		for (auto &entry : entries) {
 			auto &candidate_schema = entry.schema;

package/src/duckdb/src/common/types/vector.cpp

@@ -100,6 +100,9 @@ void Vector::Reference(const Value &value) {
 }
 
 void Vector::Reference(Vector &other) {
+	if (other.GetType().id() != GetType().id()) {
+		throw InternalException("Vector::Reference used on vector of different type");
+	}
 	D_ASSERT(other.GetType() == GetType());
 	Reinterpret(other);
 }

package/src/duckdb/src/execution/expression_executor.cpp

@@ -180,6 +180,11 @@ void ExpressionExecutor::Execute(const Expression &expr, ExpressionState *state,
 	if (count == 0) {
 		return;
 	}
+	if (result.GetType().id() != expr.return_type.id()) {
+		throw InternalException(
+		    "ExpressionExecutor::Execute called with a result vector of type %s that does not match expression type %s",
+		    result.GetType(), expr.return_type);
+	}
 	switch (expr.expression_class) {
 	case ExpressionClass::BOUND_BETWEEN:
 		Execute((const BoundBetweenExpression &)expr, state, sel, count, result);

package/src/duckdb/src/execution/operator/persistent/csv_reader_options.cpp

@@ -177,6 +177,8 @@ void BufferedCSVReaderOptions::SetReadOption(const string &loption, const Value
 		null_padding = ParseBoolean(value, loption);
 	} else if (loption == "allow_quoted_nulls") {
 		allow_quoted_nulls = ParseBoolean(value, loption);
+	} else if (loption == "parallel") {
+		parallel_mode = ParseBoolean(value, loption) ? ParallelMode::PARALLEL : ParallelMode::SINGLE_THREADED;
 	} else {
 		throw BinderException("Unrecognized option for CSV reader \"%s\"", loption);
 	}

package/src/duckdb/src/function/table/read_csv.cpp

@@ -176,9 +176,6 @@ static unique_ptr<FunctionData> ReadCSVBind(ClientContext &context, TableFunctio
 			options.all_varchar = BooleanValue::Get(kv.second);
 		} else if (loption == "normalize_names") {
 			options.normalize_names = BooleanValue::Get(kv.second);
-		} else if (loption == "parallel") {
-			options.parallel_mode =
-			    BooleanValue::Get(kv.second) ? ParallelMode::PARALLEL : ParallelMode::SINGLE_THREADED;
 		} else {
 			options.SetReadOption(loption, kv.second, names);
 		}

package/src/duckdb/src/function/table/version/pragma_version.cpp

@@ -1,8 +1,8 @@
 #ifndef DUCKDB_VERSION
-#define DUCKDB_VERSION "0.8.0"
+#define DUCKDB_VERSION "0.8.1-dev23"
 #endif
 #ifndef DUCKDB_SOURCE_ID
-#define DUCKDB_SOURCE_ID "e8e4cea5ec"
+#define DUCKDB_SOURCE_ID "950d3d9532"
 #endif
 #include "duckdb/function/table/system_functions.hpp"
 #include "duckdb/main/database.hpp"

package/src/duckdb/src/optimizer/join_order/join_order_optimizer.cpp

@@ -24,13 +24,10 @@ namespace duckdb {
 
 //! Returns true if A and B are disjoint, false otherwise
 template <class T>
-static bool Disjoint(unordered_set<T> &a, unordered_set<T> &b) {
-	for (auto &entry : a) {
-		if (b.find(entry) != b.end()) {
-			return false;
-		}
-	}
-	return true;
+static bool Disjoint(const unordered_set<T> &a, const unordered_set<T> &b) {
+	return std::all_of(a.begin(), a.end(), [&b](typename std::unordered_set<T>::const_reference entry) {
+		return b.find(entry) == b.end();
+	});
 }
 
 //! Extract the set of relations referred to inside an expression

package/src/duckdb/src/planner/binder/statement/bind_create.cpp

@@ -243,18 +243,26 @@ void Binder::BindLogicalType(ClientContext &context, LogicalType &type, optional
 		type = LogicalType::UNION(member_types);
 		type.SetAlias(alias);
 	} else if (type.id() == LogicalTypeId::USER) {
-		auto &user_type_name = UserType::GetTypeName(type);
+		auto user_type_name = UserType::GetTypeName(type);
 		if (catalog) {
+			// The search order is:
+			// 1) In the same schema as the table
+			// 2) In the same catalog
+			// 3) System catalog
 			type = catalog->GetType(context, schema, user_type_name, OnEntryNotFound::RETURN_NULL);
+
 			if (type.id() == LogicalTypeId::INVALID) {
-				// look in the system catalog if the type was not found
-				type = Catalog::GetType(context, SYSTEM_CATALOG, schema, user_type_name);
+				type = catalog->GetType(context, INVALID_SCHEMA, user_type_name, OnEntryNotFound::RETURN_NULL);
+			}
+
+			if (type.id() == LogicalTypeId::INVALID) {
+				type = Catalog::GetType(context, INVALID_CATALOG, schema, user_type_name);
 			}
 		} else {
 			type = Catalog::GetType(context, INVALID_CATALOG, schema, user_type_name);
 		}
 	} else if (type.id() == LogicalTypeId::ENUM) {
-		auto &enum_type_name = EnumType::GetTypeName(type);
+		auto enum_type_name = EnumType::GetTypeName(type);
 		optional_ptr<TypeCatalogEntry> enum_type_catalog;
 		if (catalog) {
 			enum_type_catalog =

package/src/duckdb/src/storage/table/list_column_data.cpp

@@ -62,11 +62,11 @@ void ListColumnData::InitializeScanWithOffset(ColumnScanState &state, idx_t row_
 
 	// we need to read the list at position row_idx to get the correct row offset of the child
 	auto child_offset = row_idx == start ? 0 : FetchListOffset(row_idx - 1);
-
 	D_ASSERT(child_offset <= child_column->GetMaxEntry());
 	if (child_offset < child_column->GetMaxEntry()) {
 		child_column->InitializeScanWithOffset(state.child_states[1], start + child_offset);
 	}
+	state.last_offset = child_offset;
 }
 
 idx_t ListColumnData::Scan(TransactionData transaction, idx_t vector_index, ColumnScanState &state, Vector &result) {
@@ -108,9 +108,10 @@ idx_t ListColumnData::ScanCount(ColumnScanState &state, Vector &result, idx_t co
 
 	if (child_scan_count > 0) {
 		auto &child_entry = ListVector::GetEntry(result);
-		D_ASSERT(child_entry.GetType().InternalType() == PhysicalType::STRUCT ||
-		         state.child_states[1].row_index + child_scan_count <=
-		             child_column->start + child_column->GetMaxEntry());
+		if (child_entry.GetType().InternalType() != PhysicalType::STRUCT &&
+		    state.child_states[1].row_index + child_scan_count > child_column->start + child_column->GetMaxEntry()) {
+			throw InternalException("ListColumnData::ScanCount - internal list scan offset is out of range");
+		}
 		child_column->ScanCount(state.child_states[1], child_entry, child_scan_count);
 	}
 	state.last_offset = last_entry;