hare-orm 0.9.0__py3-none-any.whl

hare/dialects/sqlite/search/terms/full_text_row_value.py

@@ -0,0 +1,104 @@
+from __future__ import annotations
+
+from collections.abc import Iterator
+from typing import TYPE_CHECKING
+
+from hare.sql.builder_methods import BuilderMethods
+from hare.sql.sql_context import SqlContext
+from hare.sql.terms.node import TNode
+from hare.sql.terms.term import Term
+
+if TYPE_CHECKING:
+    from typing import Self
+
+    from hare.sql.builder.tables.table import Table
+
+
+class FullTextRowValue(Term):
+    """What an FTS5 auxiliary function (``bm25()``, ``highlight()``, ``snippet()``) gives for the
+    row the query reads - a subquery of the full-text index matching the query for that row. A
+    subclass writes the function.
+
+    Args:
+        row_key: The column of the row's integer primary key, which keys the index's rows.
+        index_table_name: The FTS5 table.
+        index_schema: The FTS5 table's attached database; None for the main one.
+        query: The search query.
+    """
+
+    is_subquery = True
+
+    def __init__(
+        self,
+        row_key: Term,
+        index_table_name: str,
+        query: Term,
+        index_schema: str | None = None,
+        alias: str | None = None,
+    ) -> None:
+        super().__init__(alias)
+        self.row_key = row_key
+        self.index_table_name = index_table_name
+        self.index_schema = index_schema
+        self.query = query
+
+    @property
+    def outer_reference_terms(self) -> tuple[Term, ...]:  # type: ignore[override]
+        return (self.row_key,)
+
+    def get_value_terms(self) -> tuple[Term, ...]:
+        """The terms the function reads.
+
+        Returns:
+            The terms - none by default.
+        """
+        return ()
+
+    def nodes_(self) -> Iterator[TNode]:
+        yield self  # type:ignore[misc]
+        yield from self.row_key.nodes_()
+        yield from self.query.nodes_()
+        for value_term in self.get_value_terms():
+            yield from value_term.nodes_()
+
+    @BuilderMethods.builder
+    def replace_table(self, current_table: Table | None, new_table: Table | None) -> Self:
+        """Replaces the table of the row's key column.
+
+        Args:
+            current_table: The table to be replaced.
+            new_table: The table to replace with.
+
+        Returns:
+            A copy with the table replaced.
+        """
+        self.row_key = self.row_key.replace_table(current_table, new_table)
+        return self
+
+    def get_function_sql(self, sql_context: SqlContext, index_table_sql: str) -> str:
+        """Returns the auxiliary function's call.
+
+        Args:
+            sql_context: The context.
+            index_table_sql: The quoted FTS5 table.
+
+        Returns:
+            The SQL.
+        """
+        raise NotImplementedError
+
+    def get_sql(self, sql_context: SqlContext) -> str:
+        inner_context = sql_context.copy(with_alias=False)
+        index_table_sql = sql_context.quote(self.index_table_name)
+        qualified_index_table_sql = (
+            f"{sql_context.quote(self.index_schema)}.{index_table_sql}" if self.index_schema else index_table_sql
+        )
+        function_sql = self.get_function_sql(inner_context, index_table_sql)
+        query_sql = self.query.get_sql(inner_context)
+        row_key_sql = self.row_key.get_sql(inner_context.copy(with_namespace=True))
+        sql = (
+            f"(SELECT {function_sql} FROM {qualified_index_table_sql} "  # nosec B608
+            f"WHERE {index_table_sql} MATCH {query_sql} "
+            f"AND {index_table_sql}.rowid = {row_key_sql})"
+        )
+        return sql_context.format_alias_sql(sql, self.alias) if sql_context.with_alias else sql

hare/dialects/sqlite/server_versions.py

