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

{GeoAlchemy2-0.15.2.dist-info → GeoAlchemy2-0.17.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.2
 Name: GeoAlchemy2
-Version: 0.15.2
+Version: 0.17.0
 Summary: Using SQLAlchemy with Spatial Databases
 Home-page: https://geoalchemy-2.readthedocs.io/en/stable/
 Author: Eric Lemoine
@@ -24,10 +24,22 @@ Classifier: License :: OSI Approved :: MIT License
 Classifier: Topic :: Scientific/Engineering :: GIS
 Requires-Python: >=3.7
 License-File: COPYING.rst
-Requires-Dist: SQLAlchemy >=1.4
+Requires-Dist: SQLAlchemy>=1.4
 Requires-Dist: packaging
 Provides-Extra: shapely
-Requires-Dist: Shapely >=1.7 ; extra == 'shapely'
+Requires-Dist: Shapely>=1.7; extra == "shapely"
+Dynamic: author
+Dynamic: author-email
+Dynamic: classifier
+Dynamic: description
+Dynamic: home-page
+Dynamic: keywords
+Dynamic: license
+Dynamic: project-url
+Dynamic: provides-extra
+Dynamic: requires-dist
+Dynamic: requires-python
+Dynamic: summary
 
 ============
 GeoAlchemy 2

GeoAlchemy2-0.17.0.dist-info/RECORD

@@ -0,0 +1,35 @@
+geoalchemy2/__init__.py,sha256=aGo3WcjOBcqrvqYXBuzCff1d_WiFUFObgtcyR11gg6M,2043
+geoalchemy2/_functions.py,sha256=e8v584Fx_fmh8XnJvkuYEXrcyPDiWV95Mu2yw6L-LHY,62863
+geoalchemy2/_functions_helpers.py,sha256=hVM9DDTgf-oM27EZu6ycW1y2ENnSxUJixdINetWsu0E,2651
+geoalchemy2/alembic_helpers.py,sha256=WYjKiVVyHtlB4DI22z-G0-x8NnG8othAINUwmxBCMcs,27885
+geoalchemy2/comparator.py,sha256=WUDXn10doDlJVnYiWbVIAhhBu7N5AO9BI8sNf2mhpA4,8100
+geoalchemy2/elements.py,sha256=5yd_7dUQGbrLvgYvo6A2YYAFwTvP4_BskIdBCB0DrlM,13002
+geoalchemy2/exc.py,sha256=Nn9bRKB_35skWDMkEf4_Y2GL6gvguPVycPZcbOfa69g,226
+geoalchemy2/functions.py,sha256=0he8hy_SAWpXAFPdfg32NMW5G0FaZP7yVl0jn0MRLBQ,10320
+geoalchemy2/functions.pyi,sha256=rKCKdDSVTgeUQHItkOKqJSEuyKmVJ30bpjLpCPwMI5g,108636
+geoalchemy2/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+geoalchemy2/shape.py,sha256=TLeWa6NwXZqBxh3Zj-l96wBB5kPviEhnZ44kyr8v678,2735
+geoalchemy2/utils.py,sha256=OYWYnT64tjp4DWhPdq3KIxHbVti932xPMtGGxajtu-I,488
+geoalchemy2/admin/__init__.py,sha256=O5kr1ETm3lTpEELm16Oxq6344KztOZmUaapf0ZIP6b8,4016
+geoalchemy2/admin/plugin.py,sha256=2U5p4_JdZM7b2MOXXBfP8KhtXlLHu-ASjxTq4mF-thg,4332
+geoalchemy2/admin/dialects/__init__.py,sha256=z4gBrdglClnmp9VdDW0WwEAGNoemMUSvMCeFFvuQcgs,422
+geoalchemy2/admin/dialects/common.py,sha256=p-CGtcooIESy-BiwZ8bmmdAORjuJtTK-sq_X0jnjHB0,3036
+geoalchemy2/admin/dialects/geopackage.py,sha256=PgOhRftDN4I_OIqqOfop7jgmospReCq6qJi6BGW-Gts,13596
+geoalchemy2/admin/dialects/mariadb.py,sha256=4PtkC1Gv4jcAl_grO5lJwxPsIChi4_8g36soZXnMM3w,4267
+geoalchemy2/admin/dialects/mysql.py,sha256=NP0qXGsvssHZKegP8m8-4Vqbx8CosNHTsq6qfSD2MHs,7181
+geoalchemy2/admin/dialects/postgresql.py,sha256=VwB_h3TC8M5aQ6aKE3UYgxHfbEKav3eIHJeLx534Zzg,6191
+geoalchemy2/admin/dialects/sqlite.py,sha256=iW5MBhbxVKGMVghN5Do0iF-_9Pbtrv65NTXmW9mOyZA,13802
+geoalchemy2/types/__init__.py,sha256=Ud1_6gukAs3gSzN3BThZnC-p0naHnTcNEjlyD5Ahm-M,14240
+geoalchemy2/types/dialects/__init__.py,sha256=GYqO6nDtzElvsV22VN1SSUet2elaZG4ZuRrM-asbstM,414
+geoalchemy2/types/dialects/common.py,sha256=eiIKe-sFAdzgvQ7YT0cV29tYAPrs55GXKJi3p1UvjPQ,158
+geoalchemy2/types/dialects/geopackage.py,sha256=nRmN_PnF-CWMEHkWhKVdsybnw3SvXZIBXAHIHXJLTqw,147
+geoalchemy2/types/dialects/mariadb.py,sha256=tPZpfj95XlVSOm8zC52iFbqVrIOdj-EDH5KVJP1Gd9c,1723
+geoalchemy2/types/dialects/mysql.py,sha256=zMNi1920v0XlVaCJWSwtq0b0P5YQRn8y3X_rBxC5KEw,1790
+geoalchemy2/types/dialects/postgresql.py,sha256=7NBKEbDJXMwX8Sgs6o_N2bAUHgjUcjbrdmYOA7sDiRw,1117
+geoalchemy2/types/dialects/sqlite.py,sha256=B-yLzaQcqL_4dXoOPX9D9IXw2ZQlq-Tibv_kqUIBeb4,2104
+GeoAlchemy2-0.17.0.dist-info/COPYING.rst,sha256=-bQKftq9uMOROzF7oN65kYBBIJKxTmBuDoftp27IC3I,1056
+GeoAlchemy2-0.17.0.dist-info/METADATA,sha256=mc9wg4zIYUEuRbFYELFA4LygDIo6hKXdM9CDR-KyHQo,2327
+GeoAlchemy2-0.17.0.dist-info/WHEEL,sha256=In9FTNxeP60KnTkGw7wk6mJPYd_dQSjEZmXdBdMCI-8,91
+GeoAlchemy2-0.17.0.dist-info/entry_points.txt,sha256=izFHecGE8cNV6IjoLkc0uEmKH13rYbbvozc4fEwRl6Y,70
+GeoAlchemy2-0.17.0.dist-info/top_level.txt,sha256=3kGUTcfBeXd61zFpof6-qiuw1peNF_HuZabgHQgrdis,12
+GeoAlchemy2-0.17.0.dist-info/RECORD,,

{GeoAlchemy2-0.15.2.dist-info → GeoAlchemy2-0.17.0.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (70.3.0)
+Generator: setuptools (75.8.0)
 Root-Is-Purelib: true
 Tag: py3-none-any
 

GeoAlchemy2-0.17.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[sqlalchemy.plugins]
+geoalchemy2 = geoalchemy2.admin.plugin:GeoEngine

geoalchemy2/__init__.py

@@ -8,6 +8,7 @@ from geoalchemy2 import shape  # noqa
 from geoalchemy2 import types  # noqa
 from geoalchemy2.admin.dialects.geopackage import load_spatialite_gpkg  # noqa
 from geoalchemy2.admin.dialects.sqlite import load_spatialite  # noqa
+from geoalchemy2.admin.plugin import GeoEngine  # noqa
 from geoalchemy2.elements import CompositeElement  # noqa
 from geoalchemy2.elements import RasterElement  # noqa
 from geoalchemy2.elements import WKBElement  # noqa
@@ -50,6 +51,7 @@ __all__ = [
     "__version__",
     "ArgumentError",
     "CompositeElement",
+    "GeoEngine",
     "Geography",
     "Geometry",
     "Raster",

geoalchemy2/admin/__init__.py

@@ -20,7 +20,7 @@ def select_dialect(dialect_name):
     known_dialects = {
         "geopackage": dialects.geopackage,
         "mysql": dialects.mysql,
-        "mariadb": dialects.mysql,
+        "mariadb": dialects.mariadb,
         "postgresql": dialects.postgresql,
         "sqlite": dialects.sqlite,
     }
@@ -53,7 +53,7 @@ def setup_ddl_event_listeners():
     @event.listens_for(Column, "after_parent_attach")
     def after_parent_attach(column, table):
         """Automatically add spatial indexes."""
-        if not isinstance(table, Table):
+        if not isinstance(table, Table):  # pragma: no cover
             # For old versions of SQLAlchemy, subqueries might trigger the after_parent_attach event
             # with a selectable as table, so we want to skip this case.
             return
@@ -75,7 +75,7 @@ def setup_ddl_event_listeners():
         try:
             if column.type._spatial_index_reflected:
                 return
-        except AttributeError:
+        except AttributeError:  # pragma: no cover
             pass
 
         kwargs = {
@@ -98,7 +98,7 @@ def setup_ddl_event_listeners():
         )
 
     @event.listens_for(Table, "column_reflect")
-    def _reflect_geometry_column(inspector, table, column_info):
+    def column_reflect(inspector, table, column_info):
         select_dialect(inspector.bind.dialect.name).reflect_geometry_column(
             inspector, table, column_info
         )

geoalchemy2/admin/dialects/__init__.py

@@ -2,6 +2,7 @@
 
 from geoalchemy2.admin.dialects import common  # noqa
 from geoalchemy2.admin.dialects import geopackage  # noqa
+from geoalchemy2.admin.dialects import mariadb  # noqa
 from geoalchemy2.admin.dialects import mysql  # noqa
 from geoalchemy2.admin.dialects import postgresql  # noqa
 from geoalchemy2.admin.dialects import sqlite  # noqa

geoalchemy2/admin/dialects/common.py

@@ -85,20 +85,20 @@ def setup_create_drop(table, bind, check_col_management=None):
 
 
 def reflect_geometry_column(inspector, table, column_info):
-    return
+    return  # pragma: no cover
 
 
 def before_create(table, bind, **kw):
-    return
+    return  # pragma: no cover
 
 
 def after_create(table, bind, **kw):
-    return
+    return  # pragma: no cover
 
 
 def before_drop(table, bind, **kw):
-    return
+    return  # pragma: no cover
 
 
 def after_drop(table, bind, **kw):
-    return
+    return  # pragma: no cover

geoalchemy2/admin/dialects/geopackage.py

@@ -71,15 +71,15 @@ def init_geopackage(dbapi_conn, *args):
         dbapi_conn.execute("SELECT gpkgCreateBaseTables();")
 
 
-def load_spatialite_gpkg(*args, **kwargs):
+def load_spatialite_gpkg(dbapi_conn, *args, **kwargs):
     """Load SpatiaLite extension in GeoPackage and initialize internal tables.
 
     See :func:`geoalchemy2.admin.dialects.geopackage.load_geopackage_driver` and
     :func:`geoalchemy2.admin.dialects.geopackage.init_geopackage` functions for details about
     arguments.
     """
-    load_geopackage_driver(*args)
-    init_geopackage(*args, **kwargs)
+    load_geopackage_driver(dbapi_conn)
+    init_geopackage(dbapi_conn, **kwargs)
 
 
 def _get_spatialite_attrs(bind, table_name, col_name):
@@ -188,6 +188,10 @@ def reflect_geometry_column(inspector, table, column_info):
         column_info["type"]._spatial_index_reflected = False
 
 
+def connect(dbapi_conn, *args, **kwargs):
+    return load_spatialite_gpkg(dbapi_conn, *args, **kwargs)
+
+
 def before_create(table, bind, **kw):
     """Handle spatial indexes during the before_create event."""
     dialect, gis_cols, regular_cols = setup_create_drop(table, bind)

geoalchemy2/admin/dialects/mariadb.py

@@ -0,0 +1,134 @@
+"""This module defines specific functions for MariaDB dialect."""
+
+from sqlalchemy.ext.compiler import compiles
+
+from geoalchemy2 import functions
+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
+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")
+    return param
+
+
+def before_cursor_execute(
+    conn, cursor, statement, parameters, context, executemany, convert=True
+):  # noqa: D417
+    """Event handler to cast the parameters properly.
+
+    Args:
+        convert (bool): Trigger the conversion.
+    """
+    if convert:
+        if isinstance(parameters, (tuple, list)):
+            parameters = tuple(_cast(x) for x in parameters)
+        elif isinstance(parameters, dict):
+            for k in parameters:
+                parameters[k] = _cast(parameters[k])
+
+    return statement, parameters
+
+
+_MARIADB_FUNCTIONS = {
+    "ST_AsEWKB": "ST_AsBinary",
+}
+
+
+def _compiles_mariadb(cls, fn):
+    def _compile_mariadb(element, compiler, **kw):
+        return "{}({})".format(fn, compiler.process(element.clauses, **kw))
+
+    compiles(getattr(functions, cls), "mariadb")(_compile_mariadb)
+
+
+def register_mariadb_mapping(mapping):
+    """Register compilation mappings for the given functions.
+
+    Args:
+        mapping: Should have the following form::
+
+                {
+                    "function_name_1": "mariadb_function_name_1",
+                    "function_name_2": "mariadb_function_name_2",
+                    ...
+                }
+    """
+    for cls, fn in mapping.items():
+        _compiles_mariadb(cls, fn)
+
+
+register_mariadb_mapping(_MARIADB_FUNCTIONS)
+
+
+def _compile_GeomFromText_MariaDB(element, compiler, **kw):
+    element.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)
+        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)
+
+    if srid > 0:
+        res = "{}({}, {})".format(element.identifier, compiled, srid)
+    else:
+        res = "{}({})".format(element.identifier, compiled)
+    return res
+
+
+def _compile_GeomFromWKB_MariaDB(element, compiler, **kw):
+    element.identifier = "ST_GeomFromText"
+
+    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)
+
+    if srid > 0:
+        res = "{}({}, {})".format(element.identifier, compiled, srid)
+    else:
+        res = "{}({})".format(element.identifier, compiled)
+    return res
+
+
+@compiles(functions.ST_GeomFromText, "mariadb")  # type: ignore
+def _MariaDB_ST_GeomFromText(element, compiler, **kw):
+    return _compile_GeomFromText_MariaDB(element, compiler, **kw)
+
+
+@compiles(functions.ST_GeomFromEWKT, "mariadb")  # type: ignore
+def _MariaDB_ST_GeomFromEWKT(element, compiler, **kw):
+    return _compile_GeomFromText_MariaDB(element, compiler, **kw)
+
+
+@compiles(functions.ST_GeomFromWKB, "mariadb")  # type: ignore
+def _MariaDB_ST_GeomFromWKB(element, compiler, **kw):
+    return _compile_GeomFromWKB_MariaDB(element, compiler, **kw)
+
+
+@compiles(functions.ST_GeomFromEWKB, "mariadb")  # type: ignore
+def _MariaDB_ST_GeomFromEWKB(element, compiler, **kw):
+    return _compile_GeomFromWKB_MariaDB(element, compiler, **kw)

