duckdb 0.3.2-dev782.0 → 0.3.2-dev838.0

package/package.json

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

package/src/duckdb.cpp

@@ -38204,6 +38204,9 @@ LogicalType LogicalType::STRUCT(child_list_t<LogicalType> children) {
 	return LogicalType(LogicalTypeId::STRUCT, move(info));
 }
 
+//===--------------------------------------------------------------------===//
+// Map Type
+//===--------------------------------------------------------------------===//
 LogicalType LogicalType::MAP(child_list_t<LogicalType> children) {
 	auto info = make_shared<StructTypeInfo>(move(children));
 	return LogicalType(LogicalTypeId::MAP, move(info));
@@ -38216,6 +38219,16 @@ LogicalType LogicalType::MAP(LogicalType key, LogicalType value) {
 	return LogicalType::MAP(move(child_types));
 }
 
+const LogicalType &MapType::KeyType(const LogicalType &type) {
+	D_ASSERT(type.id() == LogicalTypeId::MAP);
+	return StructType::GetChildTypes(type)[0].second;
+}
+
+const LogicalType &MapType::ValueType(const LogicalType &type) {
+	D_ASSERT(type.id() == LogicalTypeId::MAP);
+	return StructType::GetChildTypes(type)[1].second;
+}
+
 //===--------------------------------------------------------------------===//
 // User Type
 //===--------------------------------------------------------------------===//
@@ -74467,7 +74480,8 @@ string MacroFunction::ValidateArguments(MacroCatalogEntry &macro_func, FunctionE
 			} else if (defaults.find(arg->alias) != defaults.end()) {
 				return StringUtil::Format("Duplicate default parameters %s!", arg->alias);
 			}
-			defaults[arg->alias] = move(arg);
+			auto alias = arg->alias;
+			defaults[alias] = move(arg);
 		} else if (!defaults.empty()) {
 			return "Positional parameters cannot come after parameters with a default value!";
 		} else {
@@ -88573,9 +88587,9 @@ static void GenerateUUIDFunction(DataChunk &args, ExpressionState &state, Vector
 }
 
 void UUIDFun::RegisterFunction(BuiltinFunctions &set) {
+	ScalarFunction uuid_function({}, LogicalType::UUID, GenerateUUIDFunction, true, UUIDRandomBind);
 	// generate a random uuid
-	set.AddFunction(
-	    ScalarFunction("gen_random_uuid", {}, LogicalType::UUID, GenerateUUIDFunction, true, UUIDRandomBind));
+	set.AddFunction({"uuid", "gen_random_uuid"}, uuid_function);
 }
 
 } // namespace duckdb
@@ -98273,8 +98287,8 @@ string ClientContext::VerifyQuery(ClientContextLock &lock, const string &query,
 	} catch (std::exception &ex) {
 		original_result->error = ex.what();
 		original_result->success = false;
-		interrupted = false;
 	}
