Add raster type & functions to manage rasters in the spatial extension

spatial/include/spatial/core/types.hpp

@@ -15,6 +15,9 @@ struct GeoTypes {
 	static LogicalType GEOMETRY();
 	static LogicalType WKB_BLOB();
 
+	static LogicalType RASTER();
+	static LogicalType RASTER_COORD();
+
 	static void Register(DatabaseInstance &db);
 
 	static LogicalType CreateEnumType(const string &name, const vector<string> &members);

spatial/include/spatial/gdal/file_handler.hpp

@@ -1,6 +1,7 @@
 #pragma once
 
 #include "spatial/common.hpp"
+#include "spatial/gdal/raster/raster_registry.hpp"
 #include "duckdb/main/database.hpp"
 
 namespace spatial {
@@ -12,13 +13,17 @@ class DuckDBFileSystemHandler;
 class GDALClientContextState : public ClientContextState {
 	string client_prefix;
 	DuckDBFileSystemHandler *fs_handler;
+	std::map<uintptr_t, std::unique_ptr<RasterRegistry>> registries;
+	std::mutex lock;
 
 public:
 	explicit GDALClientContextState(ClientContext &context);
 	~GDALClientContextState() override;
 	void QueryEnd() override;
+	void QueryEnd(ClientContext &context) override;
 	string GetPrefix(const string &value) const;
 	static GDALClientContextState &GetOrCreate(ClientContext &context);
+	RasterRegistry &GetRasterRegistry(ClientContext &context);
 };
 
 } // namespace gdal

spatial/include/spatial/gdal/functions.hpp

@@ -34,6 +34,22 @@ struct GdalTableFunction : ArrowTableFunction {
 	static void Register(DatabaseInstance &db);
 };
 
+struct GdalRasterTableFunction {
+private:
+	static unique_ptr<FunctionData> Bind(ClientContext &context, TableFunctionBindInput &input,
+	                                     vector<LogicalType> &return_types, vector<string> &names);
+
+	static void Execute(ClientContext &context, TableFunctionInput &input, DataChunk &output);
+
+	static unique_ptr<NodeStatistics> Cardinality(ClientContext &context, const FunctionData *data);
+
+	static unique_ptr<TableRef> ReplacementScan(ClientContext &context, ReplacementScanInput &input,
+	                                            optional_ptr<ReplacementScanData> data);
+
+public:
+	static void Register(DatabaseInstance &db);
+};
+
 struct GdalDriversTableFunction {
 
 	struct BindData : public TableFunctionData {
@@ -61,6 +77,14 @@ struct GdalMetadataFunction {
 	static void Register(DatabaseInstance &db);
 };
 
+struct GdalRasterMetadataFunction {
+	static void Register(DatabaseInstance &db);
+};
+
+struct GdalRasterCopyFunction {
+	static void Register(DatabaseInstance &db);
+};
+
 } // namespace gdal
 
 } // namespace spatial

spatial/include/spatial/gdal/functions/aggregate.hpp

@@ -0,0 +1,22 @@
+#pragma once
+#include "spatial/common.hpp"
+
+namespace spatial {
+
+namespace gdal {
+
+struct GdalAggregateFunctions {
+public:
+	static void Register(DatabaseInstance &db) {
+		RegisterStRasterMosaicAgg(db);
+		RegisterStRasterUnionAgg(db);
+	}
+
+private:
+	static void RegisterStRasterMosaicAgg(DatabaseInstance &db);
+	static void RegisterStRasterUnionAgg(DatabaseInstance &db);
+};
+
+} // namespace gdal
+
+} // namespace spatial

spatial/include/spatial/gdal/functions/cast.hpp

@@ -0,0 +1,15 @@
+#pragma once
+#include "spatial/common.hpp"
+
+namespace spatial {
+
+namespace gdal {
+
+struct GdalCastFunctions {
+public:
+	static void Register(DatabaseInstance &db);
+};
+
+} // namespace gdal
+
+} // namespace spatial

spatial/include/spatial/gdal/functions/raster_agg.hpp

@@ -0,0 +1,114 @@
+#pragma once
+#include "duckdb/function/aggregate_function.hpp"
+#include "spatial/common.hpp"
+
+class GDALDataset;
+
+namespace spatial {
+
+namespace gdal {
+
+struct RasterAggState {
+	bool is_set;
+	std::vector<GDALDataset *> datasets;
+};
+
+struct RasterAggUnaryOperation {
+
+	template <class STATE>
+	static void Initialize(STATE &state) {
+		state.is_set = false;
+	}
+
+	template <class STATE, class OP>
+	static void Combine(const STATE &source, STATE &target, AggregateInputData &) {
+		if (!source.is_set) {
+			return;
+		}
+		if (!target.is_set) {
+			target = source;
+			return;
+		}
+		target.datasets.insert(target.datasets.end(), source.datasets.begin(), source.datasets.end());
+	}
+
+	template <class INPUT_TYPE, class STATE, class OP>
+	static void Operation(STATE &state, const INPUT_TYPE &input, AggregateUnaryInput &) {
+		GDALDataset *dataset = reinterpret_cast<GDALDataset *>(input);
+		state.is_set = true;
+		state.datasets.emplace_back(dataset);
+	}
+
+	template <class INPUT_TYPE, class STATE, class OP>
+	static void ConstantOperation(STATE &state, const INPUT_TYPE &input, AggregateUnaryInput &agg, idx_t) {
+		Operation<INPUT_TYPE, STATE, OP>(state, input, agg);
+	}
+
+	static bool IgnoreNull() {
+		return true;
+	}
+};
+
+struct RasterAggBinaryOperation {
+
+	template <class STATE>
+	static void Initialize(STATE &state) {
+		state.is_set = false;
+	}
+
+	template <class STATE, class OP>
+	static void Combine(const STATE &source, STATE &target, AggregateInputData &) {
+		if (!source.is_set) {
+			return;
+		}
+		if (!target.is_set) {
+			target = source;
+			return;
+		}
+		target.datasets.insert(target.datasets.end(), source.datasets.begin(), source.datasets.end());
+	}
+
+	template <class INPUT_TYPE, class OPTS_TYPE, class STATE, class OP>
+	static void Operation(STATE &state, const INPUT_TYPE &input, const OPTS_TYPE &opts, AggregateBinaryInput &) {
+		GDALDataset *dataset = reinterpret_cast<GDALDataset *>(input);
+		state.is_set = true;
+		state.datasets.emplace_back(dataset);
+	}
+
+	template <class INPUT_TYPE, class OPTS_TYPE, class STATE, class OP>
+	static void ConstantOperation(STATE &state, const INPUT_TYPE &input, const OPTS_TYPE &opts,
+	                              AggregateBinaryInput &agg, idx_t) {
+		Operation<INPUT_TYPE, OPTS_TYPE, STATE, OP>(state, input, opts, agg);
+	}
+
+	static bool IgnoreNull() {
+		return true;
+	}
+};
+
+struct RasterAggBindData : public FunctionData {
+	//! The client context for the function call
+	ClientContext &context;
+	//! The list of options for the function
+	std::vector<std::string> options;
+
+	explicit RasterAggBindData(ClientContext &context, std::vector<std::string> options)
+	    : context(context), options(options) {
+	}
+
+	unique_ptr<FunctionData> Copy() const override {
+		return make_uniq<RasterAggBindData>(context, options);
+	}
+
+	bool Equals(const FunctionData &other_p) const override {
+		auto &other = other_p.Cast<RasterAggBindData>();
+		return options == other.options;
+	}
+};
+
+unique_ptr<FunctionData> BindRasterAggOperation(ClientContext &context, AggregateFunction &function,
+                                                vector<unique_ptr<Expression>> &arguments);
+
+} // namespace gdal
+
+} // namespace spatial

spatial/include/spatial/gdal/functions/scalar.hpp

@@ -0,0 +1,84 @@
+#pragma once
+#include "spatial/common.hpp"
+
+namespace spatial {
+
+namespace gdal {
+
+struct GdalScalarFunctions {
+public:
+	static void Register(DatabaseInstance &db) {
+		RegisterStGetSRID(db);
+		RegisterStGetGeometry(db);
+		RegisterStGetMetadata(db);
+		RegisterStGetHasNoBand(db);
+		RegisterStBandPixelType(db);
+		RegisterStBandPixelTypeName(db);
+		RegisterStBandNoDataValue(db);
+		RegisterStBandColorInterp(db);
+		RegisterStBandColorInterpName(db);
+		RegisterStRasterToWorldCoord(db);
+		RegisterStWorldToRasterCoord(db);
+		RegisterStGetValue(db);
+		RegisterStRasterFromFile(db);
+		RegisterStRasterAsFile(db);
+		RegisterStRasterWarp(db);
+		RegisterStRasterClip(db);
+	}
+
+private:
+	// ST_SRID
+	static void RegisterStGetSRID(DatabaseInstance &db);
+
+	// ST_GetGeometry
+	static void RegisterStGetGeometry(DatabaseInstance &db);
+
+	// Raster Accessors:
+	// ST_Width, ST_Height, ST_NumBands,
+	// ST_UpperLeftX, ST_UpperLeftY, ST_ScaleX, ST_ScaleY, ST_SkewX, ST_SkewY,
+	// ST_PixelWidth, ST_PixelHeight
+	static void RegisterStGetMetadata(DatabaseInstance &db);
+
+	// ST_HasNoBand
+	static void RegisterStGetHasNoBand(DatabaseInstance &db);
+
+	// ST_GetBandPixelType
+	static void RegisterStBandPixelType(DatabaseInstance &db);
+
+	// ST_GetBandPixelTypeName
+	static void RegisterStBandPixelTypeName(DatabaseInstance &db);
+
+	// ST_GetBandNoDataValue
+	static void RegisterStBandNoDataValue(DatabaseInstance &db);
+
+	// ST_GetBandColorInterp
+	static void RegisterStBandColorInterp(DatabaseInstance &db);
+
+	// ST_GetBandColorInterpName
+	static void RegisterStBandColorInterpName(DatabaseInstance &db);
+
+	// ST_RasterToWorldCoord[XY]
+	static void RegisterStRasterToWorldCoord(DatabaseInstance &db);
+
+	// ST_WorldToRasterCoord[XY]
+	static void RegisterStWorldToRasterCoord(DatabaseInstance &db);
+
+	// ST_Value
+	static void RegisterStGetValue(DatabaseInstance &db);
+
+	// ST_RasterFromFile
+	static void RegisterStRasterFromFile(DatabaseInstance &db);
+
+	// ST_RasterAsFile
+	static void RegisterStRasterAsFile(DatabaseInstance &db);
+
+	// ST_RasterWarp
+	static void RegisterStRasterWarp(DatabaseInstance &db);
+
+	// ST_RasterClip
+	static void RegisterStRasterClip(DatabaseInstance &db);
+};
+
+} // namespace gdal
+
+} // namespace spatial