geoalchemy2/admin/dialects/mysql.py

@@ -31,11 +31,16 @@ def reflect_geometry_column(inspector, table, column_info):
     column_name = column_info.get("name")
     schema = table.schema or inspector.default_schema_name
 
+    if inspector.dialect.name == "mariadb":
+        select_srid = "-1, "
+    else:
+        select_srid = "SRS_ID, "
+
     # Check geometry type, SRID and if the column is nullable
-    geometry_type_query = """SELECT DATA_TYPE, SRS_ID, IS_NULLABLE
+    geometry_type_query = """SELECT DATA_TYPE, {}IS_NULLABLE
         FROM INFORMATION_SCHEMA.COLUMNS
         WHERE TABLE_NAME = '{}' and COLUMN_NAME = '{}'""".format(
-        table.name, column_name
+        select_srid, table.name, column_name
     )
     if schema is not None:
         geometry_type_query += """ and table_schema = '{}'""".format(schema)
@@ -43,7 +48,7 @@ def reflect_geometry_column(inspector, table, column_info):
     is_nullable = str(nullable_str).lower() == "yes"
 
     if geometry_type not in _POSSIBLE_TYPES:
-        return
+        return  # pragma: no cover
 
     # Check if the column has spatial index
     has_index_query = """SELECT DISTINCT
