duckdb 1.1.0 → 1.1.1-dev3.0

package/src/duckdb/src/include/duckdb/transaction/local_storage.hpp

@@ -12,6 +12,7 @@
 #include "duckdb/storage/table/table_index_list.hpp"
 #include "duckdb/storage/table/table_statistics.hpp"
 #include "duckdb/storage/optimistic_data_writer.hpp"
+#include "duckdb/common/error_data.hpp"
 #include "duckdb/common/reference_map.hpp"
 
 namespace duckdb {

package/src/duckdb/src/include/duckdb/transaction/transaction_manager.hpp

@@ -12,7 +12,7 @@
 #include "duckdb/common/common.hpp"
 #include "duckdb/common/mutex.hpp"
 #include "duckdb/common/vector.hpp"
-
+#include "duckdb/common/error_data.hpp"
 #include "duckdb/common/atomic.hpp"
 
 namespace duckdb {

package/src/duckdb/src/include/duckdb.h

@@ -133,6 +133,8 @@ typedef enum DUCKDB_TYPE {
 	DUCKDB_TYPE_ANY = 34,
 	// duckdb_varint
 	DUCKDB_TYPE_VARINT = 35,
+	// SQLNULL type
+	DUCKDB_TYPE_SQLNULL = 36,
 } duckdb_type;
 //! An enum over the returned state of different functions.
 typedef enum duckdb_state { DuckDBSuccess = 0, DuckDBError = 1 } duckdb_state;
@@ -866,8 +868,8 @@ Returns the number of rows present in the result object.
 * @return The number of rows present in the result object.
 */
 DUCKDB_API idx_t duckdb_row_count(duckdb_result *result);
-#endif
 
+#endif
 /*!
 Returns the number of rows changed by the query stored in the result. This is relevant only for INSERT/UPDATE/DELETE
 queries. For other queries the rows_changed will be 0.
@@ -898,9 +900,7 @@ printf("Data for row %d: %d\n", row, data[row]);
 * @return The column data of the specified column.
 */
 DUCKDB_API void *duckdb_column_data(duckdb_result *result, idx_t col);
-#endif
 
-#ifndef DUCKDB_API_NO_DEPRECATED
 /*!
 **DEPRECATED**: Prefer using `duckdb_result_get_chunk` instead.
 
@@ -923,8 +923,8 @@ if (nullmask[row]) {
 * @return The nullmask of the specified column.
 */
 DUCKDB_API bool *duckdb_nullmask_data(duckdb_result *result, idx_t col);
-#endif
 
+#endif
 /*!
 Returns the error message contained within the result. The error is only set if `duckdb_query` returns `DuckDBError`.
 
@@ -990,6 +990,7 @@ Returns the number of data chunks present in the result.
 */
 DUCKDB_API idx_t duckdb_result_chunk_count(duckdb_result result);
 
+#endif
 /*!
 Returns the return_type of the given result, or DUCKDB_RETURN_TYPE_INVALID on error
 
@@ -998,7 +999,6 @@ Returns the return_type of the given result, or DUCKDB_RETURN_TYPE_INVALID on er
 */
 DUCKDB_API duckdb_result_type duckdb_result_return_type(duckdb_result result);
 
-#endif
 //===--------------------------------------------------------------------===//
 // Safe Fetch Functions
 //===--------------------------------------------------------------------===//
@@ -1663,8 +1663,8 @@ Note that the result must be freed with `duckdb_destroy_result`.
 */
 DUCKDB_API duckdb_state duckdb_execute_prepared_streaming(duckdb_prepared_statement prepared_statement,
                                                           duckdb_result *out_result);
-#endif
 
+#endif
 //===--------------------------------------------------------------------===//
 // Extract Statements
 //===--------------------------------------------------------------------===//
@@ -1754,8 +1754,8 @@ Note that after calling `duckdb_pending_prepared_streaming`, the pending result
 */
 DUCKDB_API duckdb_state duckdb_pending_prepared_streaming(duckdb_prepared_statement prepared_statement,
                                                           duckdb_pending_result *out_result);
-#endif
 
+#endif
 /*!
 Closes the pending result and de-allocates all memory allocated for the result.
 
@@ -4038,8 +4038,8 @@ It is not known beforehand how many chunks will be returned by this result.
 * @return The resulting data chunk. Returns `NULL` if the result has an error.
 */
 DUCKDB_API duckdb_data_chunk duckdb_stream_fetch_chunk(duckdb_result result);
-#endif
 
+#endif
 /*!
 Fetches a data chunk from a duckdb_result. This function should be called repeatedly until the result is exhausted.
 

package/src/duckdb/src/main/appender.cpp

@@ -114,7 +114,7 @@ void BaseAppender::BeginRow() {
 void BaseAppender::EndRow() {
 	// check that all rows have been appended to
 	if (column != chunk.ColumnCount()) {
-		throw InvalidInputException("Call to EndRow before all rows have been appended to!");
+		throw InvalidInputException("Call to EndRow before all columns have been appended to!");
 	}
 	column = 0;
 	chunk.SetCardinality(chunk.size() + 1);

package/src/duckdb/src/main/capi/duckdb_value-c.cpp

@@ -282,7 +282,7 @@ idx_t duckdb_get_map_size(duckdb_value value) {
 	}
 
 	auto val = UnwrapValue(value);
-	if (val.type() != LogicalTypeId::MAP) {
+	if (val.type().id() != LogicalTypeId::MAP) {
 		return 0;
 	}
 
@@ -296,7 +296,7 @@ duckdb_value duckdb_get_map_key(duckdb_value value, idx_t index) {
 	}
 
 	auto val = UnwrapValue(value);
-	if (val.type() != LogicalTypeId::MAP) {
+	if (val.type().id() != LogicalTypeId::MAP) {
 		return nullptr;
 	}
 
@@ -316,7 +316,7 @@ duckdb_value duckdb_get_map_value(duckdb_value value, idx_t index) {
 	}
 
 	auto val = UnwrapValue(value);
-	if (val.type() != LogicalTypeId::MAP) {
+	if (val.type().id() != LogicalTypeId::MAP) {
 		return nullptr;
 	}
 

package/src/duckdb/src/main/capi/helper-c.cpp

@@ -74,6 +74,8 @@ LogicalTypeId ConvertCTypeToCPP(duckdb_type c_type) {
 		return LogicalTypeId::TIMESTAMP_TZ;
 	case DUCKDB_TYPE_ANY:
 		return LogicalTypeId::ANY;
+	case DUCKDB_TYPE_SQLNULL:
+		return LogicalTypeId::SQLNULL;
 	default: // LCOV_EXCL_START
 		D_ASSERT(0);
 		return LogicalTypeId::INVALID;
@@ -154,6 +156,8 @@ duckdb_type ConvertCPPTypeToC(const LogicalType &sql_type) {
 		return DUCKDB_TYPE_ARRAY;
 	case LogicalTypeId::ANY:
 		return DUCKDB_TYPE_ANY;
+	case LogicalTypeId::SQLNULL:
+		return DUCKDB_TYPE_SQLNULL;
 	default: // LCOV_EXCL_START
 		D_ASSERT(0);
 		return DUCKDB_TYPE_INVALID;

package/src/duckdb/src/main/config.cpp

@@ -363,16 +363,22 @@ idx_t DBConfig::GetSystemMaxThreads(FileSystem &fs) {
 }
 
 idx_t DBConfig::GetSystemAvailableMemory(FileSystem &fs) {
+#ifdef __linux__
 	// Check SLURM environment variables first
 	const char *slurm_mem_per_node = getenv("SLURM_MEM_PER_NODE");
 	const char *slurm_mem_per_cpu = getenv("SLURM_MEM_PER_CPU");
 
 	if (slurm_mem_per_node) {
-		return ParseMemoryLimitSlurm(slurm_mem_per_node);
+		auto limit = ParseMemoryLimitSlurm(slurm_mem_per_node);
+		if (limit.IsValid()) {
+			return limit.GetIndex();
+		}
 	} else if (slurm_mem_per_cpu) {
-		idx_t mem_per_cpu = ParseMemoryLimitSlurm(slurm_mem_per_cpu);
-		idx_t num_threads = GetSystemMaxThreads(fs);
-		return mem_per_cpu * num_threads;
+		auto mem_per_cpu = ParseMemoryLimitSlurm(slurm_mem_per_cpu);
+		if (mem_per_cpu.IsValid()) {
+			idx_t num_threads = GetSystemMaxThreads(fs);
+			return mem_per_cpu.GetIndex() * num_threads;
+		}
 	}
 
 	// Check cgroup memory limit
@@ -380,8 +386,9 @@ idx_t DBConfig::GetSystemAvailableMemory(FileSystem &fs) {
 	if (cgroup_memory_limit.IsValid()) {
 		return cgroup_memory_limit.GetIndex();
 	}
+#endif
 
-	// Fall back to system memory detection
+	// System memory detection
 	auto memory = FileSystem::GetAvailableMemory();
 	if (!memory.IsValid()) {
 		return DBConfigOptions().maximum_memory;
@@ -451,9 +458,9 @@ idx_t DBConfig::ParseMemoryLimit(const string &arg) {
 	return LossyNumericCast<idx_t>(static_cast<double>(multiplier) * limit);
 }
 
-idx_t DBConfig::ParseMemoryLimitSlurm(const string &arg) {
+optional_idx DBConfig::ParseMemoryLimitSlurm(const string &arg) {
 	if (arg.empty()) {
-		return 0;
+		return optional_idx();
 	}
 
 	string number_str = arg;
@@ -475,13 +482,19 @@ idx_t DBConfig::ParseMemoryLimitSlurm(const string &arg) {
 	}
 
 	// Parse the number
-	double limit = Cast::Operation<string_t, double>(string_t(number_str));
+	double limit;
+	if (!TryCast::Operation<string_t, double>(string_t(number_str), limit)) {
+		return optional_idx();
+	}
 
 	if (limit < 0) {
-		return NumericLimits<idx_t>::Maximum();
+		return static_cast<idx_t>(NumericLimits<int64_t>::Maximum());
 	}
-
-	return LossyNumericCast<idx_t>(static_cast<double>(multiplier) * limit);
+	idx_t actual_limit = LossyNumericCast<idx_t>(static_cast<double>(multiplier) * limit);
+	if (actual_limit == NumericLimits<idx_t>::Maximum()) {
+		return static_cast<idx_t>(NumericLimits<int64_t>::Maximum());
+	}
+	return actual_limit;
 }
 
 // Right now we only really care about access mode when comparing DBConfigs

package/src/duckdb/src/main/database.cpp

@@ -2,29 +2,29 @@
 
 #include "duckdb/catalog/catalog.hpp"
 #include "duckdb/common/virtual_file_system.hpp"
+#include "duckdb/execution/index/index_type_set.hpp"
 #include "duckdb/execution/operator/helper/physical_set.hpp"
 #include "duckdb/function/cast/cast_function_set.hpp"
 #include "duckdb/function/compression_function.hpp"
 #include "duckdb/main/attached_database.hpp"
 #include "duckdb/main/client_context.hpp"
 #include "duckdb/main/connection_manager.hpp"
+#include "duckdb/main/database_file_opener.hpp"
 #include "duckdb/main/database_manager.hpp"
 #include "duckdb/main/database_path_and_type.hpp"
+#include "duckdb/main/db_instance_cache.hpp"
 #include "duckdb/main/error_manager.hpp"
 #include "duckdb/main/extension_helper.hpp"
 #include "duckdb/main/secret/secret_manager.hpp"
 #include "duckdb/parallel/task_scheduler.hpp"
 #include "duckdb/parser/parsed_data/attach_info.hpp"
+#include "duckdb/planner/collation_binding.hpp"
 #include "duckdb/planner/extension_callback.hpp"
 #include "duckdb/storage/object_cache.hpp"
 #include "duckdb/storage/standard_buffer_manager.hpp"
 #include "duckdb/storage/storage_extension.hpp"
 #include "duckdb/storage/storage_manager.hpp"
 #include "duckdb/transaction/transaction_manager.hpp"
-#include "duckdb/execution/index/index_type_set.hpp"
-#include "duckdb/main/database_file_opener.hpp"
-#include "duckdb/planner/collation_binding.hpp"
-#include "duckdb/main/db_instance_cache.hpp"
 
 #ifndef DUCKDB_NO_THREADS
 #include "duckdb/common/thread.hpp"
@@ -436,7 +436,8 @@ void DatabaseInstance::Configure(DBConfig &new_config, const char *database_path
 		config.buffer_pool = std::move(new_config.buffer_pool);
 	} else {
 		config.buffer_pool = make_shared_ptr<BufferPool>(config.options.maximum_memory,
-		                                                 config.options.buffer_manager_track_eviction_timestamps);
+		                                                 config.options.buffer_manager_track_eviction_timestamps,
+		                                                 config.options.allocator_bulk_deallocation_flush_threshold);
 	}
 }
 

package/src/duckdb/src/main/extension/extension_install.cpp

@@ -268,15 +268,20 @@ static unique_ptr<ExtensionInstallInfo> DirectInstallExtension(DatabaseInstance
                                                                const string &local_extension_path,
                                                                ExtensionInstallOptions &options,
                                                                optional_ptr<ClientContext> context) {
-	string file = fs.ConvertSeparators(path);
-
-	// Try autoloading httpfs for loading extensions over https
-	if (context) {
-		auto &db = DatabaseInstance::GetDatabase(*context);
-		if (StringUtil::StartsWith(path, "https://") && !db.ExtensionIsLoaded("httpfs") &&
-		    db.config.options.autoload_known_extensions) {
-			ExtensionHelper::AutoLoadExtension(*context, "httpfs");
+	string extension;
+	string file;
+	if (fs.IsRemoteFile(path, extension)) {
+		file = path;
+		// Try autoloading httpfs for loading extensions over https
+		if (context) {
+			auto &db = DatabaseInstance::GetDatabase(*context);
+			if (extension == "httpfs" && !db.ExtensionIsLoaded("httpfs") &&
+			    db.config.options.autoload_known_extensions) {
+				ExtensionHelper::AutoLoadExtension(*context, "httpfs");
+			}
 		}
+	} else {
+		file = fs.ConvertSeparators(path);
 	}
 
 	// Check if file exists

package/src/duckdb/src/main/extension/extension_load.cpp

@@ -173,7 +173,7 @@ static string FilterZeroAtEnd(string s) {
 	return s;
 }
 
-ParsedExtensionMetaData ExtensionHelper::ParseExtensionMetaData(const char *metadata) {
+ParsedExtensionMetaData ExtensionHelper::ParseExtensionMetaData(const char *metadata) noexcept {
 	ParsedExtensionMetaData result;
 
 	vector<string> metadata_field;
@@ -194,12 +194,18 @@ ParsedExtensionMetaData ExtensionHelper::ParseExtensionMetaData(const char *meta
 
 	result.extension_version = FilterZeroAtEnd(metadata_field[3]);
 
-	result.abi_type = EnumUtil::FromString<ExtensionABIType>(FilterZeroAtEnd(metadata_field[4]));
+	auto extension_abi_metadata = FilterZeroAtEnd(metadata_field[4]);
 
-	if (result.abi_type == ExtensionABIType::C_STRUCT) {
+	if (extension_abi_metadata == "C_STRUCT") {
+		result.abi_type = ExtensionABIType::C_STRUCT;
 		result.duckdb_capi_version = FilterZeroAtEnd(metadata_field[2]);
-	} else if (result.abi_type == ExtensionABIType::CPP) {
+	} else if (extension_abi_metadata == "CPP" || extension_abi_metadata.empty()) {
+		result.abi_type = ExtensionABIType::CPP;
 		result.duckdb_version = FilterZeroAtEnd(metadata_field[2]);
+	} else {
+		result.abi_type = ExtensionABIType::UNKNOWN;
+		result.duckdb_version = "unknown";
+		result.extension_abi_metadata = extension_abi_metadata;
 	}
 
 	result.signature = string(metadata, ParsedExtensionMetaData::FOOTER_SIZE - ParsedExtensionMetaData::SIGNATURE_SIZE);

package/src/duckdb/src/main/extension.cpp

@@ -62,7 +62,7 @@ string ParsedExtensionMetaData::GetInvalidMetadataError() {
 			                       DUCKDB_EXTENSION_API_VERSION_MINOR, DUCKDB_EXTENSION_API_VERSION_PATCH);
 		}
 	} else {
-		throw InternalException("Unknown ABI type for extension: " + EnumUtil::ToString(abi_type));
+		throw InternalException("Unknown ABI type for extension: " + extension_abi_metadata);
 	}
 
 	if (engine_platform != platform) {

package/src/duckdb/src/optimizer/filter_pushdown.cpp

@@ -93,9 +93,14 @@ unique_ptr<LogicalOperator> FilterPushdown::Rewrite(unique_ptr<LogicalOperator>
 		// we can just push directly through these operations without any rewriting
 		op->children[0] = Rewrite(std::move(op->children[0]));
 		return op;
-	case LogicalOperatorType::LOGICAL_MATERIALIZED_CTE:
+	case LogicalOperatorType::LOGICAL_MATERIALIZED_CTE: {
+		// we can't push filters into the materialized CTE (LHS), but we do want to recurse into it
+		FilterPushdown pushdown(optimizer, convert_mark_joins);
+		op->children[0] = pushdown.Rewrite(std::move(op->children[0]));
+		// we can push filters into the rest of the query plan (RHS)
 		op->children[1] = Rewrite(std::move(op->children[1]));
 		return op;
+	}
 	case LogicalOperatorType::LOGICAL_GET:
 		return PushdownGet(std::move(op));
 	case LogicalOperatorType::LOGICAL_LIMIT:
@@ -127,6 +132,10 @@ unique_ptr<LogicalOperator> FilterPushdown::PushdownJoin(unique_ptr<LogicalOpera
 
 	switch (join.join_type) {
 	case JoinType::INNER:
+		//	AsOf joins can't push anything into the RHS, so treat it as a left join
+		if (op->type == LogicalOperatorType::LOGICAL_ASOF_JOIN) {
+			return PushdownLeftJoin(std::move(op), left_bindings, right_bindings);
+		}
 		return PushdownInnerJoin(std::move(op), left_bindings, right_bindings);
 	case JoinType::LEFT:
 		return PushdownLeftJoin(std::move(op), left_bindings, right_bindings);

package/src/duckdb/src/optimizer/join_filter_pushdown_optimizer.cpp

@@ -118,11 +118,6 @@ void JoinFilterPushdownOptimizer::GenerateJoinFilters(LogicalComparisonJoin &joi
 		}
 	}
 	// pushdown can be performed
-	// set up the dynamic filters (if we don't have any yet)
-	if (!get.dynamic_filters) {
-		get.dynamic_filters = make_shared_ptr<DynamicTableFilterSet>();
-	}
-	pushdown_info->dynamic_filters = get.dynamic_filters;
 
 	// set up the min/max aggregates for each of the filters
 	vector<AggregateFunction> aggr_functions;
@@ -135,9 +130,18 @@ void JoinFilterPushdownOptimizer::GenerateJoinFilters(LogicalComparisonJoin &joi
 			aggr_children.push_back(join.conditions[filter.join_condition].right->Copy());
 			auto aggr_expr = function_binder.BindAggregateFunction(aggr, std::move(aggr_children), nullptr,
 			                                                       AggregateType::NON_DISTINCT);
+			if (aggr_expr->children.size() != 1) {
+				// min/max with collation - not supported
+				return;
+			}
 			pushdown_info->min_max_aggregates.push_back(std::move(aggr_expr));
 		}
 	}
+	// set up the dynamic filters (if we don't have any yet)
+	if (!get.dynamic_filters) {
+		get.dynamic_filters = make_shared_ptr<DynamicTableFilterSet>();
+	}
+	pushdown_info->dynamic_filters = get.dynamic_filters;
 
 	// set up the filter pushdown in the join itself
 	join.filter_pushdown = std::move(pushdown_info);

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

@@ -2,10 +2,10 @@
 #include "duckdb/common/enums/join_type.hpp"
 #include "duckdb/common/limits.hpp"
 #include "duckdb/common/printer.hpp"
-#include "duckdb/planner/expression_iterator.hpp"
 #include "duckdb/function/table/table_scan.hpp"
 #include "duckdb/optimizer/join_order/join_node.hpp"
 #include "duckdb/optimizer/join_order/query_graph_manager.hpp"
+#include "duckdb/planner/expression_iterator.hpp"
 #include "duckdb/planner/operator/logical_comparison_join.hpp"
 #include "duckdb/storage/data_table.hpp"
 
@@ -291,10 +291,18 @@ DenomInfo CardinalityEstimator::GetDenominator(JoinRelationSet &set) {
 	// and we start to choose the filters that join relations in the set.
 
 	// edges are guaranteed to be in order of largest tdom to smallest tdom.
+	unordered_set<idx_t> unused_edge_tdoms;
 	auto edges = GetEdges(relations_to_tdoms, set);
 	for (auto &edge : edges) {
-		auto subgraph_connections = SubgraphsConnectedByEdge(edge, subgraphs);
+		if (subgraphs.size() == 1 && subgraphs.at(0).relations->ToString() == set.ToString()) {
+			// the first subgraph has connected all the desired relations, just skip the rest of the edges
+			if (edge.has_tdom_hll) {
+				unused_edge_tdoms.insert(edge.tdom_hll);
+			}
+			continue;
+		}
 
+		auto subgraph_connections = SubgraphsConnectedByEdge(edge, subgraphs);
 		if (subgraph_connections.empty()) {
 			// create a subgraph out of left and right, then merge right into left and add left to subgraphs.
 			// this helps cover a case where there are no subgraphs yet, and the only join filter is a SEMI JOIN
@@ -342,13 +350,11 @@ DenomInfo CardinalityEstimator::GetDenominator(JoinRelationSet &set) {
 			                                   [](Subgraph2Denominator &s) { return !s.relations; });
 			subgraphs.erase(remove_start, subgraphs.end());
 		}
-		if (subgraphs.size() == 1 && subgraphs.at(0).relations->ToString() == set.ToString()) {
-			// the first subgraph has connected all the desired relations, no need to iterate
-			// through the rest of the edges.
-			break;
-		}
 	}
 
+	// Slight penalty to cardinality for unused edges
+	auto denom_multiplier = 1.0 + static_cast<double>(unused_edge_tdoms.size());
+
 	// It's possible cross-products were added and are not present in the filters in the relation_2_tdom
 	// structures. When that's the case, merge all remaining subgraphs.
 	if (subgraphs.size() > 1) {
@@ -367,7 +373,7 @@ DenomInfo CardinalityEstimator::GetDenominator(JoinRelationSet &set) {
 		// denominator is 1 and numerators are a cross product of cardinalities.
 		return DenomInfo(set, 1, 1);
 	}
-	return DenomInfo(*subgraphs.at(0).numerator_relations, 1, subgraphs.at(0).denom);
+	return DenomInfo(*subgraphs.at(0).numerator_relations, 1, subgraphs.at(0).denom * denom_multiplier);
 }
 
 template <>

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

@@ -253,7 +253,9 @@ GenerateJoinRelation QueryGraphManager::GenerateJoins(vector<unique_ptr<LogicalO
 		auto right = GenerateJoins(extracted_relations, node->right_set);
 		if (dp_entry->second->info->filters.empty()) {
 			// no filters, create a cross product
+			auto cardinality = left.op->estimated_cardinality * right.op->estimated_cardinality;
 			result_operator = LogicalCrossProduct::Create(std::move(left.op), std::move(right.op));
+			result_operator->SetEstimatedCardinality(cardinality);
 		} else {
 			// we have filters, create a join node
 			auto chosen_filter = node->info->filters.at(0);

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

@@ -85,6 +85,7 @@ static bool OperatorNeedsRelation(LogicalOperatorType op_type) {
 	case LogicalOperatorType::LOGICAL_PROJECTION:
 	case LogicalOperatorType::LOGICAL_EXPRESSION_GET:
 	case LogicalOperatorType::LOGICAL_GET:
+	case LogicalOperatorType::LOGICAL_UNNEST:
 	case LogicalOperatorType::LOGICAL_DELIM_GET:
 	case LogicalOperatorType::LOGICAL_AGGREGATE_AND_GROUP_BY:
 	case LogicalOperatorType::LOGICAL_WINDOW:
@@ -269,6 +270,20 @@ bool RelationManager::ExtractJoinRelations(JoinOrderOptimizer &optimizer, Logica
 		AddAggregateOrWindowRelation(input_op, parent, operator_stats, op->type);
 		return true;
 	}
+	case LogicalOperatorType::LOGICAL_UNNEST: {
+		// optimize children of unnest
+		RelationStats child_stats;
+		auto child_optimizer = optimizer.CreateChildOptimizer();
+		op->children[0] = child_optimizer.Optimize(std::move(op->children[0]), &child_stats);
+		// the extracted cardinality should be set for window
+		if (!datasource_filters.empty()) {
+			child_stats.cardinality = LossyNumericCast<idx_t>(static_cast<double>(child_stats.cardinality) *
+			                                                  RelationStatisticsHelper::DEFAULT_SELECTIVITY);
+		}
+		ModifyStatsIfLimit(limit_op.get(), child_stats);
+		AddRelation(input_op, parent, child_stats);
+		return true;
+	}
 	case LogicalOperatorType::LOGICAL_COMPARISON_JOIN: {
 		auto &join = op->Cast<LogicalComparisonJoin>();
 		// Adding relations of the left side to the current join order optimizer

package/src/duckdb/src/optimizer/optimizer.cpp

@@ -95,7 +95,10 @@ void Optimizer::RunBuiltInOptimizers() {
 	case LogicalOperatorType::LOGICAL_CREATE_SECRET:
 	case LogicalOperatorType::LOGICAL_EXTENSION_OPERATOR:
 		// skip optimizing simple & often-occurring plans unaffected by rewrites
-		return;
+		if (plan->children.empty()) {
+			return;
+		}
+		break;
 	default:
 		break;
 	}

package/src/duckdb/src/optimizer/pushdown/pushdown_cross_product.cpp

@@ -14,9 +14,6 @@ unique_ptr<LogicalOperator> FilterPushdown::PushdownCrossProduct(unique_ptr<Logi
 	switch (op->type) {
 	case LogicalOperatorType::LOGICAL_CROSS_PRODUCT:
 		break;
-	case LogicalOperatorType::LOGICAL_ASOF_JOIN:
-		join_ref_type = JoinRefType::ASOF;
-		break;
 	default:
 		throw InternalException("Unsupported join type for cross product push down");
 	}
@@ -33,14 +30,7 @@ unique_ptr<LogicalOperator> FilterPushdown::PushdownCrossProduct(unique_ptr<Logi
 				// bindings match left side: push into left
 				left_pushdown.filters.push_back(std::move(f));
 			} else if (side == JoinSide::RIGHT) {
-				// bindings match right side: push into right
-				if (join_ref_type == JoinRefType::ASOF) {
-					// AsOf is really a table lookup, so we don't push filters
-					// down into the lookup (right) table
-					join_expressions.push_back(std::move(f->filter));
-				} else {
-					right_pushdown.filters.push_back(std::move(f));
-				}
+				right_pushdown.filters.push_back(std::move(f));
 			} else {
 				D_ASSERT(side == JoinSide::BOTH || side == JoinSide::NONE);
 				// bindings match both: turn into join condition

package/src/duckdb/src/optimizer/pushdown/pushdown_inner_join.cpp

@@ -26,8 +26,7 @@ unique_ptr<LogicalOperator> FilterPushdown::PushdownInnerJoin(unique_ptr<Logical
 		}
 	} else {
 		// comparison join
-		D_ASSERT(op->type == LogicalOperatorType::LOGICAL_COMPARISON_JOIN ||
-		         op->type == LogicalOperatorType::LOGICAL_ASOF_JOIN);
+		D_ASSERT(op->type == LogicalOperatorType::LOGICAL_COMPARISON_JOIN);
 		auto &comp_join = join.Cast<LogicalComparisonJoin>();
 		// turn the conditions into filters
 		for (auto &i : comp_join.conditions) {
@@ -40,11 +39,6 @@ unique_ptr<LogicalOperator> FilterPushdown::PushdownInnerJoin(unique_ptr<Logical
 	}
 	GenerateFilters();
 
-	//	For AsOf joins, just use the original op
-	if (op->type == LogicalOperatorType::LOGICAL_ASOF_JOIN) {
-		return PushdownCrossProduct(std::move(op));
-	}
-
 	// turn the inner join into a cross product
 	auto cross_product = make_uniq<LogicalCrossProduct>(std::move(op->children[0]), std::move(op->children[1]));
 

package/src/duckdb/src/optimizer/pushdown/pushdown_left_join.cpp

@@ -93,7 +93,7 @@ unique_ptr<LogicalOperator> FilterPushdown::PushdownLeftJoin(unique_ptr<LogicalO
 			// erase the filter from the list of filters
 			filters.erase_at(i);
 			i--;
-		} else {
+		} else if (op->type != LogicalOperatorType::LOGICAL_ASOF_JOIN) {
 			// bindings match right side or both sides: we cannot directly push it into the right
 			// however, if the filter removes rows with null values from the RHS we can turn the left outer join
 			// in an inner join, and then push down as we would push down an inner join

package/src/duckdb/src/optimizer/statistics/expression/propagate_cast.cpp

@@ -27,6 +27,9 @@ static unique_ptr<BaseStatistics> StatisticsNumericCastSwitch(const BaseStatisti
 	case LogicalTypeId::TIME: {
 		switch (input.GetType().id()) {
 		case LogicalTypeId::TIMESTAMP:
+		case LogicalTypeId::TIMESTAMP_SEC:
+		case LogicalTypeId::TIMESTAMP_MS:
+		case LogicalTypeId::TIMESTAMP_NS:
 		case LogicalTypeId::TIMESTAMP_TZ:
 			return nullptr;
 		default:

package/src/duckdb/src/optimizer/statistics/operator/propagate_join.cpp

@@ -104,6 +104,7 @@ void StatisticsPropagator::PropagateStatistics(LogicalComparisonJoin &join, uniq
 						// TODO: write better CE logic for limits so that we can just look at
 						//  join.children[1].estimated_cardinality.
 						auto limit = make_uniq<LogicalLimit>(BoundLimitNode::ConstantValue(1), BoundLimitNode());
+						limit->SetEstimatedCardinality(1);
 						limit->AddChild(std::move(join.children[1]));
 						auto cross_product = LogicalCrossProduct::Create(std::move(join.children[0]), std::move(limit));
 						node_ptr = std::move(cross_product);

package/src/duckdb/src/parser/keyword_helper.cpp

@@ -5,6 +5,10 @@
 namespace duckdb {
 
 bool KeywordHelper::IsKeyword(const string &text) {
+	return Parser::IsKeyword(text) != KeywordCategory::KEYWORD_NONE;
+}
+
+KeywordCategory KeywordHelper::KeywordCategoryType(const string &text) {
 	return Parser::IsKeyword(text);
 }