GeoAlchemy2 0.17.0__py3-none-any.whl → 0.18.0__py3-none-any.whl

geoalchemy2/_functions_helpers.py

@@ -48,8 +48,10 @@ def _generate_stubs() -> str:
 # this file is automatically generated
 from typing import List
 
+import sqlalchemy
 from sqlalchemy.sql import functions
 from sqlalchemy.sql.elements import ColumnElement
+from sqlalchemy.sql.selectable import FromClause
 
 import geoalchemy2.types
 
@@ -60,8 +62,8 @@ class TableRowElement(ColumnElement):
     """The cache is disabled for this class."""
 
     def __init__(self, selectable: bool) -> None: ...
-    @property  # type: ignore[override]
-    def _from_objects(self) -> List[bool]: ...
+    @property
+    def _from_objects(self) -> List[FromClause]: ...
 '''
     stub_file_parts = [header]
 

geoalchemy2/admin/dialects/common.py

@@ -3,9 +3,11 @@
 import sqlalchemy
 from packaging import version
 from sqlalchemy import Column
+from sqlalchemy import String
 from sqlalchemy.sql import expression
 from sqlalchemy.types import TypeDecorator
 
+from geoalchemy2.elements import WKBElement
 from geoalchemy2.types import Geometry
 
 _SQLALCHEMY_VERSION_BEFORE_14 = version.parse(sqlalchemy.__version__) < version.parse("1.4")
@@ -102,3 +104,23 @@ def before_drop(table, bind, **kw):
 
 def after_drop(table, bind, **kw):
     return  # pragma: no cover
+
+
+def compile_bin_literal(wkb_clause):
+    """Compile a binary literal for WKBElement."""
+    wkb_data = wkb_clause.value
+    if isinstance(wkb_data, bytes | memoryview | WKBElement):
+        if isinstance(wkb_data, memoryview):
+            wkb_data = wkb_data.tobytes()
+        if isinstance(wkb_data, bytes):
+            wkb_data = WKBElement._wkb_to_hex(wkb_data)
+        elif isinstance(wkb_data, WKBElement):
+            wkb_data = wkb_data.desc
+
+        wkb_clause = expression.bindparam(
+            key=wkb_clause.key,
+            value=wkb_data,
+            type_=String(),
+            unique=True,
+        )
+    return wkb_clause

geoalchemy2/admin/dialects/geopackage.py

@@ -16,6 +16,7 @@ from geoalchemy2 import functions
 from geoalchemy2.admin.dialects.common import _check_spatial_type
 from geoalchemy2.admin.dialects.common import _format_select_args
 from geoalchemy2.admin.dialects.common import _spatial_idx_name
+from geoalchemy2.admin.dialects.common import compile_bin_literal
 from geoalchemy2.admin.dialects.common import setup_create_drop
 from geoalchemy2.admin.dialects.sqlite import _SQLITE_FUNCTIONS
 from geoalchemy2.admin.dialects.sqlite import get_col_dim
@@ -383,3 +384,38 @@ def create_spatial_ref_sys_view(bind):
             FROM gpkg_spatial_ref_sys;"""
         )
     )
+
+
+def _compile_GeomFromWKB_gpkg(element, compiler, *, identifier, **kw):
+    # Store the SRID
+    clauses = list(element.clauses)
+    try:
+        srid = clauses[1].value
+    except (IndexError, TypeError, ValueError):
+        srid = element.type.srid
+
+    if kw.get("literal_binds", False):
+        wkb_clause = compile_bin_literal(clauses[0])
+        prefix = "unhex("
+        suffix = ")"
+    else:
+        wkb_clause = clauses[0]
+        prefix = ""
+        suffix = ""
+
+    compiled = compiler.process(wkb_clause, **kw)
+
+    if srid > 0:
+        return "{}({}{}{}, {})".format(identifier, prefix, compiled, suffix, srid)
+    else:
+        return "{}({}{}{})".format(identifier, prefix, compiled, suffix)
+
+
+@compiles(functions.ST_GeomFromWKB, "geopackage")  # type: ignore
+def _gpkg_ST_GeomFromWKB(element, compiler, **kw):
+    return _compile_GeomFromWKB_gpkg(element, compiler, identifier="GeomFromWKB", **kw)
+
+
+@compiles(functions.ST_GeomFromEWKB, "geopackage")  # type: ignore
+def _gpkg_ST_GeomFromEWKB(element, compiler, **kw):
+    return _compile_GeomFromWKB_gpkg(element, compiler, identifier="GeomFromEWKB", **kw)

geoalchemy2/admin/dialects/mariadb.py

@@ -3,6 +3,7 @@
 from sqlalchemy.ext.compiler import compiles
 
 from geoalchemy2 import functions
+from geoalchemy2.admin.dialects.common import compile_bin_literal
 from geoalchemy2.admin.dialects.mysql import after_create  # noqa
 from geoalchemy2.admin.dialects.mysql import after_drop  # noqa
 from geoalchemy2.admin.dialects.mysql import before_create  # noqa
@@ -10,15 +11,15 @@ from geoalchemy2.admin.dialects.mysql import before_drop  # noqa
 from geoalchemy2.admin.dialects.mysql import reflect_geometry_column  # noqa
 from geoalchemy2.elements import WKBElement
 from geoalchemy2.elements import WKTElement
-from geoalchemy2.shape import to_shape
 
 
 def _cast(param):
     if isinstance(param, memoryview):
         param = param.tobytes()
     if isinstance(param, bytes):
-        data_element = WKBElement(param)
-        param = to_shape(data_element).wkt.encode("utf-8")
+        param = WKBElement(param)
+    if isinstance(param, WKBElement):
+        param = param.as_wkb().desc
     return param
 
 
@@ -72,46 +73,46 @@ register_mariadb_mapping(_MARIADB_FUNCTIONS)
 
 
 def _compile_GeomFromText_MariaDB(element, compiler, **kw):
-    element.identifier = "ST_GeomFromText"
+    identifier = "ST_GeomFromText"
     compiled = compiler.process(element.clauses, **kw)
     try:
         clauses = list(element.clauses)
         data_element = WKTElement(clauses[0].value)
-        srid = max(0, data_element.srid)
+        srid = data_element.srid
         if srid <= 0:
-            srid = max(0, element.type.srid)
-        if len(clauses) > 1 and srid > 0:
-            clauses[1].value = srid
+            srid = element.type.srid
     except Exception:
-        srid = max(0, element.type.srid)
+        srid = element.type.srid
 
     if srid > 0:
-        res = "{}({}, {})".format(element.identifier, compiled, srid)
+        res = "{}({}, {})".format(identifier, compiled, srid)
     else:
-        res = "{}({})".format(element.identifier, compiled)
+        res = "{}({})".format(identifier, compiled)
     return res
 
 
 def _compile_GeomFromWKB_MariaDB(element, compiler, **kw):
-    element.identifier = "ST_GeomFromText"
-
+    identifier = "ST_GeomFromWKB"
+    # Store the SRID
+    clauses = list(element.clauses)
     try:
-        clauses = list(element.clauses)
-        data_element = WKBElement(clauses[0].value)
-        srid = max(0, data_element.srid)
-        if srid <= 0:
-            srid = max(0, element.type.srid)
-        if len(clauses) > 1 and srid > 0:
-            clauses[1].value = srid
-    except Exception:
-        srid = max(0, element.type.srid)
-    compiled = compiler.process(element.clauses, **kw)
+        srid = clauses[1].value
+    except (IndexError, TypeError, ValueError):
+        srid = element.type.srid
+
+    if kw.get("literal_binds", False):
+        wkb_clause = compile_bin_literal(clauses[0])
+    else:
+        wkb_clause = clauses[0]
+    prefix = "unhex("
+    suffix = ")"
+
+    compiled = compiler.process(wkb_clause, **kw)
 
     if srid > 0:
-        res = "{}({}, {})".format(element.identifier, compiled, srid)
+        return "{}({}{}{}, {})".format(identifier, prefix, compiled, suffix, srid)
     else:
-        res = "{}({})".format(element.identifier, compiled)
-    return res
+        return "{}({}{}{})".format(identifier, prefix, compiled, suffix)
 
 
 @compiles(functions.ST_GeomFromText, "mariadb")  # type: ignore

geoalchemy2/admin/dialects/mysql.py

@@ -1,16 +1,29 @@
 """This module defines specific functions for MySQL dialect."""
 
 from sqlalchemy import text
+from sqlalchemy.dialects.mysql.base import ischema_names as _mysql_ischema_names
 from sqlalchemy.ext.compiler import compiles
 from sqlalchemy.sql.sqltypes import NullType
 
 from geoalchemy2 import functions
 from geoalchemy2.admin.dialects.common import _check_spatial_type
 from geoalchemy2.admin.dialects.common import _spatial_idx_name
+from geoalchemy2.admin.dialects.common import compile_bin_literal
 from geoalchemy2.admin.dialects.common import setup_create_drop
 from geoalchemy2.types import Geography
 from geoalchemy2.types import Geometry
 
+# Register Geometry, Geography and Raster to SQLAlchemy's reflection subsystems.
+_mysql_ischema_names["geometry"] = Geometry
+_mysql_ischema_names["point"] = Geometry
+_mysql_ischema_names["linestring"] = Geometry
+_mysql_ischema_names["polygon"] = Geometry
+_mysql_ischema_names["multipoint"] = Geometry
+_mysql_ischema_names["multilinestring"] = Geometry
+_mysql_ischema_names["multipolygon"] = Geometry
+_mysql_ischema_names["geometrycollection"] = Geometry
+
+
 _POSSIBLE_TYPES = [
     "geometry",
     "point",
@@ -124,6 +137,7 @@ def after_create(table, bind, **kw):
         if (
             _check_spatial_type(col.type, (Geometry, Geography), dialect)
             and col.type.spatial_index is True
+            and col.computed is None
         ):
             # If the index does not exist, define it and create it
             if not [i for i in table.indexes if col in i.columns.values()]:
@@ -175,25 +189,39 @@ register_mysql_mapping(_MYSQL_FUNCTIONS)
 
 
 def _compile_GeomFromText_MySql(element, compiler, **kw):
-    element.identifier = "ST_GeomFromText"
+    identifier = "ST_GeomFromText"
     compiled = compiler.process(element.clauses, **kw)
     srid = element.type.srid
 
     if srid > 0:
-        return "{}({}, {})".format(element.identifier, compiled, srid)
+        return "{}({}, {})".format(identifier, compiled, srid)
     else:
-        return "{}({})".format(element.identifier, compiled)
+        return "{}({})".format(identifier, compiled)
 
 
 def _compile_GeomFromWKB_MySql(element, compiler, **kw):
-    element.identifier = "ST_GeomFromWKB"
-    compiled = compiler.process(element.clauses, **kw)
-    srid = element.type.srid
+    # Store the SRID
+    clauses = list(element.clauses)
+    try:
+        srid = clauses[1].value
+    except (IndexError, TypeError, ValueError):
+        srid = element.type.srid
+
+    if kw.get("literal_binds", False):
+        wkb_clause = compile_bin_literal(clauses[0])
+        prefix = "unhex("
+        suffix = ")"
+    else:
+        wkb_clause = clauses[0]
+        prefix = ""
+        suffix = ""
+
+    compiled = compiler.process(wkb_clause, **kw)
 
     if srid > 0:
-        return "{}({}, {})".format(element.identifier, compiled, srid)
+        return "{}({}{}{}, {})".format(element.identifier, prefix, compiled, suffix, srid)
     else:
-        return "{}({})".format(element.identifier, compiled)
+        return "{}({}{}{})".format(element.identifier, prefix, compiled, suffix)
 
 
 @compiles(functions.ST_GeomFromText, "mysql")  # type: ignore

geoalchemy2/admin/dialects/postgresql.py

@@ -1,20 +1,37 @@
 """This module defines specific functions for Postgresql dialect."""
 
+import sqlalchemy
+from packaging import version
 from sqlalchemy import Index
 from sqlalchemy import text
+from sqlalchemy.dialects.postgresql.base import ischema_names as _postgresql_ischema_names
+from sqlalchemy.ext.compiler import compiles
 from sqlalchemy.sql import func
 from sqlalchemy.sql import select
 
+from geoalchemy2 import functions
 from geoalchemy2.admin.dialects.common import _check_spatial_type
 from geoalchemy2.admin.dialects.common import _format_select_args
 from geoalchemy2.admin.dialects.common import _spatial_idx_name
+from geoalchemy2.admin.dialects.common import compile_bin_literal
 from geoalchemy2.admin.dialects.common import setup_create_drop
 from geoalchemy2.types import Geography
 from geoalchemy2.types import Geometry
+from geoalchemy2.types import Raster
+
+_SQLALCHEMY_VERSION_BEFORE_2 = version.parse(sqlalchemy.__version__) < version.parse("2")
+
+# Register Geometry, Geography and Raster to SQLAlchemy's reflection subsystems.
+_postgresql_ischema_names["geometry"] = Geometry
+_postgresql_ischema_names["geography"] = Geography
+_postgresql_ischema_names["raster"] = Raster
 
 
 def check_management(column):
     """Check if the column should be managed."""
+    if _check_spatial_type(column.type, Raster):
+        # Raster columns are not managed
+        return _SQLALCHEMY_VERSION_BEFORE_2
     return getattr(column.type, "use_typmod", None) is False
 
 
@@ -24,27 +41,34 @@ def create_spatial_index(bind, table, col):
         postgresql_ops = {col.name: "gist_geometry_ops_nd"}
     else:
         postgresql_ops = {}
+    if _check_spatial_type(col.type, Raster):
+        col_func = func.ST_ConvexHull(col)
+    else:
+        col_func = col
     idx = Index(
         _spatial_idx_name(table.name, col.name),
-        col,
+        col_func,
         postgresql_using="gist",
         postgresql_ops=postgresql_ops,
         _column_flag=True,
     )
-    idx.create(bind=bind)
+    if bind is not None:
+        idx.create(bind=bind)
+    return idx
 
 
 def reflect_geometry_column(inspector, table, column_info):
     """Reflect a column of type Geometry with Postgresql dialect."""
-    if not isinstance(column_info.get("type"), Geometry):
+    if not _check_spatial_type(column_info.get("type"), (Geometry, Geography, Raster)):
         return
     geo_type = column_info["type"]
     geometry_type = geo_type.geometry_type
     coord_dimension = geo_type.dimension
-    if geometry_type.endswith("ZM"):
-        coord_dimension = 4
-    elif geometry_type[-1] in ["Z", "M"]:
-        coord_dimension = 3
+    if geometry_type is not None:
+        if geometry_type.endswith("ZM"):
+            coord_dimension = 4
+        elif geometry_type[-1] in ["Z", "M"]:
+            coord_dimension = 3
 
     # Query to check a given column has spatial index
     if table.schema is not None:
@@ -52,31 +76,39 @@ def reflect_geometry_column(inspector, table, column_info):
     else:
         schema_part = ""
 
-    has_index_query = """SELECT (indexrelid IS NOT NULL) AS has_index
-        FROM (
-            SELECT
-                    n.nspname,
-                    c.relname,
-                    c.oid AS relid,
-                    a.attname,
-                    a.attnum
-            FROM pg_attribute a
-            INNER JOIN pg_class c ON (a.attrelid=c.oid)
-            INNER JOIN pg_type t ON (a.atttypid=t.oid)
-            INNER JOIN pg_namespace n ON (c.relnamespace=n.oid)
-            WHERE t.typname='geometry'
-                    AND c.relkind='r'
-        ) g
-        LEFT JOIN pg_index i ON (g.relid = i.indrelid AND g.attnum = ANY(i.indkey))
-        WHERE relname = '{}' AND attname = '{}'{};
-    """.format(
-        table.name, column_info["name"], schema_part
+    # Check if the column has a spatial index (the regular expression checks for the column name
+    # in the index definition, which is required for functional indexes)
+    has_index_query = """SELECT EXISTS (
+        SELECT 1
+        FROM pg_class t
+        JOIN pg_namespace n ON n.oid = t.relnamespace
+        JOIN pg_index ix ON t.oid = ix.indrelid
+        JOIN pg_class i ON i.oid = ix.indexrelid
+        JOIN pg_am am ON i.relam = am.oid
+        WHERE
+            t.relname = '{table_name}'{schema_part}
+            AND am.amname = 'gist'
+            AND (
+                EXISTS (
+                    SELECT 1
+                    FROM pg_attribute a
+                    WHERE a.attrelid = t.oid
+                    AND a.attnum = ANY(ix.indkey)
+                    AND a.attname = '{col_name}'
+                )
+                OR pg_get_indexdef(
+                    ix.indexrelid
+                ) ~ '(^|[^a-zA-Z0-9_])("?{col_name}"?)($|[^a-zA-Z0-9_])'
+            )
+    );""".format(
+        table_name=table.name, col_name=column_info["name"], schema_part=schema_part
     )
     spatial_index = inspector.bind.execute(text(has_index_query)).scalar()
 
     # Set attributes
-    column_info["type"].geometry_type = geometry_type
-    column_info["type"].dimension = coord_dimension
+    if not _check_spatial_type(column_info["type"], Raster):
+        column_info["type"].geometry_type = geometry_type
+        column_info["type"].dimension = coord_dimension
     column_info["type"].spatial_index = bool(spatial_index)
 
     # Spatial indexes are automatically reflected with PostgreSQL dialect
@@ -95,7 +127,7 @@ def before_create(table, bind, **kw):
     for idx in current_indexes:
         for col in table.info["_saved_columns"]:
             if (
-                _check_spatial_type(col.type, Geometry, dialect) and check_management(col)
+                _check_spatial_type(col.type, (Geometry, Raster), dialect) and check_management(col)
             ) and col in idx.columns.values():
                 table.indexes.remove(idx)
                 if idx.name != _spatial_idx_name(table.name, col.name) or not getattr(
@@ -124,9 +156,9 @@ def after_create(table, bind, **kw):
             stmt = stmt.execution_options(autocommit=True)
             bind.execute(stmt)
 
-        # Add spatial indices for the Geometry and Geography columns
+        # Add spatial indices for the Geometry, Geography and Raster columns
         if (
-            _check_spatial_type(col.type, (Geometry, Geography), dialect)
+            _check_spatial_type(col.type, (Geometry, Geography, Raster), dialect)
             and col.type.spatial_index is True
         ):
             # If the index does not exist, define it and create it
@@ -146,6 +178,9 @@ def before_drop(table, bind, **kw):
 
     # Drop the managed Geometry columns
     for col in gis_cols:
+        if _check_spatial_type(col.type, Raster):
+            # Raster columns are dropped with the table, no need to drop them separately
+            continue
         args = [table.schema] if table.schema else []
         args.extend([table.name, col.name])
 
@@ -160,3 +195,38 @@ def after_drop(table, bind, **kw):
     saved_cols = table.info.pop("_saved_columns", None)
     if saved_cols is not None:
         table.columns = saved_cols
+
+
+def _compile_GeomFromWKB_Postgresql(element, compiler, **kw):
+    # Store the SRID
+    clauses = list(element.clauses)
+    try:
+        srid = clauses[1].value
+    except (IndexError, TypeError, ValueError):
+        srid = element.type.srid
+
+    if kw.get("literal_binds", False):
+        wkb_clause = compile_bin_literal(clauses[0])
+        prefix = "decode("
+        suffix = ", 'hex')"
+    else:
+        wkb_clause = clauses[0]
+        prefix = ""
+        suffix = ""
+
+    compiled = compiler.process(wkb_clause, **kw)
+
+    if srid > 0:
+        return "{}({}{}{}, {})".format(element.identifier, prefix, compiled, suffix, srid)
+    else:
+        return "{}({}{}{})".format(element.identifier, prefix, compiled, suffix)
+
+
+@compiles(functions.ST_GeomFromWKB, "postgresql")  # type: ignore
+def _PostgreSQL_ST_GeomFromWKB(element, compiler, **kw):
+    return _compile_GeomFromWKB_Postgresql(element, compiler, **kw)
+
+
+@compiles(functions.ST_GeomFromEWKB, "postgresql")  # type: ignore
+def _PostgreSQL_ST_GeomFromEWKB(element, compiler, **kw):
+    return _compile_GeomFromWKB_Postgresql(element, compiler, **kw)

geoalchemy2/admin/dialects/sqlite.py

@@ -4,6 +4,7 @@ import os
 from typing import Optional
 
 from sqlalchemy import text
+from sqlalchemy.dialects.sqlite.base import ischema_names as _sqlite_ischema_names
 from sqlalchemy.ext.compiler import compiles
 from sqlalchemy.sql import func
 from sqlalchemy.sql import select
@@ -12,12 +13,26 @@ from geoalchemy2 import functions
 from geoalchemy2.admin.dialects.common import _check_spatial_type
 from geoalchemy2.admin.dialects.common import _format_select_args
 from geoalchemy2.admin.dialects.common import _spatial_idx_name
+from geoalchemy2.admin.dialects.common import compile_bin_literal
 from geoalchemy2.admin.dialects.common import setup_create_drop
 from geoalchemy2.types import Geography
 from geoalchemy2.types import Geometry
+from geoalchemy2.types import Raster
 from geoalchemy2.types import _DummyGeometry
 from geoalchemy2.utils import authorized_values_in_docstring
 
+# Register Geometry, Geography and Raster to SQLAlchemy's reflection subsystems.
+_sqlite_ischema_names["GEOMETRY"] = Geometry
+_sqlite_ischema_names["POINT"] = Geometry
+_sqlite_ischema_names["LINESTRING"] = Geometry
+_sqlite_ischema_names["POLYGON"] = Geometry
+_sqlite_ischema_names["MULTIPOINT"] = Geometry
+_sqlite_ischema_names["MULTILINESTRING"] = Geometry
+_sqlite_ischema_names["MULTIPOLYGON"] = Geometry
+_sqlite_ischema_names["CURVE"] = Geometry
+_sqlite_ischema_names["GEOMETRYCOLLECTION"] = Geometry
+_sqlite_ischema_names["RASTER"] = Raster
+
 
 def load_spatialite_driver(dbapi_conn, *args):
     """Load SpatiaLite extension in SQLite connection.
@@ -171,7 +186,7 @@ def get_col_dim(col):
     """Get dimension of the column type."""
     if col.type.dimension == 4:
         dimension = "XYZM"
-    elif col.type.dimension == 2:
+    elif col.type.dimension == 2 or col.type.geometry_type is None:
         dimension = "XY"
     else:
         if col.type.geometry_type.endswith("M"):
@@ -183,6 +198,9 @@ def get_col_dim(col):
 
 def create_spatial_index(bind, table, col):
     """Create spatial index on the given column."""
+    if col.computed is not None:
+        # Do not create spatial index for computed columns
+        return
     stmt = select(*_format_select_args(func.CreateSpatialIndex(table.name, col.name)))
     stmt = stmt.execution_options(autocommit=True)
     bind.execute(stmt)
@@ -190,6 +208,10 @@ def create_spatial_index(bind, table, col):
 
 def disable_spatial_index(bind, table, col):
     """Disable spatial indexes if present."""
+    if col.computed is not None:
+        # Do not disable spatial index for computed columns because it can not exist
+        return
+    # Check if the spatial index is enabled
     stmt = select(*_format_select_args(func.CheckSpatialIndex(table.name, col.name)))
     if bind.execute(stmt).fetchone()[0] is not None:
         stmt = select(*_format_select_args(func.DisableSpatialIndex(table.name, col.name)))
@@ -276,7 +298,7 @@ def before_create(table, bind, **kw):
     current_indexes = set(table.indexes)
     for idx in current_indexes:
         for col in table.info["_saved_columns"]:
-            if (_check_spatial_type(col.type, Geometry, dialect)) and col in idx.columns.values():
+            if _check_spatial_type(col.type, Geometry, dialect) and col in idx.columns.values():
                 table.indexes.remove(idx)
                 if idx.name != _spatial_idx_name(table.name, col.name) or not getattr(
                     col.type, "spatial_index", False
@@ -293,11 +315,17 @@ def after_create(table, bind, **kw):
     table.columns = table.info.pop("_saved_columns")
     for col in table.columns:
         # Add the managed Geometry columns with RecoverGeometryColumn()
-        if _check_spatial_type(col.type, Geometry, dialect):
+        if _check_spatial_type(col.type, Geometry, dialect) and col.computed is None:
             col.type = col._actual_type
             del col._actual_type
             dimension = get_col_dim(col)
-            args = [table.name, col.name, col.type.srid, col.type.geometry_type, dimension]
+            args = [
+                table.name,
+                col.name,
+                col.type.srid,
+                col.type.geometry_type or "GEOMETRY",
+                dimension,
+            ]
 
             stmt = select(*_format_select_args(func.RecoverGeometryColumn(*args)))
             stmt = stmt.execution_options(autocommit=True)
@@ -322,6 +350,9 @@ def before_drop(table, bind, **kw):
     dialect, gis_cols, regular_cols = setup_create_drop(table, bind)
 
     for col in gis_cols:
+        if col.computed is not None:
+            # Computed columns are not managed
+            continue
         # Disable spatial indexes if present
         disable_spatial_index(bind, table, col)
 
@@ -341,7 +372,7 @@ def after_drop(table, bind, **kw):
 # the ST_ prefix.
 _SQLITE_FUNCTIONS = {
     "ST_GeomFromEWKT": "GeomFromEWKT",
-    "ST_GeomFromEWKB": "GeomFromEWKB",
+    # "ST_GeomFromEWKB": "GeomFromEWKB",
     "ST_AsBinary": "AsBinary",
     "ST_AsEWKB": "AsEWKB",
     "ST_AsGeoJSON": "AsGeoJSON",
@@ -372,3 +403,41 @@ def register_sqlite_mapping(mapping):
 
 
 register_sqlite_mapping(_SQLITE_FUNCTIONS)
+
+
+def _compile_GeomFromWKB_SQLite(element, compiler, *, identifier, **kw):
+    element.identifier = identifier
+
+    # Store the SRID
+    clauses = list(element.clauses)
+    try:
+        srid = clauses[1].value
+        element.type.srid = srid
+    except (IndexError, TypeError, ValueError):
+        srid = element.type.srid
+
+    if kw.get("literal_binds", False):
+        wkb_clause = compile_bin_literal(clauses[0])
+        prefix = "unhex("
+        suffix = ")"
+    else:
+        wkb_clause = clauses[0]
+        prefix = ""
+        suffix = ""
+
+    compiled = compiler.process(wkb_clause, **kw)
+
+    if srid > 0:
+        return "{}({}{}{}, {})".format(identifier, prefix, compiled, suffix, srid)
+    else:
+        return "{}({}{}{})".format(identifier, prefix, compiled, suffix)
+
+
+@compiles(functions.ST_GeomFromWKB, "sqlite")  # type: ignore
+def _SQLite_ST_GeomFromWKB(element, compiler, **kw):
+    return _compile_GeomFromWKB_SQLite(element, compiler, identifier="GeomFromWKB", **kw)
+
+
+@compiles(functions.ST_GeomFromEWKB, "sqlite")  # type: ignore
+def _SQLite_ST_GeomFromEWKB(element, compiler, **kw):
+    return _compile_GeomFromWKB_SQLite(element, compiler, identifier="GeomFromEWKB", **kw)

geoalchemy2/alembic_helpers.py

@@ -535,6 +535,7 @@ def create_geo_table(context, revision, op):
             schema=op.schema,
             _namespace_metadata=op._namespace_metadata,
             _constraints_included=op._constraints_included,
+            **op.kw,
         )
     else:
         new_op = op