@@ -67,6 +72,25 @@ def reflect_geometry_column(inspector, table, column_info):
     )
 
 
+def before_cursor_execute(
+    conn, cursor, statement, parameters, context, executemany, convert=True
+):  # noqa: D417
+    """Event handler to cast the parameters properly.
+
+    Args:
+        convert (bool): Trigger the conversion.
+    """
+    if convert:
+        if isinstance(parameters, (tuple, list)):
+            parameters = tuple(x.tobytes() if isinstance(x, memoryview) else x for x in parameters)
+        elif isinstance(parameters, dict):
+            for k in parameters:
+                if isinstance(parameters[k], memoryview):
+                    parameters[k] = parameters[k].tobytes()
+
+    return statement, parameters
+
+
 def before_create(table, bind, **kw):
     """Handle spatial indexes during the before_create event."""
     dialect, gis_cols, regular_cols = setup_create_drop(table, bind)
@@ -129,7 +153,6 @@ def _compiles_mysql(cls, fn):
         return "{}({})".format(fn, compiler.process(element.clauses, **kw))
 
     compiles(getattr(functions, cls), "mysql")(_compile_mysql)
-    compiles(getattr(functions, cls), "mariadb")(_compile_mysql)
 
 
 def register_mysql_mapping(mapping):
@@ -164,9 +187,6 @@ def _compile_GeomFromText_MySql(element, compiler, **kw):
 
 def _compile_GeomFromWKB_MySql(element, compiler, **kw):
     element.identifier = "ST_GeomFromWKB"
