duckdb 0.8.1-dev96.0 → 0.8.2-dev1.0

package/src/duckdb/src/include/duckdb/function/aggregate_function.hpp

@@ -8,40 +8,13 @@
 
 #pragma once
 
-#include "duckdb/function/function.hpp"
-#include "duckdb/storage/statistics/base_statistics.hpp"
-#include "duckdb/storage/statistics/node_statistics.hpp"
+#include "duckdb/function/aggregate_state.hpp"
 #include "duckdb/planner/bound_result_modifier.hpp"
 #include "duckdb/planner/expression.hpp"
 #include "duckdb/common/vector_operations/aggregate_executor.hpp"
 
 namespace duckdb {
 
-enum class AggregateType : uint8_t { NON_DISTINCT = 1, DISTINCT = 2 };
-//! Whether or not the input order influences the result of the aggregate
-enum class AggregateOrderDependent : uint8_t { ORDER_DEPENDENT = 1, NOT_ORDER_DEPENDENT = 2 };
-
-class BoundAggregateExpression;
-
-struct AggregateInputData {
-	AggregateInputData(FunctionData *bind_data_p, Allocator &allocator_p)
-	    : bind_data(bind_data_p), allocator(allocator_p) {
-	}
-	FunctionData *bind_data;
-	Allocator &allocator;
-};
-
-struct AggregateStatisticsInput {
-	AggregateStatisticsInput(FunctionData *bind_data_p, vector<BaseStatistics> &child_stats_p,
-	                         NodeStatistics *node_stats_p)
-	    : bind_data(bind_data_p), child_stats(child_stats_p), node_stats(node_stats_p) {
-	}
-
-	FunctionData *bind_data;
-	vector<BaseStatistics> &child_stats;
-	NodeStatistics *node_stats;
-};
-
 //! The type used for sizing hashed aggregate function states
 typedef idx_t (*aggregate_size_t)();
 //! The type used for initializing hashed aggregate function states
@@ -76,7 +49,7 @@ typedef void (*aggregate_window_t)(Vector inputs[], const ValidityMask &filter_m
 
 typedef void (*aggregate_serialize_t)(FieldWriter &writer, const FunctionData *bind_data,
                                       const AggregateFunction &function);
-typedef unique_ptr<FunctionData> (*aggregate_deserialize_t)(ClientContext &context, FieldReader &reader,
+typedef unique_ptr<FunctionData> (*aggregate_deserialize_t)(PlanDeserializationState &context, FieldReader &reader,
                                                             AggregateFunction &function);
 
 class AggregateFunction : public BaseScalarFunction {
@@ -215,7 +188,7 @@ public:
 
 	template <class STATE, class OP>
 	static void StateInitialize(data_ptr_t state) {
-		OP::Initialize((STATE *)state);
+		OP::Initialize(*reinterpret_cast<STATE *>(state));
 	}
 
 	template <class STATE, class OP>
@@ -281,6 +254,12 @@ public:
 		AggregateExecutor::Finalize<STATE, RESULT_TYPE, OP>(states, aggr_input_data, result, count, offset);
 	}
 
+	template <class STATE, class OP>
+	static void StateVoidFinalize(Vector &states, AggregateInputData &aggr_input_data, Vector &result, idx_t count,
+	                              idx_t offset) {
+		AggregateExecutor::VoidFinalize<STATE, OP>(states, aggr_input_data, result, count, offset);
+	}
+
 	template <class STATE, class OP>
 	static void StateDestroy(Vector &states, AggregateInputData &aggr_input_data, idx_t count) {
 		AggregateExecutor::Destroy<STATE, OP>(states, aggr_input_data, count);

package/src/duckdb/src/include/duckdb/function/aggregate_state.hpp

@@ -0,0 +1,95 @@
+//===----------------------------------------------------------------------===//
+//                         DuckDB
+//
+// duckdb/function/aggregate_state.hpp
+//
+//
+//===----------------------------------------------------------------------===//
+
+#pragma once
+
+#include "duckdb/function/function.hpp"
+#include "duckdb/storage/statistics/base_statistics.hpp"
+#include "duckdb/storage/statistics/node_statistics.hpp"
+
+namespace duckdb {
+
+enum class AggregateType : uint8_t { NON_DISTINCT = 1, DISTINCT = 2 };
+//! Whether or not the input order influences the result of the aggregate
+enum class AggregateOrderDependent : uint8_t { ORDER_DEPENDENT = 1, NOT_ORDER_DEPENDENT = 2 };
+
+class BoundAggregateExpression;
+
+struct AggregateInputData {
+	AggregateInputData(optional_ptr<FunctionData> bind_data_p, Allocator &allocator_p)
+	    : bind_data(bind_data_p), allocator(allocator_p) {
+	}
+	optional_ptr<FunctionData> bind_data;
+	Allocator &allocator;
+};
+
+struct AggregateUnaryInput {
+	AggregateUnaryInput(AggregateInputData &input_p, ValidityMask &input_mask_p)
+	    : input(input_p), input_mask(input_mask_p), input_idx(0) {
+	}
+
+	AggregateInputData &input;
+	ValidityMask &input_mask;
+	idx_t input_idx;
+
+	inline bool RowIsValid() {
+		return input_mask.RowIsValid(input_idx);
+	}
+};
+
+struct AggregateBinaryInput {
+	AggregateBinaryInput(AggregateInputData &input_p, ValidityMask &left_mask_p, ValidityMask &right_mask_p)
+	    : input(input_p), left_mask(left_mask_p), right_mask(right_mask_p) {
+	}
+
+	AggregateInputData &input;
+	ValidityMask &left_mask;
+	ValidityMask &right_mask;
+	idx_t lidx;
+	idx_t ridx;
+};
+
+struct AggregateFinalizeData {
+	AggregateFinalizeData(Vector &result_p, AggregateInputData &input_p)
+	    : result(result_p), input(input_p), result_idx(0) {
+	}
+
+	Vector &result;
+	AggregateInputData &input;
+	idx_t result_idx;
+
+	inline void ReturnNull() {
+		switch (result.GetVectorType()) {
+		case VectorType::FLAT_VECTOR:
+			FlatVector::SetNull(result, result_idx, true);
+			break;
+		case VectorType::CONSTANT_VECTOR:
+			ConstantVector::SetNull(result, true);
+			break;
+		default:
+			throw InternalException("Invalid result vector type for aggregate");
+		}
+	}
+
+	inline string_t ReturnString(string_t value) {
+		return StringVector::AddStringOrBlob(result, value);
+	}
+};
+
+struct AggregateStatisticsInput {
+	AggregateStatisticsInput(optional_ptr<FunctionData> bind_data_p, vector<BaseStatistics> &child_stats_p,
+	                         optional_ptr<NodeStatistics> node_stats_p)
+	    : bind_data(bind_data_p), child_stats(child_stats_p), node_stats(node_stats_p) {
+	}
+
+	optional_ptr<FunctionData> bind_data;
+	vector<BaseStatistics> &child_stats;
+	optional_ptr<NodeStatistics> node_stats;
+};
+
+} // namespace duckdb

package/src/duckdb/src/include/duckdb/function/function_serialization.hpp

@@ -25,8 +25,10 @@ public:
 		bool serialize = function.serialize;
 		writer.WriteField(serialize);
 		if (serialize) {
-			D_ASSERT(function.deserialize);
 			function.serialize(writer, bind_info, function);
+			// First check if serialize throws a NotImplementedException, in which case it doesn't require a deserialize
+			// function
+			D_ASSERT(function.deserialize);
 		}
 	}
 
@@ -64,7 +66,7 @@ public:
 				throw SerializationException("Function requires deserialization but no deserialization function for %s",
 				                             function.name);
 			}
-			bind_info = function.deserialize(context, reader, function);
+			bind_info = function.deserialize(state, reader, function);
 		} else {
 			D_ASSERT(!function.serialize);
 			D_ASSERT(!function.deserialize);

package/src/duckdb/src/include/duckdb/function/scalar/nested_functions.hpp

@@ -68,7 +68,7 @@ struct VariableReturnBindData : public FunctionData {
 		writer.WriteSerializable(info.stype);
 	}
 
-	static unique_ptr<FunctionData> Deserialize(ClientContext &context, FieldReader &reader,
+	static unique_ptr<FunctionData> Deserialize(PlanDeserializationState &context, FieldReader &reader,
 	                                            ScalarFunction &bound_function) {
 		auto stype = reader.ReadRequiredSerializable<LogicalType, LogicalType>();
 		return make_uniq<VariableReturnBindData>(std::move(stype));

package/src/duckdb/src/include/duckdb/function/scalar_function.hpp

@@ -14,6 +14,7 @@
 #include "duckdb/common/vector_operations/vector_operations.hpp"
 #include "duckdb/execution/expression_executor_state.hpp"
 #include "duckdb/function/function.hpp"
+#include "duckdb/planner/plan_serialization.hpp"
 #include "duckdb/storage/statistics/base_statistics.hpp"
 #include "duckdb/common/optional_ptr.hpp"
 
@@ -65,7 +66,7 @@ typedef void (*dependency_function_t)(BoundFunctionExpression &expr, DependencyL
 
 typedef void (*function_serialize_t)(FieldWriter &writer, const FunctionData *bind_data,
                                      const ScalarFunction &function);
-typedef unique_ptr<FunctionData> (*function_deserialize_t)(ClientContext &context, FieldReader &reader,
+typedef unique_ptr<FunctionData> (*function_deserialize_t)(PlanDeserializationState &state, FieldReader &reader,
                                                            ScalarFunction &function);
 
 class ScalarFunction : public BaseScalarFunction {

package/src/duckdb/src/include/duckdb/function/table_function.hpp

@@ -9,12 +9,12 @@
 #pragma once
 
 #include "duckdb/common/enums/operator_result_type.hpp"
+#include "duckdb/common/optional_ptr.hpp"
 #include "duckdb/execution/execution_context.hpp"
 #include "duckdb/function/function.hpp"
 #include "duckdb/planner/bind_context.hpp"
 #include "duckdb/planner/logical_operator.hpp"
 #include "duckdb/storage/statistics/node_statistics.hpp"
-#include "duckdb/common/optional_ptr.hpp"
 
 #include <functional>
 
@@ -204,7 +204,7 @@ typedef string (*table_function_to_string_t)(const FunctionData *bind_data);
 
 typedef void (*table_function_serialize_t)(FieldWriter &writer, const FunctionData *bind_data,
                                            const TableFunction &function);
-typedef unique_ptr<FunctionData> (*table_function_deserialize_t)(ClientContext &context, FieldReader &reader,
+typedef unique_ptr<FunctionData> (*table_function_deserialize_t)(PlanDeserializationState &context, FieldReader &reader,
                                                                  TableFunction &function);
 
 class TableFunction : public SimpleNamedParameterFunction {
@@ -265,6 +265,7 @@ public:
 
 	table_function_serialize_t serialize;
 	table_function_deserialize_t deserialize;
+	bool verify_serialization = true;
 
 	//! Whether or not the table function supports projection pushdown. If not supported a projection will be added
 	//! that filters out unused columns.

package/src/duckdb/src/include/duckdb/main/attached_database.hpp

@@ -40,7 +40,7 @@ public:
 	//! Create an attached database instance with the specified storage extension
 	AttachedDatabase(DatabaseInstance &db, Catalog &catalog, StorageExtension &ext, string name, AttachInfo &info,
 	                 AccessMode access_mode);
-	~AttachedDatabase();
+	~AttachedDatabase() override;
 
 	void Initialize();
 
@@ -57,6 +57,8 @@ public:
 	bool IsSystem() const;
 	bool IsTemporary() const;
 	bool IsReadOnly() const;
+	bool IsInitialDatabase() const;
+	void SetInitialDatabase();
 
 	static string ExtractDatabaseName(const string &dbpath);
 
@@ -67,6 +69,7 @@ private:
 	unique_ptr<TransactionManager> transaction_manager;
 	AttachedDatabaseType type;
 	optional_ptr<Catalog> parent_catalog;
+	bool is_initial_database = false;
 };
 
 } // namespace duckdb

package/src/duckdb/src/include/duckdb/main/capi/capi_internal.hpp

@@ -13,6 +13,8 @@
 #include "duckdb/common/types.hpp"
 #include "duckdb/common/types/data_chunk.hpp"
 #include "duckdb/main/appender.hpp"
+#include "duckdb/common/arrow/arrow_options.hpp"
+
 #include <cstring>
 #include <cassert>
 
@@ -46,7 +48,7 @@ struct PendingStatementWrapper {
 struct ArrowResultWrapper {
 	unique_ptr<MaterializedQueryResult> result;
 	unique_ptr<DataChunk> current_chunk;
-	string timezone_config;
+	ArrowOptions options;
 };
 
 struct AppenderWrapper {

package/src/duckdb/src/include/duckdb/main/config.hpp

@@ -28,6 +28,7 @@
 #include "duckdb/optimizer/optimizer_extension.hpp"
 #include "duckdb/parser/parser_extension.hpp"
 #include "duckdb/planner/operator_extension.hpp"
+#include "duckdb/common/arrow/arrow_options.hpp"
 
 namespace duckdb {
 class BufferPool;
@@ -135,6 +136,8 @@ struct DBConfigOptions {
 	WindowAggregationMode window_mode = WindowAggregationMode::WINDOW;
 	//! Whether or not preserving insertion order should be preserved
 	bool preserve_insertion_order = true;
+	//! Whether Arrow Arrays use Large or Regular buffers
+	ArrowOffsetSize arrow_offset_size = ArrowOffsetSize::REGULAR;
 	//! Database configuration variables as controlled by SET
 	case_insensitive_map_t<Value> set_variables;
 	//! Database configuration variable default values;
@@ -151,6 +154,8 @@ struct DBConfigOptions {
 	DebugInitialize debug_initialize = DebugInitialize::NO_INITIALIZE;
 	//! The set of unrecognized (other) options
 	unordered_map<string, Value> unrecognized_options;
+	//! Whether or not the configuration settings can be altered
+	bool lock_configuration = false;
 	//! Whether to print bindings when printing the plan (debug mode only)
 	static bool debug_print_bindings;
 

package/src/duckdb/src/include/duckdb/main/database_manager.hpp

@@ -44,6 +44,7 @@ public:
 	//! Returns a reference to the system catalog
 	Catalog &GetSystemCatalog();
 	static const string &GetDefaultDatabase(ClientContext &context);
+	void SetDefaultDatabase(ClientContext &context, const string &new_value);
 
 	optional_ptr<AttachedDatabase> GetDatabaseFromPath(ClientContext &context, const string &path);
 	vector<reference<AttachedDatabase>> GetDatabases(ClientContext &context);

package/src/duckdb/src/include/duckdb/main/extension_entries.hpp

@@ -17,142 +17,148 @@ struct ExtensionEntry {
 	char extension[48];
 };
 
-static constexpr ExtensionEntry EXTENSION_FUNCTIONS[] = {
-    {"->>", "json"},
-    {"array_to_json", "json"},
-    {"create_fts_index", "fts"},
-    {"current_localtime", "icu"},
-    {"current_localtimestamp", "icu"},
-    {"dbgen", "tpch"},
-    {"drop_fts_index", "fts"},
-    {"dsdgen", "tpcds"},
-    {"excel_text", "excel"},
-    {"from_json", "json"},
-    {"from_json_strict", "json"},
-    {"from_substrait", "substrait"},
-    {"from_substrait_json", "substrait"},
-    {"get_substrait", "substrait"},
-    {"get_substrait_json", "substrait"},
-    {"icu_calendar_names", "icu"},
-    {"icu_sort_key", "icu"},
-    {"json", "json"},
-    {"json_array", "json"},
-    {"json_array_length", "json"},
-    {"json_contains", "json"},
-    {"json_extract", "json"},
-    {"json_extract_path", "json"},
-    {"json_extract_path_text", "json"},
-    {"json_extract_string", "json"},
-    {"json_group_array", "json"},
-    {"json_group_object", "json"},
-    {"json_group_structure", "json"},
-    {"json_keys", "json"},
-    {"json_merge_patch", "json"},
-    {"json_object", "json"},
-    {"json_quote", "json"},
-    {"json_structure", "json"},
-    {"json_transform", "json"},
-    {"json_transform_strict", "json"},
-    {"json_type", "json"},
-    {"json_valid", "json"},
-    {"json_serialize_sql", "json"},
-    {"json_deserialize_sql", "json"},
-    {"json_serialize_sql", "json"},
-    {"json_execute_serialized_sql", "json"},
-    {"make_timestamptz", "icu"},
-    {"parquet_metadata", "parquet"},
-    {"parquet_scan", "parquet"},
-    {"parquet_schema", "parquet"},
-    {"pg_timezone_names", "icu"},
-    {"postgres_attach", "postgres_scanner"},
-    {"postgres_scan", "postgres_scanner"},
-    {"postgres_scan_pushdown", "postgres_scanner"},
-    {"read_json", "json"},
-    {"read_json_auto", "json"},
-    {"read_json_objects", "json"},
-    {"read_json_objects_auto", "json"},
-    {"read_ndjson", "json"},
-    {"read_ndjson_auto", "json"},
-    {"read_ndjson_objects", "json"},
-    {"read_parquet", "parquet"},
-    {"row_to_json", "json"},
-    {"scan_arrow_ipc", "arrow"},
-    {"sqlite_attach", "sqlite_scanner"},
-    {"sqlite_scan", "sqlite_scanner"},
-    {"stem", "fts"},
-    {"text", "excel"},
-    {"to_arrow_ipc", "arrow"},
-    {"to_json", "json"},
-    {"tpcds", "tpcds"},
-    {"tpcds_answers", "tpcds"},
-    {"tpcds_queries", "tpcds"},
-    {"tpch", "tpch"},
-    {"tpch_answers", "tpch"},
-    {"tpch_queries", "tpch"},
-    {"visualize_diff_profiling_output", "visualizer"},
-    {"visualize_json_profiling_output", "visualizer"},
-    {"visualize_last_profiling_output", "visualizer"},
-    {"st_distance_spheroid", "spatial"},
-    {"st_boundary", "spatial"},
-    {"st_makeline", "spatial"},
-    {"st_buffer", "spatial"},
-    {"st_x", "spatial"},
-    {"st_isring", "spatial"},
-    {"st_centroid", "spatial"},
-    {"st_read", "spatial"},
-    {"st_geomfromwkb", "spatial"},
-    {"st_list_proj_crs", "spatial"},
-    {"st_isvalid", "spatial"},
-    {"st_polygon2dfromwkb", "spatial"},
-    {"st_disjoint", "spatial"},
-    {"st_length", "spatial"},
-    {"st_difference", "spatial"},
-    {"st_area", "spatial"},
-    {"st_union", "spatial"},
-    {"st_isclosed", "spatial"},
-    {"st_asgeojson", "spatial"},
-    {"st_intersection", "spatial"},
-    {"st_transform", "spatial"},
-    {"st_dwithin", "spatial"},
-    {"st_perimeter", "spatial"},
-    {"st_issimple", "spatial"},
-    {"st_geometrytype", "spatial"},
-    {"st_simplifypreservetopology", "spatial"},
-    {"st_distance", "spatial"},
-    {"st_astext", "spatial"},
-    {"st_overlaps", "spatial"},
-    {"st_convexhull", "spatial"},
-    {"st_normalize", "spatial"},
-    {"st_drivers", "spatial"},
-    {"st_point2dfromwkb", "spatial"},
-    {"st_point2d", "spatial"},
-    {"st_y", "spatial"},
-    {"st_dwithin_spheroid", "spatial"},
-    {"st_isempty", "spatial"},
-    {"st_simplify", "spatial"},
-    {"st_area_spheroid", "spatial"},
-    {"st_within", "spatial"},
-    {"st_length_spheroid", "spatial"},
-    {"st_point3d", "spatial"},
-    {"st_containsproperly", "spatial"},
-    {"st_contains", "spatial"},
-    {"st_collect", "spatial"},
-    {"st_touches", "spatial"},
-    {"st_linestring2dfromwkb", "spatial"},
-    {"st_flipcoordinates", "spatial"},
-    {"st_ashexwkb", "spatial"},
-    {"st_geomfromtext", "spatial"},
-    {"st_point4d", "spatial"},
-    {"st_point", "spatial"},
-    {"st_coveredby", "spatial"},
-    {"st_perimeter_spheroid", "spatial"},
-    {"st_intersects", "spatial"},
-    {"st_crosses", "spatial"},
-    {"st_covers", "spatial"},
-    {"st_envelope", "spatial"},
-    {"st_aswkb", "spatial"},
-    {"st_equals", "spatial"},
-};
+static constexpr ExtensionEntry EXTENSION_FUNCTIONS[] = {{"->>", "json"},
+                                                         {"array_to_json", "json"},
+                                                         {"create_fts_index", "fts"},
+                                                         {"current_localtime", "icu"},
+                                                         {"current_localtimestamp", "icu"},
+                                                         {"dbgen", "tpch"},
+                                                         {"drop_fts_index", "fts"},
+                                                         {"dsdgen", "tpcds"},
+                                                         {"excel_text", "excel"},
+                                                         {"from_json", "json"},
+                                                         {"from_json_strict", "json"},
+                                                         {"from_substrait", "substrait"},
+                                                         {"from_substrait_json", "substrait"},
+                                                         {"get_substrait", "substrait"},
+                                                         {"get_substrait_json", "substrait"},
+                                                         {"icu_calendar_names", "icu"},
+                                                         {"icu_sort_key", "icu"},
+                                                         {"json", "json"},
+                                                         {"json_array", "json"},
+                                                         {"json_array_length", "json"},
+                                                         {"json_contains", "json"},
+                                                         {"json_extract", "json"},
+                                                         {"json_extract_path", "json"},
+                                                         {"json_extract_path_text", "json"},
+                                                         {"json_extract_string", "json"},
+                                                         {"json_group_array", "json"},
+                                                         {"json_group_object", "json"},
+                                                         {"json_group_structure", "json"},
+                                                         {"json_keys", "json"},
+                                                         {"json_merge_patch", "json"},
+                                                         {"json_object", "json"},
+                                                         {"json_quote", "json"},
+                                                         {"json_structure", "json"},
+                                                         {"json_transform", "json"},
+                                                         {"json_transform_strict", "json"},
+                                                         {"json_type", "json"},
+                                                         {"json_valid", "json"},
+                                                         {"json_serialize_sql", "json"},
+                                                         {"json_deserialize_sql", "json"},
+                                                         {"json_serialize_sql", "json"},
+                                                         {"json_execute_serialized_sql", "json"},
+                                                         {"make_timestamptz", "icu"},
+                                                         {"parquet_metadata", "parquet"},
+                                                         {"parquet_scan", "parquet"},
+                                                         {"parquet_schema", "parquet"},
+                                                         {"pg_timezone_names", "icu"},
+                                                         {"postgres_attach", "postgres_scanner"},
+                                                         {"postgres_scan", "postgres_scanner"},
+                                                         {"postgres_scan_pushdown", "postgres_scanner"},
+                                                         {"read_json", "json"},
+                                                         {"read_json_auto", "json"},
+                                                         {"read_json_objects", "json"},
+                                                         {"read_json_objects_auto", "json"},
+                                                         {"read_ndjson", "json"},
+                                                         {"read_ndjson_auto", "json"},
+                                                         {"read_ndjson_objects", "json"},
+                                                         {"read_parquet", "parquet"},
+                                                         {"row_to_json", "json"},
+                                                         {"scan_arrow_ipc", "arrow"},
+                                                         {"sqlite_attach", "sqlite_scanner"},
+                                                         {"sqlite_scan", "sqlite_scanner"},
+                                                         {"stem", "fts"},
+                                                         {"text", "excel"},
+                                                         {"to_arrow_ipc", "arrow"},
+                                                         {"to_json", "json"},
+                                                         {"tpcds", "tpcds"},
+                                                         {"tpcds_answers", "tpcds"},
+                                                         {"tpcds_queries", "tpcds"},
+                                                         {"tpch", "tpch"},
+                                                         {"tpch_answers", "tpch"},
+                                                         {"tpch_queries", "tpch"},
+                                                         {"visualize_diff_profiling_output", "visualizer"},
+                                                         {"visualize_json_profiling_output", "visualizer"},
+                                                         {"visualize_last_profiling_output", "visualizer"},
+                                                         {"st_distance_spheroid", "spatial"},
+                                                         {"st_boundary", "spatial"},
+                                                         {"st_makeline", "spatial"},
+                                                         {"st_buffer", "spatial"},
+                                                         {"st_x", "spatial"},
+                                                         {"st_isring", "spatial"},
+                                                         {"st_centroid", "spatial"},
+                                                         {"st_read", "spatial"},
+                                                         {"st_geomfromwkb", "spatial"},
+                                                         {"st_list_proj_crs", "spatial"},
+                                                         {"st_isvalid", "spatial"},
+                                                         {"st_polygon2dfromwkb", "spatial"},
+                                                         {"st_disjoint", "spatial"},
+                                                         {"st_length", "spatial"},
+                                                         {"st_difference", "spatial"},
+                                                         {"st_area", "spatial"},
+                                                         {"st_union", "spatial"},
+                                                         {"st_isclosed", "spatial"},
+                                                         {"st_asgeojson", "spatial"},
+                                                         {"st_intersection", "spatial"},
+                                                         {"st_transform", "spatial"},
+                                                         {"st_dwithin", "spatial"},
+                                                         {"st_perimeter", "spatial"},
+                                                         {"st_issimple", "spatial"},
+                                                         {"st_geometrytype", "spatial"},
+                                                         {"st_simplifypreservetopology", "spatial"},
+                                                         {"st_distance", "spatial"},
+                                                         {"st_astext", "spatial"},
+                                                         {"st_overlaps", "spatial"},
+                                                         {"st_convexhull", "spatial"},
+                                                         {"st_normalize", "spatial"},
+                                                         {"st_drivers", "spatial"},
+                                                         {"st_point2dfromwkb", "spatial"},
+                                                         {"st_point2d", "spatial"},
+                                                         {"st_y", "spatial"},
+                                                         {"st_dwithin_spheroid", "spatial"},
+                                                         {"st_isempty", "spatial"},
+                                                         {"st_simplify", "spatial"},
+                                                         {"st_area_spheroid", "spatial"},
+                                                         {"st_within", "spatial"},
+                                                         {"st_length_spheroid", "spatial"},
+                                                         {"st_point3d", "spatial"},
+                                                         {"st_containsproperly", "spatial"},
+                                                         {"st_contains", "spatial"},
+                                                         {"st_collect", "spatial"},
+                                                         {"st_touches", "spatial"},
+                                                         {"st_linestring2dfromwkb", "spatial"},
+                                                         {"st_flipcoordinates", "spatial"},
+                                                         {"st_ashexwkb", "spatial"},
+                                                         {"st_geomfromtext", "spatial"},
+                                                         {"st_point4d", "spatial"},
+                                                         {"st_point", "spatial"},
+                                                         {"st_coveredby", "spatial"},
+                                                         {"st_perimeter_spheroid", "spatial"},
+                                                         {"st_intersects", "spatial"},
+                                                         {"st_crosses", "spatial"},
+                                                         {"st_covers", "spatial"},
+                                                         {"st_envelope", "spatial"},
+                                                         {"st_aswkb", "spatial"},
+                                                         {"st_equals", "spatial"},
+                                                         {"st_collectionextract", "spatial"},
+                                                         {"st_npoints", "spatial"},
+                                                         {"st_pointonsurface", "spatial"},
+                                                         {"st_dimension", "spatial"},
+                                                         {"st_removerepeatedpoints", "spatial"},
+                                                         {"st_geomfromgeojson", "spatial"},
+                                                         {"st_readosm", "spatial"},
+                                                         {"st_numpoints", "spatial"}};
 
 static constexpr ExtensionEntry EXTENSION_SETTINGS[] = {
     {"binary_as_string", "parquet"},