@@ -0,0 +1,17 @@
+from __future__ import annotations
+
+#: The oldest SQLite library hare runs on - ``RETURNING`` and ``ALTER TABLE ... DROP COLUMN`` first
+#: appeared in 3.35.0; 3.35.5, the last 3.35, is the first without its known faults: ``ALTER TABLE ... RENAME
+#: COLUMN`` rewriting the generated columns of other tables (fixed in 3.35.2), a correlated ``EXISTS``
+#: filtering the wrong rows (fixed by 3.35.4), ``ALTER TABLE ... DROP COLUMN`` corrupting the database file
+#: (fixed in 3.35.5).
+SQLITE_MINIMUM_SERVER_VERSION = (3, 35, 5)
+#: The first SQLite version with ``unhex()``.
+SQLITE_UNHEX_SERVER_VERSION = (3, 41, 0)
+#: The first SQLite version with ``STRICT`` tables.
+SQLITE_STRICT_SERVER_VERSION = (3, 37, 0)
+#: The first SQLite version with ``ORDER BY`` inside an aggregate's arguments.
+SQLITE_ORDERED_AGGREGATES_SERVER_VERSION = (3, 44, 0)
+
+#: The deepest expression the SQLite library parses (its SQLITE_MAX_EXPR_DEPTH).
+SQLITE_MAX_EXPRESSION_DEPTH = 1000

hare/dialects/sqlite/spatial/constants.py