-    wkb_data = list(element.clauses)[0].value
-    if isinstance(wkb_data, memoryview):
-        list(element.clauses)[0].value = wkb_data.tobytes()
     compiled = compiler.process(element.clauses, **kw)
     srid = element.type.srid
 
@@ -177,24 +197,20 @@ def _compile_GeomFromWKB_MySql(element, compiler, **kw):
 
 
 @compiles(functions.ST_GeomFromText, "mysql")  # type: ignore
-@compiles(functions.ST_GeomFromText, "mariadb")  # type: ignore
 def _MySQL_ST_GeomFromText(element, compiler, **kw):
     return _compile_GeomFromText_MySql(element, compiler, **kw)
 
 
 @compiles(functions.ST_GeomFromEWKT, "mysql")  # type: ignore
-@compiles(functions.ST_GeomFromEWKT, "mariadb")  # type: ignore
 def _MySQL_ST_GeomFromEWKT(element, compiler, **kw):
     return _compile_GeomFromText_MySql(element, compiler, **kw)
 
 
 @compiles(functions.ST_GeomFromWKB, "mysql")  # type: ignore
-@compiles(functions.ST_GeomFromWKB, "mariadb")  # type: ignore
 def _MySQL_ST_GeomFromWKB(element, compiler, **kw):
     return _compile_GeomFromWKB_MySql(element, compiler, **kw)
 
 
 @compiles(functions.ST_GeomFromEWKB, "mysql")  # type: ignore
