GEOMETRY Rework: Part 1 - Logical Type (duckdb#19136)

This PR adds a dedicated `GEOMETRY` logical type into core DuckDB. The
internal representation is currently
[WKB-encoded](https://libgeos.org/specifications/wkb/) `BLOB`, but that
will likely change in a future PR. No functions are implemented for this
type, except to/from `VARCHAR` casts.

This is the first PR in a long series of changes thats going to be
pushed the coming weeks, with the ultimate goal of significantly
elevating DuckDBs geospatial capabilities for the DuckDB v1.5 release in
early 2026.

### Background

So far DuckDB has (mostly) contained all geospatial features in the
`spatial` extension. This has worked great as it has allowed us to
independently and rapidly experiment with how to adapt geospatial
processing to DuckDBs engine, while also keeping a lot of the
domain-specific details and dependencies separate from core DuckDBs core
codebase. Besides integrating a lot of third-party geospatial libraries,
`spatial` has also been integrating deeply into DuckDBs core execution
engine and made itself dependent on a lot of fragile interfaces within
DuckDBs internals (custom operators, optimizer rules, indexes, etc).
Fast forward to today, and `spatial` is one of DuckDBs largest and most
complex extensions.

While this complexity has been somewhat manageable so far, we're now
reaching a point where it's no longer feasible to relegate all
geospatial related stuff into a single separate extension. There's
already some awkwardness when dealing with e.g. Pandas/Postgres/SQLite
through DuckDB, which have their own geospatial extensions (GeoPandas,
PostGIS, GeoPackage/SpatiaLite) as core DuckDB doesn't really want to
acknowledge anything spatial specific and we don't want to introduce
inter-extension dependencies either. But geospatial support is now also
part of the parquet standard itself, which is of much higher importance
to DuckDB, as well as supported by all up and coming data lake formats.

In short: [Geospatial data Isn't special
(anymore)](https://forrest.nyc/why-cloud-native-geospatial-data-is-making-spatial-just-data-again/)

### What's changing

Therefore we're taking some steps to making vanilla DuckDB spatial
aware, by moving the `GEOMETRY` type from `spatial` into core DuckDB.

While almost all of the geospatial functionality will still remain in
`spatial` (e.g. 99% of `ST_` functions), this will give our (and
community!) extensions and client libraries some common ground as they
can all interface with the same `GEOMETRY` type. We will also make sure
that existing databases that use the `GEOMETRY` type as currently
defined in `spatial` will remain compatible.

Additionally, because `GEOMETRY` will now become part of both DuckDBs
execution and storage engine, this opens up a lot of optimization
opportunities that are currently impractical/impossible to implement
solely in `spatial`. The two big ones being __statistics propagation__
and __compression__, which will significantly improve performance of
processing both external formats like (Geo)Parquet and DuckDBs own
storage format.

Again, this is a pretty massive change. I have prototyped most of it on
my own fork(s), but will break it up into multiple PR's keep it
manageable. The rough short-term roadmap looks something like this:

- [x] Add the `GEOMETRY` to core
- [x] Add geometry statistics support (Implemented in duckdb#19203)
- [ ] Add geometry filter pushdown (using the statistics!)
- [ ] Fixup `parquet` extension
- [ ] Fixup `spatial` extension
- [ ] Dedicated geometry storage/compression
- [ ] Type-level CRS tracking/management
- [ ] Maybe `GEOGRAPHY`/"vectorized types" too

Client/other extension integrations etc, etc, is planned to get in
before 1.5 as well, but we will first focus on core/parquet/spatial.

This PR also removes spatial from the CI workflow until I've had time
adapt it to these changes, but that will hopefully not take too long (I
have an old branch with most of the work already)

Author: hannes

.github/config/out_of_tree_extensions.cmake

@@ -27,7 +27,7 @@ include("${EXTENSION_CONFIG_BASE_DIR}/iceberg.cmake")
 include("${EXTENSION_CONFIG_BASE_DIR}/inet.cmake")
 include("${EXTENSION_CONFIG_BASE_DIR}/mysql_scanner.cmake")
 include("${EXTENSION_CONFIG_BASE_DIR}/postgres_scanner.cmake")
-include("${EXTENSION_CONFIG_BASE_DIR}/spatial.cmake")
+# include("${EXTENSION_CONFIG_BASE_DIR}/spatial.cmake") Remove spatial until the geometry refactor is done
 include("${EXTENSION_CONFIG_BASE_DIR}/sqlite_scanner.cmake")
 include("${EXTENSION_CONFIG_BASE_DIR}/sqlsmith.cmake")
 include("${EXTENSION_CONFIG_BASE_DIR}/vss.cmake")

src/common/enum_util.cpp

@@ -89,6 +89,7 @@
 #include "duckdb/common/types/column/partitioned_column_data.hpp"
 #include "duckdb/common/types/conflict_manager.hpp"
 #include "duckdb/common/types/date.hpp"
+#include "duckdb/common/types/geometry.hpp"
 #include "duckdb/common/types/hyperloglog.hpp"
 #include "duckdb/common/types/row/block_iterator.hpp"
 #include "duckdb/common/types/row/partitioned_tuple_data.hpp"
@@ -1795,19 +1796,20 @@ const StringUtil::EnumStringLiteral *GetExtraTypeInfoTypeValues() {
 		{ static_cast<uint32_t>(ExtraTypeInfoType::ARRAY_TYPE_INFO), "ARRAY_TYPE_INFO" },
 		{ static_cast<uint32_t>(ExtraTypeInfoType::ANY_TYPE_INFO), "ANY_TYPE_INFO" },
 		{ static_cast<uint32_t>(ExtraTypeInfoType::INTEGER_LITERAL_TYPE_INFO), "INTEGER_LITERAL_TYPE_INFO" },
-		{ static_cast<uint32_t>(ExtraTypeInfoType::TEMPLATE_TYPE_INFO), "TEMPLATE_TYPE_INFO" }
+		{ static_cast<uint32_t>(ExtraTypeInfoType::TEMPLATE_TYPE_INFO), "TEMPLATE_TYPE_INFO" },
+		{ static_cast<uint32_t>(ExtraTypeInfoType::GEO_TYPE_INFO), "GEO_TYPE_INFO" }
 	};
 	return values;
 }
 
 template<>
 const char* EnumUtil::ToChars<ExtraTypeInfoType>(ExtraTypeInfoType value) {
-	return StringUtil::EnumToString(GetExtraTypeInfoTypeValues(), 13, "ExtraTypeInfoType", static_cast<uint32_t>(value));
+	return StringUtil::EnumToString(GetExtraTypeInfoTypeValues(), 14, "ExtraTypeInfoType", static_cast<uint32_t>(value));
 }
 
 template<>
 ExtraTypeInfoType EnumUtil::FromString<ExtraTypeInfoType>(const char *value) {
-	return static_cast<ExtraTypeInfoType>(StringUtil::StringToEnum(GetExtraTypeInfoTypeValues(), 13, "ExtraTypeInfoType", value));
+	return static_cast<ExtraTypeInfoType>(StringUtil::StringToEnum(GetExtraTypeInfoTypeValues(), 14, "ExtraTypeInfoType", value));
 }
 
 const StringUtil::EnumStringLiteral *GetFileBufferTypeValues() {
@@ -2059,6 +2061,30 @@ GateStatus EnumUtil::FromString<GateStatus>(const char *value) {
 	return static_cast<GateStatus>(StringUtil::StringToEnum(GetGateStatusValues(), 2, "GateStatus", value));
 }
 
+const StringUtil::EnumStringLiteral *GetGeometryTypeValues() {
+	static constexpr StringUtil::EnumStringLiteral values[] {
+		{ static_cast<uint32_t>(GeometryType::INVALID), "INVALID" },
+		{ static_cast<uint32_t>(GeometryType::POINT), "POINT" },
+		{ static_cast<uint32_t>(GeometryType::LINESTRING), "LINESTRING" },
+		{ static_cast<uint32_t>(GeometryType::POLYGON), "POLYGON" },
+		{ static_cast<uint32_t>(GeometryType::MULTIPOINT), "MULTIPOINT" },
+		{ static_cast<uint32_t>(GeometryType::MULTILINESTRING), "MULTILINESTRING" },
+		{ static_cast<uint32_t>(GeometryType::MULTIPOLYGON), "MULTIPOLYGON" },
+		{ static_cast<uint32_t>(GeometryType::GEOMETRYCOLLECTION), "GEOMETRYCOLLECTION" }
+	};
+	return values;
+}
+
+template<>
+const char* EnumUtil::ToChars<GeometryType>(GeometryType value) {
+	return StringUtil::EnumToString(GetGeometryTypeValues(), 8, "GeometryType", static_cast<uint32_t>(value));
+}
+
+template<>
+GeometryType EnumUtil::FromString<GeometryType>(const char *value) {
+	return static_cast<GeometryType>(StringUtil::StringToEnum(GetGeometryTypeValues(), 8, "GeometryType", value));
+}
+
 const StringUtil::EnumStringLiteral *GetHLLStorageTypeValues() {
 	static constexpr StringUtil::EnumStringLiteral values[] {
 		{ static_cast<uint32_t>(HLLStorageType::HLL_V1), "HLL_V1" },
@@ -2599,6 +2625,7 @@ const StringUtil::EnumStringLiteral *GetLogicalTypeIdValues() {
 		{ static_cast<uint32_t>(LogicalTypeId::POINTER), "POINTER" },
 		{ static_cast<uint32_t>(LogicalTypeId::VALIDITY), "VALIDITY" },
 		{ static_cast<uint32_t>(LogicalTypeId::UUID), "UUID" },
+		{ static_cast<uint32_t>(LogicalTypeId::GEOMETRY), "GEOMETRY" },
 		{ static_cast<uint32_t>(LogicalTypeId::STRUCT), "STRUCT" },
 		{ static_cast<uint32_t>(LogicalTypeId::LIST), "LIST" },
 		{ static_cast<uint32_t>(LogicalTypeId::MAP), "MAP" },
@@ -2615,12 +2642,12 @@ const StringUtil::EnumStringLiteral *GetLogicalTypeIdValues() {
 
 template<>
 const char* EnumUtil::ToChars<LogicalTypeId>(LogicalTypeId value) {
-	return StringUtil::EnumToString(GetLogicalTypeIdValues(), 50, "LogicalTypeId", static_cast<uint32_t>(value));
+	return StringUtil::EnumToString(GetLogicalTypeIdValues(), 51, "LogicalTypeId", static_cast<uint32_t>(value));
 }
 
 template<>
 LogicalTypeId EnumUtil::FromString<LogicalTypeId>(const char *value) {
-	return static_cast<LogicalTypeId>(StringUtil::StringToEnum(GetLogicalTypeIdValues(), 50, "LogicalTypeId", value));
+	return static_cast<LogicalTypeId>(StringUtil::StringToEnum(GetLogicalTypeIdValues(), 51, "LogicalTypeId", value));
 }
 
 const StringUtil::EnumStringLiteral *GetLookupResultTypeValues() {
@@ -4808,19 +4835,20 @@ const StringUtil::EnumStringLiteral *GetVariantLogicalTypeValues() {
 		{ static_cast<uint32_t>(VariantLogicalType::ARRAY), "ARRAY" },
 		{ static_cast<uint32_t>(VariantLogicalType::BIGNUM), "BIGNUM" },
 		{ static_cast<uint32_t>(VariantLogicalType::BITSTRING), "BITSTRING" },
+		{ static_cast<uint32_t>(VariantLogicalType::GEOMETRY), "GEOMETRY" },
 		{ static_cast<uint32_t>(VariantLogicalType::ENUM_SIZE), "ENUM_SIZE" }
 	};
 	return values;
 }
 
 template<>
 const char* EnumUtil::ToChars<VariantLogicalType>(VariantLogicalType value) {
-	return StringUtil::EnumToString(GetVariantLogicalTypeValues(), 34, "VariantLogicalType", static_cast<uint32_t>(value));
+	return StringUtil::EnumToString(GetVariantLogicalTypeValues(), 35, "VariantLogicalType", static_cast<uint32_t>(value));
 }
 
 template<>
 VariantLogicalType EnumUtil::FromString<VariantLogicalType>(const char *value) {
-	return static_cast<VariantLogicalType>(StringUtil::StringToEnum(GetVariantLogicalTypeValues(), 34, "VariantLogicalType", value));
+	return static_cast<VariantLogicalType>(StringUtil::StringToEnum(GetVariantLogicalTypeValues(), 35, "VariantLogicalType", value));
 }
 
 const StringUtil::EnumStringLiteral *GetVectorAuxiliaryDataTypeValues() {

src/common/extra_type_info.cpp

@@ -507,4 +507,19 @@ shared_ptr<ExtraTypeInfo> TemplateTypeInfo::Copy() const {
 	return make_shared_ptr<TemplateTypeInfo>(*this);
 }
 
+//===--------------------------------------------------------------------===//
+// Geo Type Info
+//===--------------------------------------------------------------------===//
+GeoTypeInfo::GeoTypeInfo() : ExtraTypeInfo(ExtraTypeInfoType::GEO_TYPE_INFO) {
+}
+
+bool GeoTypeInfo::EqualsInternal(ExtraTypeInfo *other_p) const {
+	// No additional info to compare
+	return true;
+}
+
+shared_ptr<ExtraTypeInfo> GeoTypeInfo::Copy() const {
+	return make_shared_ptr<GeoTypeInfo>(*this);
+}
+
 } // namespace duckdb

src/common/operator/cast_operators.cpp

@@ -19,6 +19,7 @@
 #include "duckdb/common/types/time.hpp"
 #include "duckdb/common/types/timestamp.hpp"
 #include "duckdb/common/types/vector.hpp"
+#include "duckdb/common/types/geometry.hpp"
 #include "duckdb/common/types.hpp"
 #include "fast_float/fast_float.h"
 #include "duckdb/common/types/bit.hpp"
@@ -1560,6 +1561,14 @@ bool TryCastBlobToUUID::Operation(string_t input, hugeint_t &result, bool strict
 	return true;
 }
 
+//===--------------------------------------------------------------------===//
+// Cast To Geometry
+//===--------------------------------------------------------------------===//
+template <>
+bool TryCastToGeometry::Operation(string_t input, string_t &result, Vector &result_vector, CastParameters &parameters) {
+	return Geometry::FromString(input, result, result_vector, parameters.strict);
+}
+
 //===--------------------------------------------------------------------===//
 // Cast To Date
 //===--------------------------------------------------------------------===//

src/common/types.cpp

@@ -159,6 +159,8 @@ PhysicalType LogicalType::GetInternalType() {
 		return PhysicalType::UNKNOWN;
 	case LogicalTypeId::AGGREGATE_STATE:
 		return PhysicalType::VARCHAR;
+	case LogicalTypeId::GEOMETRY:
+		return PhysicalType::VARCHAR;
 	default:
 		throw InternalException("Invalid LogicalType %s", ToString());
 	}
@@ -1344,6 +1346,8 @@ static idx_t GetLogicalTypeScore(const LogicalType &type) {
 		return 102;
 	case LogicalTypeId::BIGNUM:
 		return 103;
+	case LogicalTypeId::GEOMETRY:
+		return 104;
 	// nested types
 	case LogicalTypeId::STRUCT:
 		return 125;
@@ -2014,6 +2018,15 @@ LogicalType LogicalType::VARIANT() {
 	return LogicalType(LogicalTypeId::VARIANT, std::move(info));
 }
 
+//===--------------------------------------------------------------------===//
+// Spatial Types
+//===--------------------------------------------------------------------===//
+
+LogicalType LogicalType::GEOMETRY() {
+	auto info = make_shared_ptr<GeoTypeInfo>();
+	return LogicalType(LogicalTypeId::GEOMETRY, std::move(info));
+}
+
 //===--------------------------------------------------------------------===//
 // Logical Type
 //===--------------------------------------------------------------------===//

src/common/types/CMakeLists.txt

@@ -36,7 +36,8 @@ add_library_unity(
   vector_buffer.cpp
   vector.cpp
   vector_cache.cpp
-  vector_constants.cpp)
+  vector_constants.cpp
+  geometry.cpp)
 set(ALL_OBJECT_FILES
     ${ALL_OBJECT_FILES} $<TARGET_OBJECTS:duckdb_common_types>
     PARENT_SCOPE)