@@ -0,0 +1,173 @@
+from __future__ import annotations
+
+from hare.dialects.sqlite.enums import SpatialiteMetadata
+from hare.gis.enums import GeometryType, SpatialFunctionType, SpatialRelation
+
+#: Points SpatiaLite's PROJ at a ``proj.db``.
+SQLITE_SPATIAL_PROJ_DATABASE_SQL = "SELECT PROJ_SetDatabasePath(?)"
+
+#: Whether the database has SpatiaLite's spatial metadata - 0 when it has none.
+SQLITE_SPATIAL_METADATA_CHECK_SQL = "SELECT CheckSpatialMetaData()"
+
+#: Creates SpatiaLite's spatial metadata, in one transaction - of each type hare creates.
+SQLITE_SPATIAL_METADATA_CREATE_SQLS = {
+    SpatialiteMetadata.WGS84: "SELECT InitSpatialMetadata(1, 'WGS84_ONLY')",
+    SpatialiteMetadata.FULL: "SELECT InitSpatialMetadata(1)",
+}
+
+#: The SRIDs of the reference systems the spatial metadata has.
+SQLITE_SPATIAL_REFERENCE_IDS_SQL = "SELECT srid FROM spatial_ref_sys"
+
+#: The rows a spatial relation can hold for, by the bounding boxes in a column's spatial index:
+#: ``{row_key}`` among the R*Tree's rows whose box meets ``{frame}``.
+SPATIALITE_INDEX_PREFILTER_SQL = (
+    "{row_key} IN (SELECT ROWID FROM SpatialIndex WHERE f_table_name = {table} "
+    "AND f_geometry_column = {column} AND search_frame = {frame})"
+)
+
+#: A geometry's bounding box grown by a distance on every side - the frame of ``dwithin``.
+SPATIALITE_EXPANDED_FRAME_SQL = "ST_Expand({geometry}, {distance})"
+
+#: The relations no row outside the other geometry's bounding box can hold - those a spatial index
+#: narrows the rows of; ``dwithin`` through the box grown by its distance.
+SPATIALITE_INDEXED_RELATIONS = frozenset(
+    {
+        SpatialRelation.INTERSECTS,
+        SpatialRelation.CONTAINS,
+        SpatialRelation.CONTAINS_PROPERLY,
+        SpatialRelation.WITHIN,
+        SpatialRelation.COVERS,
+        SpatialRelation.COVERED_BY,
+        SpatialRelation.CROSSES,
+        SpatialRelation.EQUALS,
+        SpatialRelation.OVERLAPS,
+        SpatialRelation.TOUCHES,
+        SpatialRelation.BBOX_OVERLAPS,
+        SpatialRelation.BBOX_CONTAINS,
+        SpatialRelation.BBOX_CONTAINED,
+        SpatialRelation.DWITHIN,
+    }
+)
+
+#: The parts of SpatiaLite's geometry BLOB: its first byte, the byte orders, the byte ending the
+#: bounding box, the byte before each member of a collection, and its last byte.
+SPATIALITE_BLOB_START = 0x00
+
+SPATIALITE_BLOB_BIG_ENDIAN = 0x00
+
+SPATIALITE_BLOB_LITTLE_ENDIAN = 0x01
+
+SPATIALITE_BLOB_MBR_END = 0x7C
+
+SPATIALITE_BLOB_ENTITY = 0x69
+
+SPATIALITE_BLOB_END = 0xFE
+
+#: The offset of the byte ending the bounding box, and the size of the shortest BLOB.
+SPATIALITE_BLOB_MBR_END_OFFSET = 38
+
+SPATIALITE_BLOB_MIN_SIZE = 44
+
+#: SpatiaLite adds these to a class code for a z coordinate, an m one (3000 for both), and a compressed
+#: geometry.
+SPATIALITE_Z_CLASS_OFFSET = 1000
+
+SPATIALITE_M_CLASS_OFFSET = 2000
+
+SPATIALITE_COMPRESSED_CLASS_OFFSET = 1000000
+
+#: The column type of each geometry type - a z column adds ``Z``.
+SPATIALITE_COLUMN_TYPES = {
+    GeometryType.GEOMETRY: "GEOMETRY",
+    GeometryType.POINT: "POINT",
+    GeometryType.LINESTRING: "LINESTRING",
+    GeometryType.POLYGON: "POLYGON",
+    GeometryType.MULTIPOINT: "MULTIPOINT",
+    GeometryType.MULTILINESTRING: "MULTILINESTRING",
+    GeometryType.MULTIPOLYGON: "MULTIPOLYGON",
+    GeometryType.GEOMETRYCOLLECTION: "GEOMETRYCOLLECTION",
+}
+
+#: The SpatiaLite function testing each spatial relation - ``contains_properly`` is a DE-9IM pattern,
+#: SpatiaLite having no function of its own for it.
+SPATIALITE_RELATION_FUNCTIONS = {
+    SpatialRelation.INTERSECTS: "ST_Intersects",
+    SpatialRelation.CONTAINS: "ST_Contains",
+    SpatialRelation.WITHIN: "ST_Within",
+    SpatialRelation.COVERS: "ST_Covers",
+    SpatialRelation.COVERED_BY: "ST_CoveredBy",
+    SpatialRelation.CROSSES: "ST_Crosses",
+    SpatialRelation.DISJOINT: "ST_Disjoint",
+    SpatialRelation.EQUALS: "ST_Equals",
+    SpatialRelation.OVERLAPS: "ST_Overlaps",
+    SpatialRelation.TOUCHES: "ST_Touches",
+    SpatialRelation.RELATE: "ST_Relate",
+    SpatialRelation.BBOX_OVERLAPS: "MbrIntersects",
+    SpatialRelation.BBOX_CONTAINS: "MbrContains",
+    SpatialRelation.BBOX_CONTAINED: "MbrWithin",
+}
+
+#: The DE-9IM pattern of ``contains_properly``.
+SPATIALITE_CONTAINS_PROPERLY_PATTERN = "T**FF*FF*"
+
+#: The SpatiaLite function of each spatial function.
+SPATIALITE_FUNCTIONS = {
+    SpatialFunctionType.AREA: "ST_Area",
+    SpatialFunctionType.LENGTH: "ST_Length",
+    SpatialFunctionType.PERIMETER: "ST_Perimeter",
+    SpatialFunctionType.DISTANCE: "ST_Distance",
+    SpatialFunctionType.CENTROID: "ST_Centroid",
+    SpatialFunctionType.ENVELOPE: "ST_Envelope",
+    SpatialFunctionType.POINT_ON_SURFACE: "ST_PointOnSurface",
+    SpatialFunctionType.BOUNDARY: "ST_Boundary",
+    SpatialFunctionType.CONVEX_HULL: "ST_ConvexHull",
+    SpatialFunctionType.BUFFER: "ST_Buffer",
+    SpatialFunctionType.INTERSECTION: "ST_Intersection",
+    SpatialFunctionType.DIFFERENCE: "ST_Difference",
+    SpatialFunctionType.SYMMETRIC_DIFFERENCE: "ST_SymDifference",
+    SpatialFunctionType.UNION: "ST_Union",
+    SpatialFunctionType.TRANSFORM: "ST_Transform",
+    SpatialFunctionType.SIMPLIFY: "ST_Simplify",
+    SpatialFunctionType.MAKE_VALID: "ST_MakeValid",
+    SpatialFunctionType.IS_VALID: "ST_IsValid",
+    SpatialFunctionType.AS_TEXT: "ST_AsText",
+    SpatialFunctionType.AS_GEO_JSON: "AsGeoJSON",
+    SpatialFunctionType.NUM_POINTS: "ST_NPoints",
+    SpatialFunctionType.NUM_GEOMETRIES: "ST_NumGeometries",
+    SpatialFunctionType.GEOMETRY_TYPE_NAME: "GeometryType",
+    SpatialFunctionType.SRID: "ST_SRID",
+    SpatialFunctionType.X: "ST_X",
+    SpatialFunctionType.Y: "ST_Y",
+    SpatialFunctionType.Z: "ST_Z",
+}
+
+#: The functions SpatiaLite measures on the ellipsoid, in meters, for a geography - its last argument
+#: asks for it. Every other function SpatiaLite has no ellipsoid form of: on a geography only those
+#: reading the stored longitude/latitude as they are run.
+SPATIALITE_GEOGRAPHY_MEASURES = frozenset(
+    {
+        SpatialFunctionType.AREA,
+        SpatialFunctionType.LENGTH,
+        SpatialFunctionType.PERIMETER,
+        SpatialFunctionType.DISTANCE,
+    }
+)
+
+#: The geography functions hare computes on the spheroid that SpatiaLite has no form of.
+SPATIALITE_UNSUPPORTED_GEOGRAPHY_FUNCTIONS = frozenset(
+    {SpatialFunctionType.CENTROID, SpatialFunctionType.BUFFER, SpatialFunctionType.INTERSECTION}
+)
+
+#: The relations a geography takes on SQLite - measured on the ellipsoid.
+SPATIALITE_GEOGRAPHY_RELATIONS = frozenset({SpatialRelation.DWITHIN})
+
+#: The SpatiaLite aggregate of each spatial aggregate.
+SPATIALITE_AGGREGATES = {
+    SpatialFunctionType.COLLECT: "ST_Collect",
+    SpatialFunctionType.EXTENT: "Extent",
+    SpatialFunctionType.UNION_AGGREGATE: "ST_Union",
+    SpatialFunctionType.MAKE_LINE: "MakeLine",
+}
+
+#: The suffix SpatiaLite's ``GeometryType`` adds for a z coordinate - hare's ``GeometryType`` has none.
+SPATIALITE_GEOMETRY_TYPE_Z_SUFFIX = " Z"