-@compiles(functions.ST_GeomFromEWKB, "mariadb")  # type: ignore
 def _MySQL_ST_GeomFromEWKB(element, compiler, **kw):
     return _compile_GeomFromWKB_MySql(element, compiler, **kw)

geoalchemy2/admin/dialects/sqlite.py

@@ -51,6 +51,8 @@ def init_spatialite(
 
     Args:
         dbapi_conn: The DBAPI connection.
+        transaction: If set to `True` the whole operation will be handled as a single Transaction
+            (faster). The default value is `False` (slower, but safer).
         init_mode: Can be `None` to load all EPSG SRIDs, `'WGS84'` to load only the ones related
             to WGS84 or `'EMPTY'` to not load any EPSG SRID.
 
@@ -58,8 +60,6 @@ def init_spatialite(
 
                 It is possible to load other EPSG SRIDs afterwards using `InsertEpsgSrid(srid)`.
 
-        transaction: If set to `True` the whole operation will be handled as a single Transaction
-            (faster). The default value is `False` (slower, but safer).
         journal_mode: Change the journal mode to the given value. This can make the table creation
             much faster. The possible values are the following: <JOURNAL_MODE_VALUES>. See
             https://www.sqlite.org/pragma.html#pragma_journal_mode for more details.
@@ -127,15 +127,15 @@ def init_spatialite(
             dbapi_conn.execute("PRAGMA journal_mode = {}".format(current_journal_mode))
 
 
-def load_spatialite(*args, **kwargs):
+def load_spatialite(dbapi_conn, *args, **kwargs):
     """Load SpatiaLite extension in SQLite DB and initialize internal tables.
 
     See :func:`geoalchemy2.admin.dialects.sqlite.load_spatialite_driver` and
     :func:`geoalchemy2.admin.dialects.sqlite.init_spatialite` functions for details about
     arguments.
     """
-    load_spatialite_driver(*args)
-    init_spatialite(*args, **kwargs)
+    load_spatialite_driver(dbapi_conn)
+    init_spatialite(dbapi_conn, **kwargs)
 
 
 def _get_spatialite_attrs(bind, table_name, col_name):
@@ -260,6 +260,11 @@ def reflect_geometry_column(inspector, table, column_info):
         column_info["type"]._spatial_index_reflected = False
 
 
+def connect(dbapi_conn, *args, **kwargs):
+    """Even handler to load spatial extension when a new connection is created."""
+    return load_spatialite(dbapi_conn, *args, **kwargs)
+
+
 def before_create(table, bind, **kw):
     """Handle spatial indexes during the before_create event."""
     dialect, gis_cols, regular_cols = setup_create_drop(table, bind)

geoalchemy2/admin/plugin.py

@@ -0,0 +1,98 @@
+from collections import defaultdict
+from functools import partial
+
+from sqlalchemy import event
+from sqlalchemy.engine import CreateEnginePlugin
+
+from geoalchemy2.admin import select_dialect
+
+
+class GeoEngine(CreateEnginePlugin):
+    """A plugin to create `sqlalchemy.Engine` objects with specific events to handle spatial data.
+
+    This plugin should only be used with the :func:`sqlalchemy.create_engine` function. This plugin
+    will automatically attach the relevant event listeners to the new engine depending on its
+    dialect. For some specific dialects it's even possible to pass arguments to customize the
+    functions called by the listeners. These arguments have the following form:
+    `geoalchemy2_<event>_<dialect>_<argument_name>`.
+    For example, creating a new SQLite DB and initialize the SpatiaLite extension with only the
+    WGS84 SRID can be performed this way:
+
+    .. code-block:: python
+
+        db_url = "sqlite:////tmp/test_db.sqlite?geoalchemy2_connect_sqlite_init_mode=WGS84"
+        engine = sqlalchemy.create_engine(db_url, plugins=["geoalchemy2"])
+
+    The names of the parameters can be found in the event listener of each dialect. Note that all
+    dialects don't have listeners for all events.
+    """
+
+    def __init__(self, url, kwargs):
+        super().__init__(url, kwargs)
+
+        # Consume the parameters from the URL query
+        self.params = defaultdict(lambda: defaultdict(dict))
+
+        transaction = url.query.get("geoalchemy2_connect_sqlite_transaction", None)
+        if transaction is not None:
+            self.params["connect"]["sqlite"]["transaction"] = self.str_to_bool(transaction)
+
+        init_mode = url.query.get("geoalchemy2_connect_sqlite_init_mode", None)
+        if init_mode is not None:
+            self.params["connect"]["sqlite"]["init_mode"] = init_mode
+
+        journal_mode = url.query.get("geoalchemy2_connect_sqlite_journal_mode", None)
+        if journal_mode is not None:
+            self.params["connect"]["sqlite"]["journal_mode"] = journal_mode
+
+        before_cursor_execute_convert_mysql = url.query.get(
+            "geoalchemy2_before_cursor_execute_mysql_convert", None
+        )
+        if before_cursor_execute_convert_mysql is not None:
+            self.params["before_cursor_execute"]["mysql"]["convert"] = self.str_to_bool(
+                before_cursor_execute_convert_mysql
+            )
+
+        before_cursor_execute_convert_mariadb = url.query.get(
+            "geoalchemy2_before_cursor_execute_mariadb_convert", None
+        )
+        if before_cursor_execute_convert_mariadb is not None:
+            self.params["before_cursor_execute"]["mariadb"]["convert"] = self.str_to_bool(
+                before_cursor_execute_convert_mariadb
+            )
+
+    @staticmethod
+    def str_to_bool(argument):
+        """Cast argument to bool."""
+        lowered = str(argument).lower()
+        if lowered in ("yes", "y", "true", "t", "1", "enable", "on"):
+            return True
+        elif lowered in ("no", "n", "false", "f", "0", "disable", "off"):
+            return False
+        raise ValueError(argument)
+
+    def update_url(self, url):
+        """Update the URL to one that no longer includes specific parameters."""
+        return url.difference_update_query(
+            [
+                "geoalchemy2_connect_sqlite_transaction",
+                "geoalchemy2_connect_sqlite_init_mode",
+                "geoalchemy2_connect_sqlite_journal_mode",
+                "geoalchemy2_before_cursor_execute_mysql_convert",
+                "geoalchemy2_before_cursor_execute_mariadb_convert",
+            ],
+        )
+
+    def engine_created(self, engine):
+        """Attach event listeners after the new Engine object is created."""
+        dialect_module = select_dialect(engine.dialect.name)
+
+        if hasattr(dialect_module, "connect"):
+            params = dict(self.params["connect"].get(engine.dialect.name, {}))
+            func = partial(dialect_module.connect, **params)
+            event.listen(engine, "connect", func)
+
+        if hasattr(dialect_module, "before_cursor_execute"):
+            params = dict(self.params["before_cursor_execute"].get(engine.dialect.name, {}))
+            func = partial(dialect_module.before_cursor_execute, **params)
+            event.listen(engine, "before_cursor_execute", func, retval=True)

geoalchemy2/shape.py

@@ -48,7 +48,6 @@ def to_shape(element: Union[WKBElement, WKTElement]):
         lake = Session.query(Lake).get(1)
         polygon = to_shape(lake.geom)
     """
-    assert isinstance(element, (WKBElement, WKTElement))
     if isinstance(element, WKBElement):
         data, hex = (
             (element.data, True) if isinstance(element.data, str) else (bytes(element.data), False)

geoalchemy2/types/__init__.py

@@ -40,7 +40,7 @@ def select_dialect(dialect_name):
     known_dialects = {
         "geopackage": dialects.geopackage,
         "mysql": dialects.mysql,
-        "mariadb": dialects.mysql,
+        "mariadb": dialects.mariadb,
         "postgresql": dialects.postgresql,
         "sqlite": dialects.sqlite,
     }
@@ -198,9 +198,9 @@ class _GISType(UserDefinedType):
         return geometry_type, srid
 
 
-@compiles(_GISType, "mariadb")
 @compiles(_GISType, "mysql")
-def get_col_spec(self, *args, **kwargs):
+@compiles(_GISType, "mariadb")
+def get_col_spec_mysql(self, compiler, *args, **kwargs):
     if self.geometry_type is not None:
         spec = "%s" % self.geometry_type
     else:
@@ -208,7 +208,7 @@ def get_col_spec(self, *args, **kwargs):
 
     if not self.nullable or self.spatial_index:
         spec += " NOT NULL"
-    if self.srid > 0:
+    if self.srid > 0 and compiler.dialect.name != "mariadb":
         spec += " SRID %d" % self.srid
     return spec
 
@@ -245,7 +245,7 @@ class Geometry(_GISType):
     """ The element class to use. Used by the parent class'
         ``result_processor`` method. """
 
-    cache_ok = False
+    cache_ok = True
     """ Disable cache for this type. """
 
 
@@ -275,7 +275,7 @@ class Geography(_GISType):
     """ The element class to use. Used by the parent class'
         ``result_processor`` method. """
 
-    cache_ok = False
+    cache_ok = True
     """ Disable cache for this type. """
 
 
@@ -315,7 +315,7 @@ class Raster(_GISType):
     """ The element class to use. Used by the parent class'
         ``result_processor`` method. """
 
-    cache_ok = False
+    cache_ok = True
     """ Disable cache for this type. """
 
     def __init__(self, spatial_index=True, from_text=None, name=None, nullable=True) -> None:

geoalchemy2/types/dialects/__init__.py

@@ -2,6 +2,7 @@
 
 from geoalchemy2.types.dialects import common  # noqa
 from geoalchemy2.types.dialects import geopackage  # noqa
+from geoalchemy2.types.dialects import mariadb  # noqa
 from geoalchemy2.types.dialects import mysql  # noqa
 from geoalchemy2.types.dialects import postgresql  # noqa
 from geoalchemy2.types.dialects import sqlite  # noqa

geoalchemy2/types/dialects/common.py

@@ -2,4 +2,4 @@
 
 
 def bind_processor_process(spatial_type, bindvalue):
-    return bindvalue
+    return bindvalue  # pragma: no cover

geoalchemy2/types/dialects/mariadb.py

@@ -0,0 +1,47 @@
+"""This module defines specific functions for MySQL dialect."""
+
+from geoalchemy2.elements import WKBElement
+from geoalchemy2.elements import WKTElement
+from geoalchemy2.elements import _SpatialElement
+from geoalchemy2.exc import ArgumentError
+from geoalchemy2.shape import to_shape
+
+
+def bind_processor_process(spatial_type, bindvalue):
+    if isinstance(bindvalue, str):
+        wkt_match = WKTElement._REMOVE_SRID.match(bindvalue)
+        srid = wkt_match.group(2)
+        try:
+            if srid is not None:
+                srid = int(srid)
+        except (ValueError, TypeError):  # pragma: no cover
+            raise ArgumentError(
+                f"The SRID ({srid}) of the supplied value can not be casted to integer"
+            )
+
+        if srid is not None and srid != spatial_type.srid:
+            raise ArgumentError(
+                f"The SRID ({srid}) of the supplied value is different "
+                f"from the one of the column ({spatial_type.srid})"
+            )
+        return wkt_match.group(3)
+
+    if (
+        isinstance(bindvalue, _SpatialElement)
+        and bindvalue.srid != -1
+        and bindvalue.srid != spatial_type.srid
+    ):
+        raise ArgumentError(
+            f"The SRID ({bindvalue.srid}) of the supplied value is different "
+            f"from the one of the column ({spatial_type.srid})"
+        )
+
+    if isinstance(bindvalue, WKTElement):
+        bindvalue = bindvalue.as_wkt()
+        if bindvalue.srid <= 0:
+            bindvalue.srid = spatial_type.srid
+        return bindvalue
+    elif isinstance(bindvalue, WKBElement):
+        # With MariaDB we use Shapely to convert the WKBElement to an EWKT string
+        return to_shape(bindvalue).wkt
+    return bindvalue

GeoAlchemy2-0.15.2.dist-info/RECORD

@@ -1,31 +0,0 @@
-geoalchemy2/__init__.py,sha256=Wb5f11AM_hYn56yrxOAOjCT3z76TCtseqjFo2hKsob4,1971
-geoalchemy2/_functions.py,sha256=e8v584Fx_fmh8XnJvkuYEXrcyPDiWV95Mu2yw6L-LHY,62863
-geoalchemy2/_functions_helpers.py,sha256=hVM9DDTgf-oM27EZu6ycW1y2ENnSxUJixdINetWsu0E,2651
-geoalchemy2/alembic_helpers.py,sha256=WYjKiVVyHtlB4DI22z-G0-x8NnG8othAINUwmxBCMcs,27885
-geoalchemy2/comparator.py,sha256=WUDXn10doDlJVnYiWbVIAhhBu7N5AO9BI8sNf2mhpA4,8100
-geoalchemy2/elements.py,sha256=5yd_7dUQGbrLvgYvo6A2YYAFwTvP4_BskIdBCB0DrlM,13002
-geoalchemy2/exc.py,sha256=Nn9bRKB_35skWDMkEf4_Y2GL6gvguPVycPZcbOfa69g,226
-geoalchemy2/functions.py,sha256=0he8hy_SAWpXAFPdfg32NMW5G0FaZP7yVl0jn0MRLBQ,10320
-geoalchemy2/functions.pyi,sha256=rKCKdDSVTgeUQHItkOKqJSEuyKmVJ30bpjLpCPwMI5g,108636
-geoalchemy2/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-geoalchemy2/shape.py,sha256=TZJIhCN4p4ZVwZMXidxYxTMeeyReAyoFzyYwspJRqSA,2792
-geoalchemy2/utils.py,sha256=OYWYnT64tjp4DWhPdq3KIxHbVti932xPMtGGxajtu-I,488
-geoalchemy2/admin/__init__.py,sha256=s8L5C9pYC5dTxhIp9j-JzWeg9kEJevXUW8Pq4_L4aZ8,3984
-geoalchemy2/admin/dialects/__init__.py,sha256=XodzuBbWKkkSQzM5EL3I33azuE-y_go0nVOlmIyJ13g,367
-geoalchemy2/admin/dialects/common.py,sha256=8OkGa7T2Gxz2vDVnC9nva8Ma0YqBwGxHWfBJoZF1cNQ,2936
-geoalchemy2/admin/dialects/geopackage.py,sha256=UaJignKtlo13oHxq92yescVJtXFEXkm4fy5WzR6sLT8,13469
-geoalchemy2/admin/dialects/mysql.py,sha256=z2gmkTGav60_myDCFxO1yeezDKBcNcMxFvcpH-OqVKw,6867
-geoalchemy2/admin/dialects/postgresql.py,sha256=VwB_h3TC8M5aQ6aKE3UYgxHfbEKav3eIHJeLx534Zzg,6191
-geoalchemy2/admin/dialects/sqlite.py,sha256=UYQuNDDy-1-lsvYlqyKy01UtHgLF4iEN42fE5D-9QQk,13597
-geoalchemy2/types/__init__.py,sha256=dD2-E8rr1nXr_d4CqyiEvRjO1H-dDRQnzr5B1g3_an8,14186
-geoalchemy2/types/dialects/__init__.py,sha256=sw__RqGAFVrUPGrICjsva9SPoYLBNfyAkBHmsJkT7k0,359
-geoalchemy2/types/dialects/common.py,sha256=gxKaRQhIODJhu_yBurlvFNAqGh3LfPNu_DcObEG1wlU,138
-geoalchemy2/types/dialects/geopackage.py,sha256=nRmN_PnF-CWMEHkWhKVdsybnw3SvXZIBXAHIHXJLTqw,147
-geoalchemy2/types/dialects/mysql.py,sha256=zMNi1920v0XlVaCJWSwtq0b0P5YQRn8y3X_rBxC5KEw,1790
-geoalchemy2/types/dialects/postgresql.py,sha256=7NBKEbDJXMwX8Sgs6o_N2bAUHgjUcjbrdmYOA7sDiRw,1117
-geoalchemy2/types/dialects/sqlite.py,sha256=B-yLzaQcqL_4dXoOPX9D9IXw2ZQlq-Tibv_kqUIBeb4,2104
-GeoAlchemy2-0.15.2.dist-info/COPYING.rst,sha256=-bQKftq9uMOROzF7oN65kYBBIJKxTmBuDoftp27IC3I,1056
-GeoAlchemy2-0.15.2.dist-info/METADATA,sha256=7ti009u_zE-vAPIyGyfVcC-oZzloZ-TYOKOV7ZahmKo,2087
-GeoAlchemy2-0.15.2.dist-info/WHEEL,sha256=Z4pYXqR_rTB7OWNDYFOm1qRk0RX6GFP2o8LgvP453Hk,91
-GeoAlchemy2-0.15.2.dist-info/top_level.txt,sha256=3kGUTcfBeXd61zFpof6-qiuw1peNF_HuZabgHQgrdis,12
-GeoAlchemy2-0.15.2.dist-info/RECORD,,