merge with v1.2.1

Author: Maxxen

Makefile

@@ -1,7 +1,7 @@
 PROJ_DIR := $(dir $(abspath $(lastword $(MAKEFILE_LIST))))
 
 # Configuration of extension
-EXT_NAME=excel
+EXT_NAME=spatial
 EXT_CONFIG=${PROJ_DIR}extension_config.cmake
 
 # Include the Makefile from extension-ci-tools

duckdb

@@ -34,7 +34,7 @@ class RTreeIndex final : public BoundIndex {
 		return std::move(res);
 	}
 
-	static unique_ptr<PhysicalOperator> CreatePlan(PlanIndexInput &input);
+	static PhysicalOperator &CreatePlan(PlanIndexInput &input);
 
 public:
 	//! Called when data is appended to the index. The lock obtained from InitializeLock must be held

src/spatial/index/rtree/rtree_index.hpp

@@ -39,8 +39,8 @@ void LogicalCreateRTreeIndex::ResolveColumnBindings(ColumnBindingResolver &res,
 	                                             [&](unique_ptr<Expression> *child) { res.VisitExpression(child); });
 }
 
-static unique_ptr<PhysicalOperator> CreateNullFilter(const LogicalOperator &op, const vector<LogicalType> &types,
-                                                     ClientContext &context) {
+static PhysicalOperator &CreateNullFilter(PhysicalPlanGenerator &generator, const LogicalOperator &op,
+                                          const vector<LogicalType> &types, ClientContext &context) {
 	vector<unique_ptr<Expression>> filter_select_list;
 
 	// Filter NOT NULL on the GEOMETRY column
@@ -66,14 +66,13 @@ static unique_ptr<PhysicalOperator> CreateNullFilter(const LogicalOperator &op,
 	// Combine into an AND
 	auto and_expr = make_uniq_base<Expression, BoundConjunctionExpression>(
 	    ExpressionType::CONJUNCTION_AND, std::move(is_not_null_expr), std::move(is_not_empty_expr));
-
 	filter_select_list.push_back(std::move(and_expr));
 
-	return make_uniq<PhysicalFilter>(types, std::move(filter_select_list), op.estimated_cardinality);
+	return generator.Make<PhysicalFilter>(types, std::move(filter_select_list), op.estimated_cardinality);
 }
 
-static unique_ptr<PhysicalOperator>
-CreateBoundingBoxProjection(const LogicalOperator &op, const vector<LogicalType> &types, ClientContext &context) {
+static PhysicalOperator &CreateBoundingBoxProjection(PhysicalPlanGenerator &planner, const LogicalOperator &op,
+                                                     const vector<LogicalType> &types, ClientContext &context) {
 	auto &catalog = Catalog::GetSystemCatalog(context);
 
 	// Get the bounding box function
@@ -96,11 +95,11 @@ CreateBoundingBoxProjection(const LogicalOperator &op, const vector<LogicalType>
 	select_list.push_back(std::move(bbox_expr));
 	select_list.push_back(std::move(rowid_expr));
 
-	return make_uniq<PhysicalProjection>(types, std::move(select_list), op.estimated_cardinality);
+	return planner.Make<PhysicalProjection>(types, std::move(select_list), op.estimated_cardinality);
 }
 
-static unique_ptr<PhysicalOperator> CreateOrderByMinX(const LogicalOperator &op, const vector<LogicalType> &types,
-                                                      ClientContext &context) {
+static PhysicalOperator &CreateOrderByMinX(PhysicalPlanGenerator &planner, const LogicalOperator &op,
+                                           const vector<LogicalType> &types, ClientContext &context) {
 	auto &catalog = Catalog::GetSystemCatalog(context);
 
 	// Get the centroid value function
@@ -130,14 +129,15 @@ static unique_ptr<PhysicalOperator> CreateOrderByMinX(const LogicalOperator &op,
 	vector<BoundOrderByNode> orders;
 	orders.emplace_back(OrderType::ASCENDING, OrderByNullType::NULLS_FIRST, std::move(xmin_expr));
 	vector<idx_t> projections = {0, 1};
-	return make_uniq<PhysicalOrder>(types, std::move(orders), projections, op.estimated_cardinality);
+	return planner.Make<PhysicalOrder>(types, std::move(orders), projections, op.estimated_cardinality);
 }
 
-unique_ptr<PhysicalOperator> RTreeIndex::CreatePlan(PlanIndexInput &input) {
+PhysicalOperator &RTreeIndex::CreatePlan(PlanIndexInput &input) {
 
 	auto &op = input.op;
 	auto &table_scan = input.table_scan;
 	auto &context = input.context;
+	auto &planner = input.planner;
 
 	// generate a physical plan for the parallel index creation which consists of the following operators
 	// table scan - projection (for expression execution) - filter (NOT NULL) - order - create index
@@ -175,38 +175,35 @@ unique_ptr<PhysicalOperator> RTreeIndex::CreatePlan(PlanIndexInput &input) {
 	select_list.push_back(make_uniq<BoundReferenceExpression>(LogicalType::ROW_TYPE, op.info->scan_types.size() - 1));
 
 	// Project the expressions
-	auto projection = make_uniq<PhysicalProjection>(new_column_types, std::move(select_list), op.estimated_cardinality);
-	projection->children.push_back(std::move(table_scan));
+	auto &projection =
+	    planner.Make<PhysicalProjection>(new_column_types, std::move(select_list), op.estimated_cardinality);
+	projection.children.push_back(table_scan);
 
 	// Filter operator for (IS_NOT_NULL) and (NOT ST_IsEmpty) on the geometry column
-	auto null_filter = CreateNullFilter(op, new_column_types, context);
-	null_filter->children.push_back(std::move(projection));
+	auto &null_filter = CreateNullFilter(planner, op, new_column_types, context);
+	null_filter.children.push_back(projection);
 
 	// Project the bounding box and the row ID
 	vector<LogicalType> projected_types = {GeoTypes::BOX_2DF(), LogicalType::ROW_TYPE};
-	auto bbox_proj = CreateBoundingBoxProjection(op, projected_types, context);
-	bbox_proj->children.push_back(std::move(null_filter));
+	auto &bbox_proj = CreateBoundingBoxProjection(planner, op, projected_types, context);
+	bbox_proj.children.push_back(null_filter);
 
 	// Create an ORDER_BY operator to sort the bounding boxes by the xmin value
-	auto physical_order = CreateOrderByMinX(op, projected_types, context);
-	physical_order->children.push_back(std::move(bbox_proj));
+	auto &physical_order = CreateOrderByMinX(planner, op, projected_types, context);
+	physical_order.children.push_back(bbox_proj);
 
 	// Now finally create the actual physical create index operator
-	auto physical_create_index =
-	    make_uniq<PhysicalCreateRTreeIndex>(op, op.table, op.info->column_ids, std::move(op.info),
-	                                        std::move(op.unbound_expressions), op.estimated_cardinality);
-
-	physical_create_index->children.push_back(std::move(physical_order));
-
-	return std::move(physical_create_index);
+	auto &physical_create_index =
+	    planner.Make<PhysicalCreateRTreeIndex>(op, op.table, op.info->column_ids, std::move(op.info),
+	                                           std::move(op.unbound_expressions), op.estimated_cardinality);
+	physical_create_index.children.push_back(physical_order);
+	return physical_create_index;
 }
 
 // TODO: Remove this
-unique_ptr<PhysicalOperator> LogicalCreateRTreeIndex::CreatePlan(ClientContext &context,
-                                                                 PhysicalPlanGenerator &generator) {
-
-	auto table_scan = generator.CreatePlan(std::move(children[0]));
+PhysicalOperator &LogicalCreateRTreeIndex::CreatePlan(ClientContext &context, PhysicalPlanGenerator &planner) {
 
+	auto &table_scan = planner.CreatePlan(*children[0]);
 	auto &op = *this;
 
 	// generate a physical plan for the parallel index creation which consists of the following operators
@@ -235,7 +232,7 @@ unique_ptr<PhysicalOperator> LogicalCreateRTreeIndex::CreatePlan(ClientContext &
 	D_ASSERT(op.info->index_type == RTreeIndex::TYPE_NAME);
 
 	// table scan operator for index key columns and row IDs
-	generator.dependencies.AddDependency(op.table);
+	planner.dependencies.AddDependency(op.table);
 
 	D_ASSERT(op.info->scan_types.size() - 1 <= op.info->names.size());
 	D_ASSERT(op.info->scan_types.size() - 1 <= op.info->column_ids.size());
@@ -255,30 +252,29 @@ unique_ptr<PhysicalOperator> LogicalCreateRTreeIndex::CreatePlan(ClientContext &
 	select_list.push_back(make_uniq<BoundReferenceExpression>(LogicalType::ROW_TYPE, op.info->scan_types.size() - 1));
 
 	// Project the expressions
-	auto projection = make_uniq<PhysicalProjection>(new_column_types, std::move(select_list), op.estimated_cardinality);
-	projection->children.push_back(std::move(table_scan));
+	auto &projection =
+	    planner.Make<PhysicalProjection>(new_column_types, std::move(select_list), op.estimated_cardinality);
+	projection.children.push_back(table_scan);
 
 	// Filter operator for (IS_NOT_NULL) and (NOT ST_IsEmpty) on the geometry column
-	auto null_filter = CreateNullFilter(op, new_column_types, context);
-	null_filter->children.push_back(std::move(projection));
+	auto &null_filter = CreateNullFilter(planner, op, new_column_types, context);
+	null_filter.children.push_back(projection);
 
 	// Project the bounding box and the row ID
 	vector<LogicalType> projected_types = {GeoTypes::BOX_2DF(), LogicalType::ROW_TYPE};
-	auto bbox_proj = CreateBoundingBoxProjection(op, projected_types, context);
-	bbox_proj->children.push_back(std::move(null_filter));
+	auto &bbox_proj = CreateBoundingBoxProjection(planner, op, projected_types, context);
+	bbox_proj.children.push_back(null_filter);
 
 	// Create an ORDER_BY operator to sort the bounding boxes by the xmin value
-	auto physical_order = CreateOrderByMinX(op, projected_types, context);
-	physical_order->children.push_back(std::move(bbox_proj));
+	auto &physical_order = CreateOrderByMinX(planner, op, projected_types, context);
+	physical_order.children.push_back(bbox_proj);
 
 	// Now finally create the actual physical create index operator
-	auto physical_create_index =
-	    make_uniq<PhysicalCreateRTreeIndex>(op, op.table, op.info->column_ids, std::move(op.info),
-	                                        std::move(op.unbound_expressions), op.estimated_cardinality);
-
-	physical_create_index->children.push_back(std::move(physical_order));
-
-	return std::move(physical_create_index);
+	auto &physical_create_index =
+	    planner.Make<PhysicalCreateRTreeIndex>(op, op.table, op.info->column_ids, std::move(op.info),
+	                                           std::move(op.unbound_expressions), op.estimated_cardinality);
+	physical_create_index.children.push_back(physical_order);
+	return physical_create_index;
 }
 
 } // namespace duckdb

src/spatial/index/rtree/rtree_index_create_logical.cpp

@@ -25,7 +25,7 @@ class LogicalCreateRTreeIndex final : public LogicalExtensionOperator {
 	void ResolveColumnBindings(ColumnBindingResolver &res, vector<ColumnBinding> &bindings) override;
 
 	// Actually create and plan the index creation
-	unique_ptr<PhysicalOperator> CreatePlan(ClientContext &context, PhysicalPlanGenerator &generator) override;
+	PhysicalOperator &CreatePlan(ClientContext &context, PhysicalPlanGenerator &planner) override;
 
 	void Serialize(Serializer &writer) const override {
 		LogicalExtensionOperator::Serialize(writer);

src/spatial/index/rtree/rtree_index_create_logical.hpp

@@ -60,7 +60,7 @@ static unique_ptr<GlobalTableFunctionState> RTreeIndexScanInitGlobal(ClientConte
 	}
 
 	// Initialize the storage scan state
-	result->local_storage_state.Initialize(result->column_ids, input.filters.get());
+	result->local_storage_state.Initialize(result->column_ids, context, input.filters);
 	local_storage.InitializeScan(bind_data.table.GetStorage(), result->local_storage_state.local_state, input.filters);
 
 	// Initialize the scan state for the index

src/spatial/index/rtree/rtree_index_scan.cpp

@@ -10,7 +10,7 @@
 // DuckDB
 #include "duckdb/main/database.hpp"
 #include "duckdb/common/enums/file_glob_options.hpp"
-#include "duckdb/common/multi_file_reader.hpp"
+#include "duckdb/common/multi_file/multi_file_reader.hpp"
 #include "duckdb/function/table/arrow.hpp"
 #include "duckdb/main/extension_util.hpp"
 #include "duckdb/parser/parsed_data/create_table_function_info.hpp"

src/spatial/modules/gdal/gdal_module.cpp

@@ -3,7 +3,7 @@
 #include "spatial/geometry/sgl.hpp"
 #include "spatial/spatial_types.hpp"
 
-#include "duckdb/common/multi_file_reader.hpp"
+#include "duckdb/common/multi_file/multi_file_reader.hpp"
 #include "duckdb/function/replacement_scan.hpp"
 #include "duckdb/main/extension_util.hpp"
 #include "duckdb/parser/expression/constant_expression.hpp"

src/spatial/modules/shapefile/shapefile_module.cpp

@@ -25,7 +25,7 @@ SElECT ST_Dump(ST_GeomFromText('GEOMETRYCOLLECTION EMPTY'));
 query I
 SElECT ST_Dump(ST_GeomFromText('GEOMETRYCOLLECTION (POINT (0 0))'));
 ----
-[{'geom': POINT (0 0), 'path': [1]}]
+[{'geom': 'POINT (0 0)', 'path': [1]}]
 
 # Test with multipoint
 query II
@@ -69,9 +69,9 @@ FROM (VALUES
     (ST_GeomFromText('GEOMETRYCOLLECTION (POINT (1 1), GEOMETRYCOLLECTION(POINT (3 3)), POINT (2 2))'))
 ) as t(geom)
 ----
-[{'geom': POINT (1 1), 'path': [1]}, {'geom': POINT (2 2), 'path': [2]}, {'geom': POINT (3 3), 'path': [3, 1]}]
+[{'geom': 'POINT (1 1)', 'path': [1]}, {'geom': 'POINT (2 2)', 'path': [2]}, {'geom': 'POINT (3 3)', 'path': [3, 1]}]
 NULL
-[{'geom': POINT (1 1), 'path': [1]}, {'geom': POINT (3 3), 'path': [2, 1]}, {'geom': POINT (2 2), 'path': [3]}]
+[{'geom': 'POINT (1 1)', 'path': [1]}, {'geom': 'POINT (3 3)', 'path': [2, 1]}, {'geom': 'POINT (2 2)', 'path': [3]}]
 
 
 # With Z and M