hare/dialects/sqlite/spatial/spatialite_blob_reader.py

@@ -0,0 +1,166 @@
+from __future__ import annotations
+
+import struct
+
+from hare.dialects.sqlite.spatial.constants import (
+    SPATIALITE_BLOB_BIG_ENDIAN,
+    SPATIALITE_BLOB_END,
+    SPATIALITE_BLOB_ENTITY,
+    SPATIALITE_BLOB_LITTLE_ENDIAN,
+    SPATIALITE_BLOB_MBR_END,
+    SPATIALITE_BLOB_MBR_END_OFFSET,
+    SPATIALITE_BLOB_MIN_SIZE,
+    SPATIALITE_BLOB_START,
+    SPATIALITE_COMPRESSED_CLASS_OFFSET,
+    SPATIALITE_M_CLASS_OFFSET,
+    SPATIALITE_Z_CLASS_OFFSET,
+)
+from hare.exceptions import ValidationError
+from hare.gis.enums import GeometryType
+from hare.gis.geometries.geometry import Geometry
+from hare.gis.geometries.geometry_collection import GeometryCollection
+from hare.gis.geometries.line_string import LineString
+from hare.gis.geometries.point import Point
+from hare.gis.geometries.polygon import Polygon
+from hare.gis.readers.constants import COLLECTION_CLASSES, GEOMETRY_TYPES_BY_CODE
+
+
+class SpatialiteBlobReader:
+    """Reads a geometry from SpatiaLite's own BLOB - the header with the byte order, the SRID and the
+    bounding box, then the geometry class and its coordinates; a compressed line or ring keeps its
+    inner positions as float offsets from the position before. Measured (m) coordinates are refused.
+
+    Args:
+        data: The bytes.
+    """
+
+    def __init__(self, data: bytes) -> None:
+        self.data = data
+        self.offset = 0
+        self.byte_order = "<"
+
+    @classmethod
+    def read(cls, data: bytes | bytearray | memoryview) -> Geometry:
+        """The geometry of a SpatiaLite BLOB.
+
+        Args:
+            data: The bytes.
+
+        Returns:
+            The geometry.
+
+        Raises:
+            ValidationError: ``data`` isn't a whole SpatiaLite geometry.
+        """
+        try:
+            return cls(bytes(data)).read_blob()
+        except (ValueError, struct.error, IndexError) as error:
+            raise ValidationError(f"Not a SpatiaLite geometry: {error}") from None
+
+    def read_blob(self) -> Geometry:
+        """Reads the whole BLOB.
+
+        Raises:
+            ValueError: The bytes aren't a SpatiaLite geometry hare reads.
+        """
+        data = self.data
+        if (
+            len(data) < SPATIALITE_BLOB_MIN_SIZE
+            or data[0] != SPATIALITE_BLOB_START
+            or data[SPATIALITE_BLOB_MBR_END_OFFSET] != SPATIALITE_BLOB_MBR_END
+            or data[-1] != SPATIALITE_BLOB_END
+        ):
+            raise ValueError("no SpatiaLite header and end")
+        if data[1] not in {SPATIALITE_BLOB_LITTLE_ENDIAN, SPATIALITE_BLOB_BIG_ENDIAN}:
+            raise ValueError(f"unknown byte order {data[1]}")
+        self.byte_order = "<" if data[1] == SPATIALITE_BLOB_LITTLE_ENDIAN else ">"
+        self.offset = 2
+        (srid,) = self.read_struct("i")
+        self.offset = SPATIALITE_BLOB_MBR_END_OFFSET + 1
+        (class_code,) = self.read_struct("I")
+        geometry = self.read_body(int(class_code), Geometry.get_validated_srid(int(srid)))
+        if self.offset != len(data) - 1:
+            raise ValueError(f"{len(data) - 1 - self.offset} byte(s) after the geometry")
+        return geometry
+
+    def read_struct(self, format_text: str) -> tuple[float | int, ...]:
+        """Reads values at the current offset and moves past them.
+
+        Args:
+            format_text: The ``struct`` format of the values.
+
+        Returns:
+            The values.
+        """
+        values_format = struct.Struct(self.byte_order + format_text)
+        values = values_format.unpack_from(self.data, self.offset)
+        self.offset += values_format.size
+        return values
+
+    def read_body(self, class_code: int, srid: int | None) -> Geometry:
+        """Reads the geometry of a class code at the current offset.
+
+        Args:
+            class_code: The class code.
+            srid: The SRID of the BLOB.
+
+        Returns:
+            The geometry.
+
+        Raises:
+            ValueError: The class is unknown or has measured coordinates.
+        """
+        compressed = class_code > SPATIALITE_COMPRESSED_CLASS_OFFSET
+        if compressed:
+            class_code -= SPATIALITE_COMPRESSED_CLASS_OFFSET
+        # An m class (2001...) and a z and m one (3001...) are both past the m offset.
+        if class_code > SPATIALITE_M_CLASS_OFFSET:
+            raise ValueError("measured (M) coordinates are not supported")
+        has_z = class_code > SPATIALITE_Z_CLASS_OFFSET
+        if has_z:
+            class_code -= SPATIALITE_Z_CLASS_OFFSET
+        geometry_type = GEOMETRY_TYPES_BY_CODE.get(class_code)
+        if geometry_type is None:
+            raise ValueError(f"unknown geometry class {class_code}")
+        dimensions = 3 if has_z else 2
+        if geometry_type == GeometryType.POINT:
+            return Point(*self.read_struct("d" * dimensions), srid=srid)
+        if geometry_type == GeometryType.LINESTRING:
+            return LineString(self.read_positions(dimensions, compressed), srid=srid)
+        if geometry_type == GeometryType.POLYGON:
+            (ring_count,) = self.read_struct("I")
+            rings = [self.read_positions(dimensions, compressed) for _ring_index in range(int(ring_count))]
+            return Polygon.from_coordinates(rings, srid=srid)
+        (member_count,) = self.read_struct("I")
+        members = []
+        for _member_index in range(int(member_count)):
+            if self.data[self.offset] != SPATIALITE_BLOB_ENTITY:
+                raise ValueError("a collection member without its marker")
+            self.offset += 1
+            (member_class_code,) = self.read_struct("I")
+            members.append(self.read_body(int(member_class_code), srid))
+        collection_class = COLLECTION_CLASSES.get(geometry_type, GeometryCollection)
+        return collection_class(members, srid=srid)
+
+    def read_positions(self, dimensions: int, compressed: bool) -> list[tuple[float, ...]]:
+        """Reads a count, then that many positions - of a compressed geometry the first and the last
+        in full, every other as float offsets from the one before.
+
+        Args:
+            dimensions: The coordinates of a position.
+            compressed: Whether the geometry is compressed.
+
+        Returns:
+            The positions.
+        """
+        (position_count,) = self.read_struct("I")
+        last_index = int(position_count) - 1
+        positions: list[tuple[float, ...]] = []
+        for position_index in range(int(position_count)):
+            if not compressed or position_index in (0, last_index):
+                positions.append(tuple(float(number) for number in self.read_struct("d" * dimensions)))
+                continue
+            offsets = self.read_struct("f" * dimensions)
+            previous = positions[-1]
+            positions.append(tuple(previous[axis] + float(offsets[axis]) for axis in range(dimensions)))
+        return positions

