duckdb 0.6.2-dev2115.0 → 0.6.2-dev2226.0

package/src/duckdb/src/execution/operator/projection/physical_unnest.cpp

@@ -11,7 +11,11 @@ namespace duckdb {
 class UnnestOperatorState : public OperatorState {
 public:
 	UnnestOperatorState(ClientContext &context, const vector<unique_ptr<Expression>> &select_list)
-	    : parent_position(0), list_position(0), list_length(-1), first_fetch(true), executor(context) {
+	    : current_row(0), list_position(0), longest_list_length(DConstants::INVALID_INDEX), first_fetch(true),
+	      executor(context) {
+
+		// for each UNNEST in the select_list, we add the child expression to the expression executor
+		// and set the return type in the list_data chunk, which will contain the evaluated expression results
 		vector<LogicalType> list_data_types;
 		for (auto &exp : select_list) {
 			D_ASSERT(exp->type == ExpressionType::BOUND_UNNEST);
@@ -19,6 +23,7 @@ public:
 			list_data_types.push_back(bue->child->return_type);
 			executor.AddExpression(*bue->child.get());
 		}
+
 		auto &allocator = Allocator::Get(context);
 		list_data.Initialize(allocator, list_data_types);
 
@@ -26,18 +31,50 @@ public:
 		list_child_data.resize(list_data.ColumnCount());
 	}
 
-	idx_t parent_position;
+	idx_t current_row;
 	idx_t list_position;
-	int64_t list_length;
+	idx_t longest_list_length;
 	bool first_fetch;
 
 	ExpressionExecutor executor;
 	DataChunk list_data;
 	vector<UnifiedVectorFormat> list_vector_data;
 	vector<UnifiedVectorFormat> list_child_data;
+
+public:
+	//! Reset the fields of the unnest operator state
+	void Reset();
+	//! Set the longest list's length for the current row
+	void SetLongestListLength();
 };
 
-// this implements a sorted window functions variant
+void UnnestOperatorState::Reset() {
+	current_row = 0;
+	list_position = 0;
+	longest_list_length = DConstants::INVALID_INDEX;
+	first_fetch = true;
+}
+
+void UnnestOperatorState::SetLongestListLength() {
+
+	longest_list_length = 0;
+	for (idx_t col_idx = 0; col_idx < list_data.ColumnCount(); col_idx++) {
+
+		auto &vector_data = list_vector_data[col_idx];
+		auto current_idx = vector_data.sel->get_index(current_row);
+
+		if (vector_data.validity.RowIsValid(current_idx)) {
+
+			// check if this list is longer
+			auto list_data = (list_entry_t *)vector_data.data;
+			auto list_entry = list_data[current_idx];
+			if (list_entry.length > longest_list_length) {
+				longest_list_length = list_entry.length;
+			}
+		}
+	}
+}
+
 PhysicalUnnest::PhysicalUnnest(vector<LogicalType> types, vector<unique_ptr<Expression>> select_list,
                                idx_t estimated_cardinality, PhysicalOperatorType type)
     : PhysicalOperator(type, std::move(types), estimated_cardinality), select_list(std::move(select_list)) {
@@ -45,6 +82,8 @@ PhysicalUnnest::PhysicalUnnest(vector<LogicalType> types, vector<unique_ptr<Expr
 }
 
 static void UnnestNull(idx_t start, idx_t end, Vector &result) {
+
+	D_ASSERT(result.GetVectorType() == VectorType::FLAT_VECTOR);
 	auto &validity = FlatVector::Validity(result);
 	for (idx_t i = start; i < end; i++) {
 		validity.SetInvalid(i);
@@ -58,14 +97,17 @@ static void UnnestNull(idx_t start, idx_t end, Vector &result) {
 }
 
 template <class T>
-static void TemplatedUnnest(UnifiedVectorFormat &vdata, idx_t start, idx_t end, Vector &result) {
-	auto source_data = (T *)vdata.data;
-	auto &source_mask = vdata.validity;
+static void TemplatedUnnest(UnifiedVectorFormat &vector_data, idx_t start, idx_t end, Vector &result) {
+
+	auto source_data = (T *)vector_data.data;
+	auto &source_mask = vector_data.validity;
+
+	D_ASSERT(result.GetVectorType() == VectorType::FLAT_VECTOR);
 	auto result_data = FlatVector::GetData<T>(result);
 	auto &result_mask = FlatVector::Validity(result);
 
 	for (idx_t i = start; i < end; i++) {
-		auto source_idx = vdata.sel->get_index(i);
+		auto source_idx = vector_data.sel->get_index(i);
 		auto target_idx = i - start;
 		if (source_mask.RowIsValid(source_idx)) {
 			result_data[target_idx] = source_data[source_idx];
@@ -76,84 +118,131 @@ static void TemplatedUnnest(UnifiedVectorFormat &vdata, idx_t start, idx_t end,
 	}
 }
 
-static void UnnestValidity(UnifiedVectorFormat &vdata, idx_t start, idx_t end, Vector &result) {
-	auto &source_mask = vdata.validity;
+static void UnnestValidity(UnifiedVectorFormat &vector_data, idx_t start, idx_t end, Vector &result) {
+
+	auto &source_mask = vector_data.validity;
+	D_ASSERT(result.GetVectorType() == VectorType::FLAT_VECTOR);
 	auto &result_mask = FlatVector::Validity(result);
 
 	for (idx_t i = start; i < end; i++) {
-		auto source_idx = vdata.sel->get_index(i);
+		auto source_idx = vector_data.sel->get_index(i);
 		auto target_idx = i - start;
 		result_mask.Set(target_idx, source_mask.RowIsValid(source_idx));
 	}
 }
 
-static void UnnestVector(UnifiedVectorFormat &vdata, Vector &source, idx_t list_size, idx_t start, idx_t end,
-                         Vector &result) {
-	D_ASSERT(source.GetType() == result.GetType());
+static void UnnestVector(UnifiedVectorFormat &child_vector_data, Vector &child_vector, idx_t list_size, idx_t start,
+                         idx_t end, Vector &result) {
+
+	D_ASSERT(child_vector.GetType() == result.GetType());
 	switch (result.GetType().InternalType()) {
 	case PhysicalType::BOOL:
 	case PhysicalType::INT8:
-		TemplatedUnnest<int8_t>(vdata, start, end, result);
+		TemplatedUnnest<int8_t>(child_vector_data, start, end, result);
 		break;
 	case PhysicalType::INT16:
-		TemplatedUnnest<int16_t>(vdata, start, end, result);
+		TemplatedUnnest<int16_t>(child_vector_data, start, end, result);
 		break;
 	case PhysicalType::INT32:
-		TemplatedUnnest<int32_t>(vdata, start, end, result);
+		TemplatedUnnest<int32_t>(child_vector_data, start, end, result);
 		break;
 	case PhysicalType::INT64:
-		TemplatedUnnest<int64_t>(vdata, start, end, result);
+		TemplatedUnnest<int64_t>(child_vector_data, start, end, result);
 		break;
 	case PhysicalType::INT128:
-		TemplatedUnnest<hugeint_t>(vdata, start, end, result);
+		TemplatedUnnest<hugeint_t>(child_vector_data, start, end, result);
 		break;
 	case PhysicalType::UINT8:
-		TemplatedUnnest<uint8_t>(vdata, start, end, result);
+		TemplatedUnnest<uint8_t>(child_vector_data, start, end, result);
 		break;
 	case PhysicalType::UINT16:
-		TemplatedUnnest<uint16_t>(vdata, start, end, result);
+		TemplatedUnnest<uint16_t>(child_vector_data, start, end, result);
 		break;
 	case PhysicalType::UINT32:
-		TemplatedUnnest<uint32_t>(vdata, start, end, result);
+		TemplatedUnnest<uint32_t>(child_vector_data, start, end, result);
 		break;
 	case PhysicalType::UINT64:
-		TemplatedUnnest<uint64_t>(vdata, start, end, result);
+		TemplatedUnnest<uint64_t>(child_vector_data, start, end, result);
 		break;
 	case PhysicalType::FLOAT:
-		TemplatedUnnest<float>(vdata, start, end, result);
+		TemplatedUnnest<float>(child_vector_data, start, end, result);
 		break;
 	case PhysicalType::DOUBLE:
-		TemplatedUnnest<double>(vdata, start, end, result);
+		TemplatedUnnest<double>(child_vector_data, start, end, result);
 		break;
 	case PhysicalType::INTERVAL:
-		TemplatedUnnest<interval_t>(vdata, start, end, result);
+		TemplatedUnnest<interval_t>(child_vector_data, start, end, result);
 		break;
 	case PhysicalType::VARCHAR:
-		TemplatedUnnest<string_t>(vdata, start, end, result);
+		TemplatedUnnest<string_t>(child_vector_data, start, end, result);
 		break;
 	case PhysicalType::LIST: {
+		// the child vector of result now references the child vector source
+		// FIXME: only reference relevant children (start - end) instead of all
 		auto &target = ListVector::GetEntry(result);
-		target.Reference(ListVector::GetEntry(source));
-		ListVector::SetListSize(result, ListVector::GetListSize(source));
-		TemplatedUnnest<list_entry_t>(vdata, start, end, result);
+		target.Reference(ListVector::GetEntry(child_vector));
+		ListVector::SetListSize(result, ListVector::GetListSize(child_vector));
+		// unnest
+		TemplatedUnnest<list_entry_t>(child_vector_data, start, end, result);
 		break;
 	}
 	case PhysicalType::STRUCT: {
-		auto &source_entries = StructVector::GetEntries(source);
-		auto &target_entries = StructVector::GetEntries(result);
-		UnnestValidity(vdata, start, end, result);
-		for (idx_t i = 0; i < source_entries.size(); i++) {
-			UnifiedVectorFormat sdata;
-			source_entries[i]->ToUnifiedFormat(list_size, sdata);
-			UnnestVector(sdata, *source_entries[i], list_size, start, end, *target_entries[i]);
+		auto &child_vector_entries = StructVector::GetEntries(child_vector);
+		auto &result_entries = StructVector::GetEntries(result);
+
+		// set the validity mask for the 'outer' struct vector before unnesting its children
+		UnnestValidity(child_vector_data, start, end, result);
+
+		for (idx_t i = 0; i < child_vector_entries.size(); i++) {
+			UnifiedVectorFormat child_vector_entries_data;
+			child_vector_entries[i]->ToUnifiedFormat(list_size, child_vector_entries_data);
+			UnnestVector(child_vector_entries_data, *child_vector_entries[i], list_size, start, end,
+			             *result_entries[i]);
 		}
 		break;
 	}
 	default:
-		throw InternalException("Unimplemented type for UNNEST");
+		throw InternalException("Unimplemented type for UNNEST.");
 	}
 }
 
+static void PrepareInput(UnnestOperatorState &state, DataChunk &input,
+                         const vector<unique_ptr<Expression>> &select_list) {
+
+	state.list_data.Reset();
+	// execute the expressions inside each UNNEST in the select_list to get the list data
+	// execution results (lists) are kept in state.list_data chunk
+	state.executor.Execute(input, state.list_data);
+
+	// verify incoming lists
+	state.list_data.Verify();
+	D_ASSERT(input.size() == state.list_data.size());
+	D_ASSERT(state.list_data.ColumnCount() == select_list.size());
+	D_ASSERT(state.list_vector_data.size() == state.list_data.ColumnCount());
+	D_ASSERT(state.list_child_data.size() == state.list_data.ColumnCount());
+
+	// get the UnifiedVectorFormat of each list_data vector (LIST vectors for the different UNNESTs)
+	// both for the vector itself and its child vector
+	for (idx_t col_idx = 0; col_idx < state.list_data.ColumnCount(); col_idx++) {
+
+		auto &list_vector = state.list_data.data[col_idx];
+		list_vector.ToUnifiedFormat(state.list_data.size(), state.list_vector_data[col_idx]);
+
+		if (list_vector.GetType() == LogicalType::SQLNULL) {
+			// UNNEST(NULL): SQLNULL vectors don't have child vectors, but we need to point to the child vector of
+			// each vector, so we just get the UnifiedVectorFormat of the vector itself
+			auto &child_vector = list_vector;
+			child_vector.ToUnifiedFormat(0, state.list_child_data[col_idx]);
+		} else {
+			auto list_size = ListVector::GetListSize(list_vector);
+			auto &child_vector = ListVector::GetEntry(list_vector);
+			child_vector.ToUnifiedFormat(list_size, state.list_child_data[col_idx]);
+		}
+	}
+
+	state.first_fetch = false;
+}
+
 unique_ptr<OperatorState> PhysicalUnnest::GetOperatorState(ExecutionContext &context) const {
 	return PhysicalUnnest::GetState(context, select_list);
 }
@@ -167,137 +256,107 @@ OperatorResultType PhysicalUnnest::ExecuteInternal(ExecutionContext &context, Da
                                                    OperatorState &state_p,
                                                    const vector<unique_ptr<Expression>> &select_list,
                                                    bool include_input) {
+
 	auto &state = (UnnestOperatorState &)state_p;
+
 	do {
+		// prepare the input data by executing any expressions and getting the
+		// UnifiedVectorFormat of each LIST vector (list_vector_data) and its child vector (list_child_data)
 		if (state.first_fetch) {
-			// get the list data to unnest
-			state.list_data.Reset();
-			state.executor.Execute(input, state.list_data);
-
-			// paranoia aplenty
-			state.list_data.Verify();
-			D_ASSERT(input.size() == state.list_data.size());
-			D_ASSERT(state.list_data.ColumnCount() == select_list.size());
-			D_ASSERT(state.list_vector_data.size() == state.list_data.ColumnCount());
-			D_ASSERT(state.list_child_data.size() == state.list_data.ColumnCount());
-
-			// initialize UnifiedVectorFormat object so the nullmask can accessed
-			for (idx_t col_idx = 0; col_idx < state.list_data.ColumnCount(); col_idx++) {
-				auto &list_vector = state.list_data.data[col_idx];
-				list_vector.ToUnifiedFormat(state.list_data.size(), state.list_vector_data[col_idx]);
-
-				if (list_vector.GetType() == LogicalType::SQLNULL) {
-					// UNNEST(NULL)
-					auto &child_vector = list_vector;
-					child_vector.ToUnifiedFormat(0, state.list_child_data[col_idx]);
-				} else {
-					auto list_size = ListVector::GetListSize(list_vector);
-					auto &child_vector = ListVector::GetEntry(list_vector);
-					child_vector.ToUnifiedFormat(list_size, state.list_child_data[col_idx]);
-				}
-			}
-			state.first_fetch = false;
+			PrepareInput(state, input, select_list);
 		}
-		if (state.parent_position >= input.size()) {
-			// finished with this input chunk
-			state.parent_position = 0;
-			state.list_position = 0;
-			state.list_length = -1;
-			state.first_fetch = true;
+
+		// finished with all rows of this input chunk, reset
+		if (state.current_row >= input.size()) {
+			state.Reset();
 			return OperatorResultType::NEED_MORE_INPUT;
 		}
 
-		// need to figure out how many times we need to repeat for current row
-		if (state.list_length < 0) {
-			for (idx_t col_idx = 0; col_idx < state.list_data.ColumnCount(); col_idx++) {
-				auto &vdata = state.list_vector_data[col_idx];
-				auto current_idx = vdata.sel->get_index(state.parent_position);
-
-				int64_t list_length;
-				// deal with NULL values
-				if (!vdata.validity.RowIsValid(current_idx)) {
-					list_length = 0;
-				} else {
-					auto list_data = (list_entry_t *)vdata.data;
-					auto list_entry = list_data[current_idx];
-					list_length = (int64_t)list_entry.length;
-				}
-
-				if (list_length > state.list_length) {
-					state.list_length = list_length;
-				}
-			}
+		// each UNNEST in the select_list contains a list (or NULL) for this row, find longest list
+		// because this length determines how many times we need to repeat for the current row
+		if (state.longest_list_length == DConstants::INVALID_INDEX) {
+			state.SetLongestListLength();
 		}
+		D_ASSERT(state.longest_list_length != DConstants::INVALID_INDEX);
 
-		D_ASSERT(state.list_length >= 0);
-
-		auto this_chunk_len = MinValue<idx_t>(STANDARD_VECTOR_SIZE, state.list_length - state.list_position);
-
-		// first cols are from child, last n cols from unnest
+		// we emit chunks of either STANDARD_VECTOR_SIZE or smaller
+		auto this_chunk_len = MinValue<idx_t>(STANDARD_VECTOR_SIZE, state.longest_list_length - state.list_position);
 		chunk.SetCardinality(this_chunk_len);
 
-		idx_t output_offset = 0;
+		// if we include other projection input columns, e.g. SELECT 1, UNNEST([1, 2]);, then
+		// we need to add them as a constant vector to the resulting chunk
+		// FIXME: emit multiple unnested rows. Currently, we never emit a chunk containing multiple unnested input rows,
+		//  so setting a constant vector for the value at state.current_row is fine
+		idx_t col_offset = 0;
 		if (include_input) {
 			for (idx_t col_idx = 0; col_idx < input.ColumnCount(); col_idx++) {
-				ConstantVector::Reference(chunk.data[col_idx], input.data[col_idx], state.parent_position,
-				                          input.size());
+				ConstantVector::Reference(chunk.data[col_idx], input.data[col_idx], state.current_row, input.size());
 			}
-			output_offset = input.ColumnCount();
+			col_offset = input.ColumnCount();
 		}
 
+		// unnest the lists
 		for (idx_t col_idx = 0; col_idx < state.list_data.ColumnCount(); col_idx++) {
-			auto &result_vector = chunk.data[col_idx + output_offset];
+
+			auto &result_vector = chunk.data[col_idx + col_offset];
 
 			if (state.list_data.data[col_idx].GetType() == LogicalType::SQLNULL) {
 				// UNNEST(NULL)
 				chunk.SetCardinality(0);
+				break;
+
 			} else {
-				auto &vdata = state.list_vector_data[col_idx];
-				auto &child_data = state.list_child_data[col_idx];
-				auto current_idx = vdata.sel->get_index(state.parent_position);
 
-				auto list_data = (list_entry_t *)vdata.data;
-				auto list_entry = list_data[current_idx];
+				auto &vector_data = state.list_vector_data[col_idx];
+				auto current_idx = vector_data.sel->get_index(state.current_row);
+
+				if (!vector_data.validity.RowIsValid(current_idx)) {
+					UnnestNull(0, this_chunk_len, result_vector);
 
-				idx_t list_count;
-				if (state.list_position >= list_entry.length) {
-					list_count = 0;
 				} else {
-					list_count = MinValue<idx_t>(this_chunk_len, list_entry.length - state.list_position);
-				}
 
-				if (list_entry.length > state.list_position) {
-					if (!vdata.validity.RowIsValid(current_idx)) {
-						UnnestNull(0, list_count, result_vector);
-					} else {
+					auto list_data = (list_entry_t *)vector_data.data;
+					auto list_entry = list_data[current_idx];
+
+					idx_t list_count = 0;
+					if (state.list_position < list_entry.length) {
+						// there are still list_count elements to unnest
+						list_count = MinValue<idx_t>(this_chunk_len, list_entry.length - state.list_position);
+
 						auto &list_vector = state.list_data.data[col_idx];
 						auto &child_vector = ListVector::GetEntry(list_vector);
 						auto list_size = ListVector::GetListSize(list_vector);
+						auto &child_vector_data = state.list_child_data[col_idx];
 
 						auto base_offset = list_entry.offset + state.list_position;
-						UnnestVector(child_data, child_vector, list_size, base_offset, base_offset + list_count,
+						UnnestVector(child_vector_data, child_vector, list_size, base_offset, base_offset + list_count,
 						             result_vector);
 					}
-				}
 
-				UnnestNull(list_count, this_chunk_len, result_vector);
+					// fill the rest with NULLs
+					if (list_count != this_chunk_len) {
+						UnnestNull(list_count, this_chunk_len, result_vector);
+					}
+				}
 			}
 		}
 
+		chunk.Verify();
+
 		state.list_position += this_chunk_len;
-		if ((int64_t)state.list_position == state.list_length) {
-			state.parent_position++;
-			state.list_length = -1;
+		if (state.list_position == state.longest_list_length) {
+			state.current_row++;
+			state.longest_list_length = DConstants::INVALID_INDEX;
 			state.list_position = 0;
 		}
 
-		chunk.Verify();
+		// we only emit one unnested row (that contains data) at a time
 	} while (chunk.size() == 0);
 	return OperatorResultType::HAVE_MORE_OUTPUT;
 }
 
 OperatorResultType PhysicalUnnest::Execute(ExecutionContext &context, DataChunk &input, DataChunk &chunk,
-                                           GlobalOperatorState &gstate, OperatorState &state) const {
+                                           GlobalOperatorState &, OperatorState &state) const {
 	return ExecuteInternal(context, input, chunk, state, select_list);
 }
 

package/src/duckdb/src/execution/operator/schema/physical_attach.cpp

@@ -5,6 +5,7 @@
 #include "duckdb/main/attached_database.hpp"
 #include "duckdb/main/database.hpp"
 #include "duckdb/storage/storage_extension.hpp"
+#include "duckdb/main/extension_helper.hpp"
 
 namespace duckdb {
 
@@ -55,11 +56,29 @@ void PhysicalAttach::GetData(ExecutionContext &context, DataChunk &chunk, Global
 			unrecognized_option = entry.first;
 		}
 	}
+	auto &db = DatabaseInstance::GetDatabase(context.client);
+	if (type.empty()) {
+		// try to extract type from path
+		type = db.ExtractDatabaseType(info->path);
+	}
+	if (!type.empty()) {
+		type = ExtensionHelper::ApplyExtensionAlias(type);
+	}
+	if (type.empty() && !unrecognized_option.empty()) {
+		throw BinderException("Unrecognized option for attach \"%s\"", unrecognized_option);
+	}
+
+	// if we are loading a database type from an extension - check if that extension is loaded
+	if (!type.empty()) {
+		if (!db.ExtensionIsLoaded(type)) {
+			ExtensionHelper::LoadExternalExtension(context.client, type);
+		}
+	}
 
 	// attach the database
-	auto name = info->name;
+	auto &name = info->name;
 	const auto &path = info->path;
-	auto &db = DatabaseInstance::GetDatabase(context.client);
+
 	if (name.empty()) {
 		name = AttachedDatabase::ExtractDatabaseName(path);
 	}
@@ -68,22 +87,7 @@ void PhysicalAttach::GetData(ExecutionContext &context, DataChunk &chunk, Global
 	if (existing_db) {
 		throw BinderException("Database \"%s\" is already attached with alias \"%s\"", path, existing_db->GetName());
 	}
-
-	unique_ptr<AttachedDatabase> new_db;
-	if (type.empty()) {
-		if (!unrecognized_option.empty()) {
-			throw BinderException("Unrecognized option for attach \"%s\"", unrecognized_option);
-		}
-		new_db = make_unique<AttachedDatabase>(db, Catalog::GetSystemCatalog(db), name, path, access_mode);
-	} else {
-		// attach an extension database
-		auto entry = config.storage_extensions.find(type);
-		if (entry == config.storage_extensions.end()) {
-			throw BinderException("Unrecognized storage type \"%s\"", type);
-		}
-		new_db =
-		    make_unique<AttachedDatabase>(db, Catalog::GetSystemCatalog(db), *entry->second, name, *info, access_mode);
-	}
+	auto new_db = db.CreateAttachedDatabase(*info, type, access_mode);
 	new_db->Initialize();
 
 	db_manager.AddDatabase(context.client, std::move(new_db));

package/src/duckdb/src/execution/physical_plan/plan_create_table.cpp

@@ -34,7 +34,7 @@ unique_ptr<PhysicalOperator> DuckCatalog::PlanCreateTableAs(ClientContext &conte
 }
 
 unique_ptr<PhysicalOperator> PhysicalPlanGenerator::CreatePlan(LogicalCreateTable &op) {
-	auto &create_info = (CreateTableInfo &)*op.info->base;
+	const auto &create_info = (CreateTableInfo &)*op.info->base;
 	auto &catalog = *op.info->schema->catalog;
 	auto existing_entry = catalog.GetEntry<TableCatalogEntry>(context, create_info.schema, create_info.table, true);
 	bool replace = op.info->Base().on_conflict == OnCreateConflict::REPLACE_ON_CONFLICT;

package/src/duckdb/src/function/aggregate/distributive/arg_min_max.cpp

@@ -183,7 +183,6 @@ struct VectorArgMinMaxBase : ArgMinMaxBase<COMPARATOR> {
 
 		auto states = (STATE **)sdata.data;
 		for (idx_t i = 0; i < count; i++) {
-			const auto aidx = adata.sel->get_index(i);
 			const auto bidx = bdata.sel->get_index(i);
 			if (!bdata.validity.RowIsValid(bidx)) {
 				continue;
@@ -194,12 +193,12 @@ struct VectorArgMinMaxBase : ArgMinMaxBase<COMPARATOR> {
 			auto state = states[sidx];
 			if (!state->is_initialized) {
 				STATE::template AssignValue<BY_TYPE>(state->value, bval, false);
-				AssignVector(state, arg, aidx);
+				AssignVector(state, arg, i);
 				state->is_initialized = true;
 
 			} else if (COMPARATOR::template Operation<BY_TYPE>(bval, state->value)) {
 				STATE::template AssignValue<BY_TYPE>(state->value, bval, true);
-				AssignVector(state, arg, aidx);
+				AssignVector(state, arg, i);
 			}
 		}
 	}

package/src/duckdb/src/function/scalar/math/setseed.cpp

@@ -36,7 +36,7 @@ static void SetSeedFunction(DataChunk &args, ExpressionState &state, Vector &res
 
 	auto &random_engine = RandomEngine::Get(info.context);
 	for (idx_t i = 0; i < args.size(); i++) {
-		if (input_seeds[i] < -1.0 || input_seeds[i] > 1.0) {
+		if (input_seeds[i] < -1.0 || input_seeds[i] > 1.0 || Value::IsNan(input_seeds[i])) {
 			throw Exception("SETSEED accepts seed values between -1.0 and 1.0, inclusive");
 		}
 		uint32_t norm_seed = (input_seeds[i] + 1.0) * half_max;

package/src/duckdb/src/function/scalar/string/substring.cpp

@@ -7,6 +7,7 @@
 #include "duckdb/storage/statistics/string_statistics.hpp"
 #include "duckdb/planner/expression/bound_function_expression.hpp"
 #include "utf8proc.hpp"
+#include "duckdb/common/types/blob.hpp"
 
 namespace duckdb {
 
@@ -138,6 +139,13 @@ string_t SubstringFun::SubstringUnicode(Vector &result, string_t input, int64_t
 				}
 			}
 		}
+		while (!LengthFun::IsCharacter(input_data[start_pos])) {
+			start_pos++;
+		}
+		while (end_pos < input_size && !LengthFun::IsCharacter(input_data[end_pos])) {
+			end_pos++;
+		}
+
 		if (end_pos == DConstants::INVALID_INDEX) {
 			return SubstringEmptyString(result);
 		}

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

@@ -257,7 +257,7 @@ public:
 		first_file_size = file_size;
 		bytes_read = 0;
 		if (buffer_size < file_size) {
-			bytes_per_local_state = buffer_size / MaxThreads();
+			bytes_per_local_state = buffer_size / ParallelCSVGlobalState::MaxThreads();
 		} else {
 			bytes_per_local_state = file_size / MaxThreads();
 		}

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

@@ -1,8 +1,8 @@
 #ifndef DUCKDB_VERSION
-#define DUCKDB_VERSION "0.6.2-dev2115"
+#define DUCKDB_VERSION "0.6.2-dev2226"
 #endif
 #ifndef DUCKDB_SOURCE_ID
-#define DUCKDB_SOURCE_ID "9480481947"
+#define DUCKDB_SOURCE_ID "6e71048a0d"
 #endif
 #include "duckdb/function/table/system_functions.hpp"
 #include "duckdb/main/database.hpp"

package/src/duckdb/src/include/duckdb/catalog/catalog.hpp

@@ -196,6 +196,8 @@ public:
 	DUCKDB_API CatalogEntry *GetEntry(ClientContext &context, const string &schema, const string &name);
 
 	//! Fetches a logical type from the catalog
+	DUCKDB_API LogicalType GetType(ClientContext &context, const string &schema, const string &names, bool if_exists);
+
 	DUCKDB_API static LogicalType GetType(ClientContext &context, const string &catalog_name, const string &schema,
 	                                      const string &name);
 

package/src/duckdb/src/include/duckdb/common/box_renderer.hpp

@@ -22,7 +22,11 @@ enum class ValueRenderAlignment { LEFT, MIDDLE, RIGHT };
 struct BoxRendererConfig {
 	// a max_width of 0 means we default to the terminal width
 	idx_t max_width = 0;
+	// the maximum amount of rows to render
 	idx_t max_rows = 20;
+	// the limit that is applied prior to rendering
+	// if we are rendering exactly "limit" rows then a question mark is rendered instead
+	idx_t limit = 0;
 	// the max col width determines the maximum size of a single column
 	// note that the max col width is only used if the result does not fit on the screen
 	idx_t max_col_width = 20;

package/src/duckdb/src/include/duckdb/common/enums/relation_type.hpp

@@ -35,6 +35,7 @@ enum class RelationType : uint8_t {
 	DELETE_RELATION,
 	UPDATE_RELATION,
 	WRITE_CSV_RELATION,
+	WRITE_PARQUET_RELATION,
 	READ_CSV_RELATION,
 	SUBQUERY_RELATION,
 	TABLE_FUNCTION_RELATION,

package/src/duckdb/src/include/duckdb/common/file_opener.hpp

@@ -25,6 +25,8 @@ public:
 	virtual ClientContext *TryGetClientContext() = 0;
 
 	DUCKDB_API static FileOpener *Get(ClientContext &context);
+	DUCKDB_API static ClientContext *TryGetClientContext(FileOpener *opener);
+	DUCKDB_API static bool TryGetCurrentSetting(FileOpener *opener, const string &key, Value &result);
 };
 
 } // namespace duckdb

package/src/duckdb/src/include/duckdb/common/http_stats.hpp

@@ -35,7 +35,7 @@ public:
 
 	//! helper function to get the HTTP
 	static HTTPStats *TryGetStats(FileOpener *opener) {
-		auto client_context = opener->TryGetClientContext();
+		auto client_context = FileOpener::TryGetClientContext(opener);
 		if (client_context) {
 			return client_context->client_data->http_stats.get();
 		}