SPATIALITE: fix insert incompatible geometry types

elpaso · elpaso · commit ed64f37b51bd · 2023-09-30T08:27:27.000+02:00
Fix #54662 Logic shamelessly copied from potgres provider.
diff --git a/src/providers/spatialite/qgsspatialiteprovider.cpp b/src/providers/spatialite/qgsspatialiteprovider.cpp
@@ -18,6 +18,10 @@ email                : a.furieri@lqt.it
 #include "qgsfeature.h"
 #include "qgsfields.h"
 #include "qgsgeometry.h"
+#include "qgsgeometryfactory.h"
+#include "qgsgeometrycollection.h"
+#include "qgscompoundcurve.h"
+#include "qgscircularstring.h"
 #include "qgsrectangle.h"
 #include "qgscoordinatereferencesystem.h"
 #include "qgslogger.h"
@@ -127,6 +131,125 @@ bool QgsSpatiaLiteProvider::convertField( QgsField &field )
   return true;
 }
 
+QgsGeometry QgsSpatiaLiteProvider::convertToProviderType( const QgsGeometry &geom ) const
+{
+  if ( geom.isNull() )
+  {
+    return QgsGeometry();
+  }
+
+  const QgsAbstractGeometry *geometry = geom.constGet();
+  if ( !geometry )
+  {
+    return QgsGeometry();
+  }
+
+  const Qgis::WkbType providerGeomType = wkbType();
+
+  //geom is already in the provider geometry type
+  if ( geometry->wkbType() == providerGeomType )
+  {
+    return QgsGeometry();
+  }
+
+  std::unique_ptr< QgsAbstractGeometry > outputGeom;
+
+  //convert compoundcurve to circularstring (possible if compoundcurve consists of one circular string)
+  if ( QgsWkbTypes::flatType( providerGeomType ) == Qgis::WkbType::CircularString )
+  {
+    QgsCompoundCurve *compoundCurve = qgsgeometry_cast<QgsCompoundCurve *>( geometry );
+    if ( compoundCurve )
+    {
+      if ( compoundCurve->nCurves() == 1 )
+      {
+        const QgsCircularString *circularString = qgsgeometry_cast<const QgsCircularString *>( compoundCurve->curveAt( 0 ) );
+        if ( circularString )
+        {
+          outputGeom.reset( circularString->clone() );
+        }
+      }
+    }
+  }
+
+  //convert to curved type if necessary
+  if ( !QgsWkbTypes::isCurvedType( geometry->wkbType() ) && QgsWkbTypes::isCurvedType( providerGeomType ) )
+  {
+    QgsAbstractGeometry *curveGeom = outputGeom ? outputGeom->toCurveType() : geometry->toCurveType();
+    if ( curveGeom )
+    {
+      outputGeom.reset( curveGeom );
+    }
+  }
+
+  //convert to linear type from curved type
+  if ( QgsWkbTypes::isCurvedType( geometry->wkbType() ) && !QgsWkbTypes::isCurvedType( providerGeomType ) )
+  {
+    QgsAbstractGeometry *segmentizedGeom = outputGeom ? outputGeom->segmentize() : geometry->segmentize();
+    if ( segmentizedGeom )
+    {
+      outputGeom.reset( segmentizedGeom );
+    }
+  }
+
+  //convert to multitype if necessary
+  if ( QgsWkbTypes::isMultiType( providerGeomType ) && !QgsWkbTypes::isMultiType( geometry->wkbType() ) )
+  {
+    std::unique_ptr< QgsAbstractGeometry > collGeom( QgsGeometryFactory::geomFromWkbType( providerGeomType ) );
+    QgsGeometryCollection *geomCollection = qgsgeometry_cast<QgsGeometryCollection *>( collGeom.get() );
+    if ( geomCollection )
+    {
+      if ( geomCollection->addGeometry( outputGeom ? outputGeom->clone() : geometry->clone() ) )
+      {
+        outputGeom.reset( collGeom.release() );
+      }
+    }
+  }
+
+  //convert to single type if there's a single part of compatible type
+  if ( !QgsWkbTypes::isMultiType( providerGeomType ) && QgsWkbTypes::isMultiType( geometry->wkbType() ) )
+  {
+    const QgsGeometryCollection *collection = qgsgeometry_cast<const QgsGeometryCollection *>( geometry );
+    if ( collection )
+    {
+      if ( collection->numGeometries() == 1 )
+      {
+        const QgsAbstractGeometry *firstGeom = collection->geometryN( 0 );
+        if ( firstGeom && firstGeom->wkbType() == providerGeomType )
+        {
+          outputGeom.reset( firstGeom->clone() );
+        }
+      }
+    }
+  }
+
+  //set z/m types
+  if ( QgsWkbTypes::hasZ( providerGeomType ) )
+  {
+    if ( !outputGeom )
+    {
+      outputGeom.reset( geometry->clone() );
+    }
+    outputGeom->addZValue();
+  }
+
+  if ( QgsWkbTypes::hasM( providerGeomType ) )
+  {
+    if ( !outputGeom )
+    {
+      outputGeom.reset( geometry->clone() );
+    }
+    outputGeom->addMValue();
+  }
+
+  if ( outputGeom )
+  {
+    return QgsGeometry( outputGeom.release() );
+  }
+
+  return QgsGeometry();
+
+}
+
 
 Qgis::VectorExportResult QgsSpatiaLiteProvider::createEmptyLayer( const QString &uri,
     const QgsFields &fields,
@@ -4230,7 +4353,8 @@ bool QgsSpatiaLiteProvider::addFeatures( QgsFeatureList &flist, Flags flags )
           {
             unsigned char *wkb = nullptr;
             int wkb_size;
-            QByteArray featureWkb = feature->geometry().asWkb();
+            const QgsGeometry convertedGeom( convertToProviderType( feature->geometry() ) );
+            const QByteArray featureWkb{ !convertedGeom.isNull() ? convertedGeom.asWkb() : feature->geometry().asWkb() };
             convertFromGeosWKB( reinterpret_cast<const unsigned char *>( featureWkb.constData() ),
                                 featureWkb.length(),
                                 &wkb, &wkb_size, nDims );
diff --git a/src/providers/spatialite/qgsspatialiteprovider.h b/src/providers/spatialite/qgsspatialiteprovider.h
@@ -218,6 +218,9 @@ class QgsSpatiaLiteProvider final: public QgsVectorDataProvider
     //! Convert a QgsField to work with SL
     static bool convertField( QgsField &field );
 
+    //! Convert a geometry to a compatible type, borrowed from Posgres provider.
+    QgsGeometry convertToProviderType( const QgsGeometry &geom ) const;
+
     QString geomParam() const;
 
     //! Gets SpatiaLite version string
diff --git a/tests/src/python/test_provider_spatialite.py b/tests/src/python/test_provider_spatialite.py
@@ -45,7 +45,7 @@
 from qgis.utils import spatialite_connect
 
 from providertestbase import ProviderTestCase
-from utilities import unitTestDataPath
+from utilities import unitTestDataPath, compareWkt
 
 # Pass no_exit=True: for some reason this crashes sometimes on exit on Travis
 start_app(True)
@@ -1885,6 +1885,33 @@ def test_absolute_relative_uri(self):
         self.assertEqual(meta.absoluteToRelativeUri(absolute_uri, context), relative_uri)
         self.assertEqual(meta.relativeToAbsoluteUri(relative_uri, context), absolute_uri)
 
+    def testRegression54622Multisurface(self):
+
+        con = spatialite_connect(self.dbname, isolation_level=None)
+        cur = con.cursor()
+        cur.execute("BEGIN")
+        sql = sql = """CREATE TABLE table54622 (
+            _id INTEGER PRIMARY KEY AUTOINCREMENT)"""
+        cur.execute(sql)
+        sql = "SELECT AddGeometryColumn('table54622', 'geometry', 25832, 'MULTIPOLYGON', 'XY', 0)"
+        cur.execute(sql)
+        cur.execute("COMMIT")
+        con.close()
+
+        layer = QgsVectorLayer(
+            'dbname=\'{}\' table="table54622" (geometry) sql='.format(self.dbname), 'test', 'spatialite')
+
+        self.assertTrue(layer.isValid())
+        feature = QgsFeature(layer.fields())
+        feature.setGeometry(QgsGeometry.fromWkt('MULTISURFACE(CURVEPOLYGON(COMPOUNDCURVE((-0.886 0.135,-0.886 -0.038,-0.448 -0.070,-0.427 0.144,-0.886 0.135))))'))
+        self.assertTrue(layer.dataProvider().addFeatures([feature]))
+
+        layer = QgsVectorLayer(
+            'dbname=\'{}\' table="table54622" (geometry) sql='.format(self.dbname), 'test', 'spatialite')
+        feature = next(layer.getFeatures())
+        self.assertFalse(feature.geometry().isNull())
+        self.assertTrue(compareWkt(feature.geometry().asWkt(), 'MultiPolygon (((-0.886 0.135, -0.886 -0.038, -0.448 -0.070, -0.426 0.143, -0.886 0.135)))', 0.01))
+
 
 if __name__ == '__main__':
     unittest.main()