hare/dialects/sqlite/spatial/spatialite_blob_writer.py

@@ -0,0 +1,105 @@
+from __future__ import annotations
+
+import struct
+from typing import Any
+
+from hare.dialects.sqlite.spatial.constants import (
+    SPATIALITE_BLOB_END,
+    SPATIALITE_BLOB_ENTITY,
+    SPATIALITE_BLOB_LITTLE_ENDIAN,
+    SPATIALITE_BLOB_MBR_END,
+    SPATIALITE_BLOB_START,
+    SPATIALITE_Z_CLASS_OFFSET,
+)
+from hare.exceptions import ValidationError
+from hare.gis.constants import WKB_TYPE_CODES
+from hare.gis.enums import GeometryType
+from hare.gis.fields.extent_field import ExtentField
+from hare.gis.geometries.geometry import Geometry
+
+
+class SpatialiteBlobWriter:
+    """Writes a geometry as SpatiaLite's own BLOB, little-endian and uncompressed - the bytes
+    SpatiaLite's own ``GeomFromEWKT()`` makes of the geometry. SpatiaLite has no empty geometry."""
+
+    #: The header - the first byte, the byte order, the SRID, the bounding box and its end.
+    HEADER = struct.Struct("<BBi4dB")
+
+    @classmethod
+    def write(cls, geometry: Geometry) -> bytes:
+        """The BLOB of a geometry.
+
+        Args:
+            geometry: The geometry, with an SRID.
+
+        Returns:
+            The bytes.
+
+        Raises:
+            ValidationError: The geometry is empty or has an empty member.
+        """
+        cls.raise_if_empty(geometry)
+        positions = ExtentField.get_positions(geometry.get_coordinates())
+        header = cls.HEADER.pack(
+            SPATIALITE_BLOB_START,
+            SPATIALITE_BLOB_LITTLE_ENDIAN,
+            geometry.srid or 0,
+            min(position[0] for position in positions),
+            min(position[1] for position in positions),
+            max(position[0] for position in positions),
+            max(position[1] for position in positions),
+            SPATIALITE_BLOB_MBR_END,
+        )
+        return header + cls.get_body(geometry) + bytes((SPATIALITE_BLOB_END,))
+
+    @classmethod
+    def raise_if_empty(cls, geometry: Geometry) -> None:
+        """Rejects an empty geometry, or a collection with an empty member.
+
+        Args:
+            geometry: The geometry.
+
+        Raises:
+            ValidationError: It is empty or has an empty member.
+        """
+        if geometry.is_empty:
+            raise ValidationError(f"SpatiaLite stores no empty geometry, got {geometry.ewkt}")
+        for member in getattr(geometry, "members", ()):
+            cls.raise_if_empty(member)
+
+    @classmethod
+    def get_body(cls, geometry: Geometry) -> bytes:
+        """A geometry's class code and coordinates.
+
+        Args:
+            geometry: The geometry.
+
+        Returns:
+            The bytes.
+        """
+        class_code = WKB_TYPE_CODES[geometry.GEOMETRY_TYPE] + (SPATIALITE_Z_CLASS_OFFSET if geometry.has_z else 0)
+        body = struct.pack("<I", class_code)
+        geometry_type = geometry.GEOMETRY_TYPE
+        if geometry_type == GeometryType.POINT:
+            return body + cls.get_position_bytes(geometry.get_coordinates())
+        if geometry_type == GeometryType.LINESTRING:
+            return body + cls.get_positions_bytes(geometry.get_coordinates())
+        if geometry_type == GeometryType.POLYGON:
+            rings = geometry.get_coordinates()
+            return body + struct.pack("<I", len(rings)) + b"".join(cls.get_positions_bytes(ring) for ring in rings)
+        members = geometry.members  # type: ignore[attr-defined]
+        return (
+            body
+            + struct.pack("<I", len(members))
+            + b"".join(bytes((SPATIALITE_BLOB_ENTITY,)) + cls.get_body(member) for member in members)
+        )
+
+    @staticmethod
+    def get_position_bytes(position: Any) -> bytes:
+        """The coordinates of one position as doubles."""
+        return struct.pack(f"<{len(position)}d", *position)
+
+    @classmethod
+    def get_positions_bytes(cls, positions: Any) -> bytes:
+        """A count, then the positions."""
+        return struct.pack("<I", len(positions)) + b"".join(cls.get_position_bytes(position) for position in positions)