+	interrupted = false;
 
 	// check explain, only if q does not already contain EXPLAIN
 	if (original_result->success) {
@@ -98294,8 +98308,8 @@ string ClientContext::VerifyQuery(ClientContextLock &lock, const string &query,
 	} catch (std::exception &ex) {
 		copied_result->error = ex.what();
 		copied_result->success = false;
-		interrupted = false;
 	}
+	interrupted = false;
 	// now execute the deserialized statement
 	try {
 		auto result = RunStatementInternal(lock, query, move(deserialized_stmt), false, false);
@@ -98303,8 +98317,8 @@ string ClientContext::VerifyQuery(ClientContextLock &lock, const string &query,
 	} catch (std::exception &ex) {
 		deserialized_result->error = ex.what();
 		deserialized_result->success = false;
-		interrupted = false;
 	}
+	interrupted = false;
 	// now execute the unoptimized statement
 	config.enable_optimizer = false;
 	try {
@@ -98313,8 +98327,8 @@ string ClientContext::VerifyQuery(ClientContextLock &lock, const string &query,
 	} catch (std::exception &ex) {
 		unoptimized_result->error = ex.what();
 		unoptimized_result->success = false;
-		interrupted = false;
 	}
+	interrupted = false;
 	config.enable_optimizer = true;
 
 	if (profiling_is_enabled) {
@@ -99884,6 +99898,7 @@ ExtensionLoadResult ExtensionHelper::LoadExtensionInternal(DuckDB &db, const std
 
 
 
+#ifndef DISABLE_DUCKDB_REMOTE_INSTALL
 
 
 // LICENSE_CHANGE_BEGIN
@@ -107326,6 +107341,7 @@ inline SSL_CTX *Client::ssl_context() const {
 
 // LICENSE_CHANGE_END
 
+#endif
 
 
 #include <fstream>
@@ -107383,6 +107399,9 @@ void ExtensionHelper::InstallExtension(DatabaseInstance &db, const string &exten
 		throw IOException("Failed to read extension from \"%s\": no such file", extension);
 	}
 
+#ifdef DISABLE_DUCKDB_REMOTE_INSTALL
+	throw BinderException("Remote extension installation is disabled through configuration");
+#else
 	string url_template = "http://extensions.duckdb.org/${REVISION}/${PLATFORM}/${NAME}.duckdb_extension.gz";
 
 	if (is_http_url) {
@@ -107421,6 +107440,7 @@ void ExtensionHelper::InstallExtension(DatabaseInstance &db, const string &exten
 	if (out.bad()) {
 		throw IOException("Failed to write extension to %s", local_extension_path);
 	}
+#endif
 }
 
 } // namespace duckdb
@@ -112829,7 +112849,10 @@ void ExpressionRewriter::VisitExpression(unique_ptr<Expression> *expression) {
 
 
 
+
+
 #include <functional>
+#include <map>
 
 namespace duckdb {
 
@@ -112867,6 +112890,37 @@ private:
 	idx_t GetEquivalenceSet(Expression *expr);
 	FilterResult AddConstantComparison(vector<ExpressionValueInformation> &info_list, ExpressionValueInformation info);
 
+	//! Functions used to push and generate OR Filters
+	void LookUpConjunctions(Expression *expr);
+	bool BFSLookUpConjunctions(BoundConjunctionExpression *conjunction);
+	void VerifyOrsToPush(Expression &expr);
+
+	bool UpdateConjunctionFilter(BoundComparisonExpression *comparison_expr);
+	bool UpdateFilterByColumn(BoundColumnRefExpression *column_ref, BoundComparisonExpression *comparison_expr);
+	void GenerateORFilters(TableFilterSet &table_filter, vector<idx_t> &column_ids);
+
+	template <typename CONJUNCTION_TYPE>
+	void GenerateConjunctionFilter(BoundConjunctionExpression *conjunction, ConjunctionFilter *last_conj_filter) {
+		auto new_filter = NextConjunctionFilter<CONJUNCTION_TYPE>(conjunction);
+		auto conj_filter_ptr = (ConjunctionFilter *)new_filter.get();
+		last_conj_filter->child_filters.push_back(move(new_filter));
+		last_conj_filter = conj_filter_ptr;
+	}
+
+	template <typename CONJUNCTION_TYPE>
+	unique_ptr<TableFilter> NextConjunctionFilter(BoundConjunctionExpression *conjunction) {
+		unique_ptr<ConjunctionFilter> conj_filter = make_unique<CONJUNCTION_TYPE>();
+		for (auto &expr : conjunction->children) {
+			auto comp_expr = (BoundComparisonExpression *)expr.get();
+			auto &const_expr =
+			    (comp_expr->left->type == ExpressionType::VALUE_CONSTANT) ? *comp_expr->left : *comp_expr->right;
+			auto const_value = ExpressionExecutor::EvaluateScalar(const_expr);
+			auto const_filter = make_unique<ConstantFilter>(comp_expr->type, const_value);
+			conj_filter->child_filters.push_back(move(const_filter));
+		}
+		return move(conj_filter);
+	}
+
 private:
 	vector<unique_ptr<Expression>> remaining_filters;
 
@@ -112875,6 +112929,26 @@ private:
 	unordered_map<idx_t, vector<ExpressionValueInformation>> constant_values;
 	unordered_map<idx_t, vector<Expression *>> equivalence_map;
 	idx_t set_index = 0;
+
+	//! Structures used for OR Filters
+
+	struct ConjunctionsToPush {
+		BoundConjunctionExpression *root_or;
+
+		// only preserve AND if there is a single column in the expression
+		bool preserve_and = true;
+
+		// conjunction chain for this column
+		vector<unique_ptr<BoundConjunctionExpression>> conjunctions;
+	};
+
+	expression_map_t<vector<unique_ptr<ConjunctionsToPush>>> map_col_conjunctions;
+	vector<BoundColumnRefExpression *> vec_colref_insertion_order;
+
+	BoundConjunctionExpression *cur_root_or;
+	BoundConjunctionExpression *cur_conjunction;
+
+	BoundColumnRefExpression *cur_colref_to_push;
 };
 
 } // namespace duckdb
@@ -112896,6 +112970,7 @@ private:
 
 
 
+
 namespace duckdb {
 
 using ExpressionValueInformation = FilterCombiner::ExpressionValueInformation;
@@ -112958,6 +113033,7 @@ FilterResult FilterCombiner::AddConstantComparison(vector<ExpressionValueInforma
 }
 
 FilterResult FilterCombiner::AddFilter(unique_ptr<Expression> expr) {
+	LookUpConjunctions(expr.get());
 	// try to push the filter into the combiner
 	auto result = AddFilter(expr.get());
 	if (result == FilterResult::UNSUPPORTED) {
@@ -113430,6 +113506,8 @@ TableFilterSet FilterCombiner::GenerateTableScanFilters(vector<idx_t> &column_id
 		}
 	}
 
+	GenerateORFilters(table_filters, column_ids);
+
 	return table_filters;
 }
 
@@ -113867,6 +113945,176 @@ ValueComparisonResult CompareValueInformation(ExpressionValueInformation &left,
 	}
 }
 
+void FilterCombiner::LookUpConjunctions(Expression *expr) {
+	if (expr->GetExpressionType() == ExpressionType::CONJUNCTION_OR) {
+		auto root_or_expr = (BoundConjunctionExpression *)expr;
+		for (const auto &entry : map_col_conjunctions) {
+			for (const auto &conjs_to_push : entry.second) {
+				if (conjs_to_push->root_or->Equals(root_or_expr)) {
+					return;
+				}
+			}
+		}
+
+		cur_root_or = root_or_expr;
+		cur_conjunction = root_or_expr;
+		cur_colref_to_push = nullptr;
+		if (!BFSLookUpConjunctions(cur_root_or)) {
+			if (cur_colref_to_push) {
+				auto entry = map_col_conjunctions.find(cur_colref_to_push);
+				auto &vec_conjs_to_push = entry->second;
+				if (vec_conjs_to_push.size() == 1) {
+					map_col_conjunctions.erase(entry);
+					return;
+				}
+				vec_conjs_to_push.pop_back();
+			}
+		}
+		return;
+	}
+
+	// Verify if the expression has a column already pushed down by other OR expression
+	VerifyOrsToPush(*expr);
+}
+
+bool FilterCombiner::BFSLookUpConjunctions(BoundConjunctionExpression *conjunction) {
+	vector<BoundConjunctionExpression *> conjunctions_to_visit;
+
+	for (auto &child : conjunction->children) {
+		switch (child->GetExpressionClass()) {
+		case ExpressionClass::BOUND_CONJUNCTION: {
+			auto child_conjunction = (BoundConjunctionExpression *)child.get();
+			conjunctions_to_visit.emplace_back(child_conjunction);
+			break;
+		}
+		case ExpressionClass::BOUND_COMPARISON: {
+			if (!UpdateConjunctionFilter((BoundComparisonExpression *)child.get())) {
+				return false;
+			}
+			break;
+		}
+		default: {
+			return false;
+		}
+		}
+	}
+
+	for (auto child_conjunction : conjunctions_to_visit) {
+		cur_conjunction = child_conjunction;
+		// traverse child conjuction
+		if (!BFSLookUpConjunctions(child_conjunction)) {
+			return false;
+		}
+	}
+	return true;
+}
+
+void FilterCombiner::VerifyOrsToPush(Expression &expr) {
+	if (expr.type == ExpressionType::BOUND_COLUMN_REF) {
+		auto colref = (BoundColumnRefExpression *)&expr;
+		auto entry = map_col_conjunctions.find(colref);
+		if (entry == map_col_conjunctions.end()) {
+			return;
+		}
+		map_col_conjunctions.erase(entry);
+	}
+	ExpressionIterator::EnumerateChildren(expr, [&](Expression &child) { VerifyOrsToPush(child); });
+}
+
+bool FilterCombiner::UpdateConjunctionFilter(BoundComparisonExpression *comparison_expr) {
+	bool left_is_scalar = comparison_expr->left->IsFoldable();
+	bool right_is_scalar = comparison_expr->right->IsFoldable();
+
+	Expression *non_scalar_expr;
+	if (left_is_scalar || right_is_scalar) {
+		// only support comparison with scalar
+		non_scalar_expr = left_is_scalar ? comparison_expr->right.get() : comparison_expr->left.get();
+
+		if (non_scalar_expr->GetExpressionType() == ExpressionType::BOUND_COLUMN_REF) {
+			return UpdateFilterByColumn((BoundColumnRefExpression *)non_scalar_expr, comparison_expr);
+		}
+	}
+
+	return false;
+}
+
+bool FilterCombiner::UpdateFilterByColumn(BoundColumnRefExpression *column_ref,
+                                          BoundComparisonExpression *comparison_expr) {
+	if (cur_colref_to_push == nullptr) {
+		cur_colref_to_push = column_ref;
+
+		auto or_conjunction = make_unique<BoundConjunctionExpression>(ExpressionType::CONJUNCTION_OR);
+		or_conjunction->children.emplace_back(comparison_expr->Copy());
+
+		unique_ptr<ConjunctionsToPush> conjs_to_push = make_unique<ConjunctionsToPush>();
+		conjs_to_push->conjunctions.emplace_back(move(or_conjunction));
+		conjs_to_push->root_or = cur_root_or;
+
+		auto &&vec_col_conjs = map_col_conjunctions[column_ref];
+		vec_col_conjs.emplace_back(move(conjs_to_push));
+		vec_colref_insertion_order.emplace_back(column_ref);
+		return true;
+	}
+
+	auto entry = map_col_conjunctions.find(cur_colref_to_push);
+	D_ASSERT(entry != map_col_conjunctions.end());
+	auto &conjunctions_to_push = entry->second.back();
+
+	if (!cur_colref_to_push->Equals(column_ref)) {
+		// check for multiple colunms in the same root OR node
+		if (cur_root_or == cur_conjunction) {
+			return false;
+		}
+		// found an AND using a different column, we should stop the look up
+		if (cur_conjunction->GetExpressionType() == ExpressionType::CONJUNCTION_AND) {
+			return false;
+		}
+
+		// found a different column, AND conditions cannot be preserved anymore
+		conjunctions_to_push->preserve_and = false;
+		return true;
+	}
+
+	auto &last_conjunction = conjunctions_to_push->conjunctions.back();
+	if (cur_conjunction->GetExpressionType() == last_conjunction->GetExpressionType()) {
+		last_conjunction->children.emplace_back(comparison_expr->Copy());
+	} else {
+		auto new_conjunction = make_unique<BoundConjunctionExpression>(cur_conjunction->GetExpressionType());
+		new_conjunction->children.emplace_back(comparison_expr->Copy());
+		conjunctions_to_push->conjunctions.emplace_back(move(new_conjunction));
+	}
+	return true;
+}
+
+void FilterCombiner::GenerateORFilters(TableFilterSet &table_filter, vector<idx_t> &column_ids) {
+	for (const auto colref : vec_colref_insertion_order) {
+		auto column_index = column_ids[colref->binding.column_index];
+		if (column_index == COLUMN_IDENTIFIER_ROW_ID) {
+			break;
+		}
+
+		for (const auto &conjunctions_to_push : map_col_conjunctions[colref]) {
+			// root OR filter to push into the TableFilter
+			auto root_or_filter = make_unique<ConjunctionOrFilter>();
+			// variable to hold the last conjuntion filter pointer
+			// the next filter will be added into it, i.e., we create a chain of conjunction filters
+			ConjunctionFilter *last_conj_filter = root_or_filter.get();
+
+			for (auto &conjunction : conjunctions_to_push->conjunctions) {
+				if (conjunction->GetExpressionType() == ExpressionType::CONJUNCTION_AND &&
+				    conjunctions_to_push->preserve_and) {
+					GenerateConjunctionFilter<ConjunctionAndFilter>(conjunction.get(), last_conj_filter);
+				} else {
+					GenerateConjunctionFilter<ConjunctionOrFilter>(conjunction.get(), last_conj_filter);
+				}
+			}
+			table_filter.PushFilter(column_index, move(root_or_filter));
+		}
+	}
+	map_col_conjunctions.clear();
+	vec_colref_insertion_order.clear();
+}
+
 } // namespace duckdb
 //===----------------------------------------------------------------------===//
 //                         DuckDB
@@ -119003,6 +119251,10 @@ FilterPropagateResult StatisticsPropagator::PropagateComparison(BaseStatistics &
 	// only handle numerics for now
 	switch (left.type.InternalType()) {
 	case PhysicalType::BOOL:
+	case PhysicalType::UINT8:
+	case PhysicalType::UINT16:
+	case PhysicalType::UINT32:
+	case PhysicalType::UINT64:
 	case PhysicalType::INT8:
 	case PhysicalType::INT16:
 	case PhysicalType::INT32:
@@ -119130,6 +119382,10 @@ namespace duckdb {
 unique_ptr<BaseStatistics> StatisticsPropagator::StatisticsFromValue(const Value &input) {
 	switch (input.type().InternalType()) {
 	case PhysicalType::BOOL:
+	case PhysicalType::UINT8:
+	case PhysicalType::UINT16:
+	case PhysicalType::UINT32:
+	case PhysicalType::UINT64:
 	case PhysicalType::INT8:
 	case PhysicalType::INT16:
 	case PhysicalType::INT32:
@@ -138758,7 +139014,8 @@ unique_ptr<CreateStatement> Transformer::TransformCreateFunction(duckdb_libpgque
 				if (macro_func->default_parameters.find(param->alias) != macro_func->default_parameters.end()) {
 					throw ParserException("Duplicate default parameter: '%s'", param->alias);
 				}
-				macro_func->default_parameters[param->alias] = move(param);
+				auto alias = param->alias;
+				macro_func->default_parameters[alias] = move(param);
 			} else if (param->GetExpressionClass() == ExpressionClass::COLUMN_REF) {
 				// positional parameters
 				if (!macro_func->default_parameters.empty()) {
@@ -149818,7 +150075,7 @@ void ExpressionIterator::EnumerateQueryNodeChildren(BoundQueryNode &node,
 
 namespace duckdb {
 
-ConjunctionOrFilter::ConjunctionOrFilter() : TableFilter(TableFilterType::CONJUNCTION_OR) {
+ConjunctionOrFilter::ConjunctionOrFilter() : ConjunctionFilter(TableFilterType::CONJUNCTION_OR) {
 }
 
 FilterPropagateResult ConjunctionOrFilter::CheckStatistics(BaseStatistics &stats) {
@@ -149847,7 +150104,7 @@ string ConjunctionOrFilter::ToString(const string &column_name) {
 }
 
 bool ConjunctionOrFilter::Equals(const TableFilter &other_p) const {
-	if (!TableFilter::Equals(other_p)) {
+	if (!ConjunctionFilter::Equals(other_p)) {
 		return false;
 	}
 	auto &other = (ConjunctionOrFilter &)other_p;
@@ -149862,11 +150119,11 @@ bool ConjunctionOrFilter::Equals(const TableFilter &other_p) const {
 	return true;
 }
 
-ConjunctionAndFilter::ConjunctionAndFilter() : TableFilter(TableFilterType::CONJUNCTION_AND) {
+ConjunctionAndFilter::ConjunctionAndFilter() : ConjunctionFilter(TableFilterType::CONJUNCTION_AND) {
 }
 
 FilterPropagateResult ConjunctionAndFilter::CheckStatistics(BaseStatistics &stats) {
-	// the OR filter is true if ALL of the children is true
+	// the AND filter is true if ALL of the children is true
 	D_ASSERT(!child_filters.empty());
 	auto result = FilterPropagateResult::FILTER_ALWAYS_TRUE;
 	for (auto &filter : child_filters) {
@@ -149892,7 +150149,7 @@ string ConjunctionAndFilter::ToString(const string &column_name) {
 }
 
 bool ConjunctionAndFilter::Equals(const TableFilter &other_p) const {
-	if (!TableFilter::Equals(other_p)) {
+	if (!ConjunctionFilter::Equals(other_p)) {
 		return false;
 	}
 	auto &other = (ConjunctionAndFilter &)other_p;
@@ -160109,6 +160366,14 @@ FilterPropagateResult NumericStatistics::CheckZonemap(ExpressionType comparison_
 		} else {
 			return FilterPropagateResult::FILTER_ALWAYS_FALSE;
 		}
+	case ExpressionType::COMPARE_NOTEQUAL:
+		if (constant < min || constant > max) {
+			return FilterPropagateResult::FILTER_ALWAYS_TRUE;
+		} else if (min == max && min == constant) {
+			// corner case of a cluster with one numeric equal to the target constant
+			return FilterPropagateResult::FILTER_ALWAYS_FALSE;
+		}
+		return FilterPropagateResult::NO_PRUNING_POSSIBLE;
 	case ExpressionType::COMPARE_GREATERTHANOREQUALTO:
 		// X >= C
 		// this can be true only if max(X) >= C
@@ -160305,7 +160570,6 @@ unique_ptr<BaseStatistics> StringStatistics::Copy() {
 	memcpy(stats->max, max, MAX_STRING_MINMAX_SIZE);
 	stats->has_unicode = has_unicode;
 	stats->max_string_length = max_string_length;
-	stats->max_string_length = max_string_length;
 	if (validity_stats) {
 		stats->validity_stats = validity_stats->Copy();
 	}
@@ -160409,6 +160673,11 @@ FilterPropagateResult StringStatistics::CheckZonemap(ExpressionType comparison_t
 		} else {
 			return FilterPropagateResult::FILTER_ALWAYS_FALSE;
 		}
+	case ExpressionType::COMPARE_NOTEQUAL:
+		if (min_comp < 0 || max_comp > 0) {
+			return FilterPropagateResult::FILTER_ALWAYS_TRUE;
+		}
+		return FilterPropagateResult::NO_PRUNING_POSSIBLE;
 	case ExpressionType::COMPARE_GREATERTHANOREQUALTO:
 	case ExpressionType::COMPARE_GREATERTHAN:
 		if (max_comp <= 0) {
@@ -162532,6 +162801,16 @@ static void FilterSelectionSwitch(T *vec, T *predicate, SelectionVector &sel, id
 		}
 		break;
 	}
+	case ExpressionType::COMPARE_NOTEQUAL: {
+		if (mask.AllValid()) {
+			approved_tuple_count =
+			    TemplatedFilterSelection<T, NotEquals, false>(vec, predicate, sel, approved_tuple_count, mask, new_sel);
+		} else {
+			approved_tuple_count =
+			    TemplatedFilterSelection<T, NotEquals, true>(vec, predicate, sel, approved_tuple_count, mask, new_sel);
+		}
+		break;
+	}
 	case ExpressionType::COMPARE_LESSTHAN: {
 		if (mask.AllValid()) {
 			approved_tuple_count =
@@ -162601,15 +162880,44 @@ static idx_t TemplatedNullSelection(SelectionVector &sel, idx_t approved_tuple_c
 	}
 }
 
-void ColumnSegment::FilterSelection(SelectionVector &sel, Vector &result, const TableFilter &filter,
-                                    idx_t &approved_tuple_count, ValidityMask &mask) {
+idx_t ColumnSegment::FilterSelection(SelectionVector &sel, Vector &result, const TableFilter &filter,
+                                     idx_t &approved_tuple_count, ValidityMask &mask) {
 	switch (filter.filter_type) {
+	case TableFilterType::CONJUNCTION_OR: {
+		// similar to the CONJUNCTION_AND, but we need to take care of the SelectionVectors (OR all of them)
+		idx_t count_total = 0;
+		SelectionVector result_sel(approved_tuple_count);
+		auto &conjunction_or = (ConjunctionOrFilter &)filter;
+		for (auto &child_filter : conjunction_or.child_filters) {
+			SelectionVector temp_sel;
+			temp_sel.Initialize(sel);
+			idx_t temp_tuple_count = approved_tuple_count;
+			idx_t temp_count = FilterSelection(temp_sel, result, *child_filter, temp_tuple_count, mask);
+			// tuples passed, move them into the actual result vector
+			for (idx_t i = 0; i < temp_count; i++) {
+				auto new_idx = temp_sel.get_index(i);
+				bool is_new_idx = true;
+				for (idx_t res_idx = 0; res_idx < count_total; res_idx++) {
+					if (result_sel.get_index(res_idx) == new_idx) {
+						is_new_idx = false;
+						break;
+					}
+				}
+				if (is_new_idx) {
+					result_sel.set_index(count_total++, new_idx);
+				}
+			}
+		}
+		sel.Initialize(result_sel);
+		approved_tuple_count = count_total;
+		return approved_tuple_count;
+	}
 	case TableFilterType::CONJUNCTION_AND: {
 		auto &conjunction_and = (ConjunctionAndFilter &)filter;
 		for (auto &child_filter : conjunction_and.child_filters) {
 			FilterSelection(sel, result, *child_filter, approved_tuple_count, mask);
 		}
-		break;
+		return approved_tuple_count;
 	}
 	case TableFilterType::CONSTANT_COMPARISON: {
 		auto &constant_filter = (ConstantFilter &)filter;
@@ -162722,14 +163030,12 @@ void ColumnSegment::FilterSelection(SelectionVector &sel, Vector &result, const
 		default:
 			throw InvalidTypeException(result.GetType(), "Invalid type for filter pushed down to table comparison");
 		}
-		break;
+		return approved_tuple_count;
 	}
 	case TableFilterType::IS_NULL:
-		TemplatedNullSelection<true>(sel, approved_tuple_count, mask);
-		break;
+		return TemplatedNullSelection<true>(sel, approved_tuple_count, mask);
 	case TableFilterType::IS_NOT_NULL:
-		TemplatedNullSelection<false>(sel, approved_tuple_count, mask);
-		break;
+		return TemplatedNullSelection<false>(sel, approved_tuple_count, mask);
 	default:
 		throw InternalException("FIXME: unsupported type for filter selection");
 	}

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 "7473f3eb0"
-#define DUCKDB_VERSION "0.3.2-dev782"
+#define DUCKDB_SOURCE_ID "542f5d599"
+#define DUCKDB_VERSION "0.3.2-dev838"
 //===----------------------------------------------------------------------===//
 //                         DuckDB
 //
@@ -1097,6 +1097,11 @@ struct StructType {
 	DUCKDB_API static idx_t GetChildCount(const LogicalType &type);
 };
 
+struct MapType {
+	DUCKDB_API static const LogicalType &KeyType(const LogicalType &type);
+	DUCKDB_API static const LogicalType &ValueType(const LogicalType &type);
+};
+
 
 string LogicalTypeIdToString(LogicalTypeId type);
 
@@ -19200,8 +19205,8 @@ public:
 	//! Fetch a value of the specific row id and append it to the result
 	void FetchRow(ColumnFetchState &state, row_t row_id, Vector &result, idx_t result_idx);
 
-	static void FilterSelection(SelectionVector &sel, Vector &result, const TableFilter &filter,
-	                            idx_t &approved_tuple_count, ValidityMask &mask);
+	static idx_t FilterSelection(SelectionVector &sel, Vector &result, const TableFilter &filter,
+	                             idx_t &approved_tuple_count, ValidityMask &mask);
 
 	//! Skip a scan forward to the row_index specified in the scan state
 	void Skip(ColumnScanState &state);
@@ -20102,27 +20107,40 @@ void NumericStatistics::Update<list_entry_t>(SegmentStatistics &stats, list_entr
 
 
 namespace duckdb {
-
-class ConjunctionOrFilter : public TableFilter {
+class ConjunctionFilter : public TableFilter {
 public:
-	ConjunctionOrFilter();
+	ConjunctionFilter(TableFilterType filter_type_p) : TableFilter(filter_type_p) {
+	}
 
-	//! The filters to OR together
+	virtual ~ConjunctionFilter() {
+	}
+
+	//! The filters of this conjunction
 	vector<unique_ptr<TableFilter>> child_filters;
 
+public:
+	virtual FilterPropagateResult CheckStatistics(BaseStatistics &stats) = 0;
+	virtual string ToString(const string &column_name) = 0;
+
+	virtual bool Equals(const TableFilter &other) const {
+		return TableFilter::Equals(other);
+	}
+};
+
+class ConjunctionOrFilter : public ConjunctionFilter {
+public:
+	ConjunctionOrFilter();
+
 public:
 	FilterPropagateResult CheckStatistics(BaseStatistics &stats) override;
 	string ToString(const string &column_name) override;
 	bool Equals(const TableFilter &other) const override;
 };
 
-class ConjunctionAndFilter : public TableFilter {
+class ConjunctionAndFilter : public ConjunctionFilter {
 public:
 	ConjunctionAndFilter();
 
-	//! The filters to OR together
-	vector<unique_ptr<TableFilter>> child_filters;
-
 public:
 	FilterPropagateResult CheckStatistics(BaseStatistics &stats) override;
 	string ToString(const string &column_name) override;