hare/dialects/sqlite/spatial/sqlite_geometry_values.py

@@ -0,0 +1,75 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Any, cast
+
+from hare.dialects.sqlite.spatial.constants import SPATIALITE_COLUMN_TYPES
+from hare.dialects.sqlite.spatial.spatialite_blob_reader import SpatialiteBlobReader
+from hare.dialects.sqlite.spatial.spatialite_blob_writer import SpatialiteBlobWriter
+
+if TYPE_CHECKING:
+    from hare.fields.field import Field
+    from hare.gis.fields.geometry_field import GeometryField
+    from hare.models import Model
+
+
+class SqliteGeometryValues:
+    """How SQLite stores a ``GeometryField`` - SpatiaLite's own BLOB, written and read by hare itself,
+    so a geometry is stored and compared without the SpatiaLite extension; only the spatial lookups,
+    functions and aggregates need it."""
+
+    @staticmethod
+    def get_column_type(field: Field[Any]) -> str:
+        """The column type - the geometry type's name, with ``Z`` for x/y/z (``POINTZ``).
+
+        Args:
+            field: The geometry field.
+
+        Returns:
+            The column type.
+        """
+        geometry_field = cast("GeometryField", field)
+        column_type = SPATIALITE_COLUMN_TYPES[geometry_field.get_geometry_type()]
+        return f"{column_type}Z" if geometry_field.dimensions == 3 else column_type
+
+    @staticmethod
+    def to_db(field: Field[Any], value: Any, instance: type[Model] | Model) -> bytes | None:
+        """The BLOB of a written geometry - of the field's type, dimensions and SRID.
+
+        Raises:
+            ValidationError: The value isn't such a geometry, or is empty.
+        """
+        geometry_field = cast("GeometryField", field)
+        geometry_field.validate(value)
+        if value is None:
+            return None
+        geometry = geometry_field.get_checked_geometry(geometry_field.get_parsed_geometry(value))
+        return SpatialiteBlobWriter.write(geometry)
+
+    @staticmethod
+    def to_lookup(field: Field[Any], value: Any, instance: type[Model] | Model) -> bytes | None:
+        """The BLOB an equality compares the column with - in the column's SRID: a BLOB of another one
+        would equal no row.
+
+        Raises:
+            ValidationError: The value isn't a geometry, is empty, or has another SRID than the column.
+        """
+        if value is None:
+            return None
+        geometry_field = cast("GeometryField", field)
+        geometry = geometry_field.get_parsed_geometry(value)
+        geometry_field.raise_if_other_srid(geometry)
+        return SpatialiteBlobWriter.write(geometry)
+
+    @staticmethod
+    def to_python(field: Field[Any], value: Any) -> Any:
+        """The geometry of a read BLOB."""
+        if isinstance(value, (bytes, bytearray, memoryview)):
+            return SpatialiteBlobReader.read(value)
+        return field.to_python(value)
+
+    @staticmethod
+    def to_python_extent(field: Field[Any], value: Any) -> Any:
+        """The bounding box of ``Extent`` - SpatiaLite gives the box's polygon."""
+        if isinstance(value, (bytes, bytearray, memoryview)):
+            value = SpatialiteBlobReader.read(value)
+        return field.to_python(value)