LCOV - code coverage report
Current view: top level - ogr/ogrsf_frmts/sqlite - ogr_sqlite.h (source / functions) Hit Total Coverage
Test: gdal_filtered.info Lines: 79 87 90.8 %
Date: 2025-02-18 14:19:29 Functions: 35 39 89.7 %

          Line data    Source code
       1             : /******************************************************************************
       2             :  *
       3             :  * Project:  OpenGIS Simple Features Reference Implementation
       4             :  * Purpose:  Private definitions for OGR/SQLite driver.
       5             :  * Author:   Frank Warmerdam, warmerdam@pobox.com
       6             :  *
       7             :  ******************************************************************************
       8             :  * Copyright (c) 2004, Frank Warmerdam <warmerdam@pobox.com>
       9             :  * Copyright (c) 2009-2014, Even Rouault <even dot rouault at spatialys.com>
      10             :  *
      11             :  * SPDX-License-Identifier: MIT
      12             :  ****************************************************************************/
      13             : 
      14             : #ifndef OGR_SQLITE_H_INCLUDED
      15             : #define OGR_SQLITE_H_INCLUDED
      16             : 
      17             : #include <cstddef>
      18             : #include <map>
      19             : #include <set>
      20             : #include <utility>
      21             : #include <vector>
      22             : 
      23             : #include "cpl_error.h"
      24             : #include "gdal_pam.h"
      25             : #include "ogrsf_frmts.h"
      26             : #include "ogrsf_frmts.h"
      27             : #include "rasterlite2_header.h"
      28             : 
      29             : #ifdef SPATIALITE_AMALGAMATION
      30             : /*
      31             : / using an AMALGAMATED version of SpatiaLite
      32             : / a private internal copy of SQLite is included:
      33             : / so we are required including the SpatiaLite's
      34             : / own header
      35             : /
      36             : / IMPORTANT NOTICE: using AMALAGATION is only
      37             : / useful on Windows (to skip DLL hell related oddities)
      38             : /
      39             : / You MUST NOT use AMALGAMATION on Linux or any
      40             : / other "sane" operating system !!!!
      41             : */
      42             : #include <spatialite/sqlite3.h>
      43             : #else
      44             : #include <sqlite3.h>
      45             : #endif
      46             : 
      47             : #define UNINITIALIZED_SRID -2
      48             : 
      49             : #if defined(DEBUG) || defined(FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION) ||     \
      50             :     defined(ALLOW_FORMAT_DUMPS)
      51             : // Enable accepting a SQL dump (starting with a "-- SQL SQLITE" or
      52             : // "-- SQL RASTERLITE" or "--SQL MBTILES" line) as a valid
      53             : // file. This makes fuzzer life easier
      54             : #define ENABLE_SQL_SQLITE_FORMAT
      55             : #endif
      56             : 
      57             : #include "ogrsqlitebase.h"
      58             : 
      59             : /************************************************************************/
      60             : /*      SpatiaLite's own Geometry type IDs.                             */
      61             : /************************************************************************/
      62             : 
      63             : enum OGRSpatialiteGeomType
      64             : {
      65             :     // 2D [XY]
      66             :     OGRSplitePointXY = 1,
      67             :     OGRSpliteLineStringXY = 2,
      68             :     OGRSplitePolygonXY = 3,
      69             :     OGRSpliteMultiPointXY = 4,
      70             :     OGRSpliteMultiLineStringXY = 5,
      71             :     OGRSpliteMultiPolygonXY = 6,
      72             :     OGRSpliteGeometryCollectionXY = 7,
      73             :     // 3D [XYZ]
      74             :     OGRSplitePointXYZ = 1001,
      75             :     OGRSpliteLineStringXYZ = 1002,
      76             :     OGRSplitePolygonXYZ = 1003,
      77             :     OGRSpliteMultiPointXYZ = 1004,
      78             :     OGRSpliteMultiLineStringXYZ = 1005,
      79             :     OGRSpliteMultiPolygonXYZ = 1006,
      80             :     OGRSpliteGeometryCollectionXYZ = 1007,
      81             :     // 2D with Measure [XYM]
      82             :     OGRSplitePointXYM = 2001,
      83             :     OGRSpliteLineStringXYM = 2002,
      84             :     OGRSplitePolygonXYM = 2003,
      85             :     OGRSpliteMultiPointXYM = 2004,
      86             :     OGRSpliteMultiLineStringXYM = 2005,
      87             :     OGRSpliteMultiPolygonXYM = 2006,
      88             :     OGRSpliteGeometryCollectionXYM = 2007,
      89             :     // 3D with Measure [XYZM]
      90             :     OGRSplitePointXYZM = 3001,
      91             :     OGRSpliteLineStringXYZM = 3002,
      92             :     OGRSplitePolygonXYZM = 3003,
      93             :     OGRSpliteMultiPointXYZM = 3004,
      94             :     OGRSpliteMultiLineStringXYZM = 3005,
      95             :     OGRSpliteMultiPolygonXYZM = 3006,
      96             :     OGRSpliteGeometryCollectionXYZM = 3007,
      97             :     // COMPRESSED: 2D [XY]
      98             :     OGRSpliteComprLineStringXY = 1000002,
      99             :     OGRSpliteComprPolygonXY = 1000003,
     100             :     OGRSpliteComprMultiPointXY = 1000004,
     101             :     OGRSpliteComprMultiLineStringXY = 1000005,
     102             :     OGRSpliteComprMultiPolygonXY = 1000006,
     103             :     OGRSpliteComprGeometryCollectionXY = 1000007,
     104             :     // COMPRESSED: 3D [XYZ]
     105             :     OGRSpliteComprLineStringXYZ = 1001002,
     106             :     OGRSpliteComprPolygonXYZ = 1001003,
     107             :     OGRSpliteComprMultiPointXYZ = 1001004,
     108             :     OGRSpliteComprMultiLineStringXYZ = 1001005,
     109             :     OGRSpliteComprMultiPolygonXYZ = 1001006,
     110             :     OGRSpliteComprGeometryCollectionXYZ = 1001007,
     111             :     // COMPRESSED: 2D with Measure [XYM]
     112             :     OGRSpliteComprLineStringXYM = 1002002,
     113             :     OGRSpliteComprPolygonXYM = 1002003,
     114             :     OGRSpliteComprMultiPointXYM = 1002004,
     115             :     OGRSpliteComprMultiLineStringXYM = 1002005,
     116             :     OGRSpliteComprMultiPolygonXYM = 1002006,
     117             :     OGRSpliteComprGeometryCollectionXYM = 1002007,
     118             :     // COMPRESSED: 3D with Measure [XYZM]
     119             :     OGRSpliteComprLineStringXYZM = 1003002,
     120             :     OGRSpliteComprPolygonXYZM = 1003003,
     121             :     OGRSpliteComprMultiPointXYZM = 1003004,
     122             :     OGRSpliteComprMultiLineStringXYZM = 1003005,
     123             :     OGRSpliteComprMultiPolygonXYZM = 1003006,
     124             :     OGRSpliteComprGeometryCollectionXYZM = 1003007
     125             : };
     126             : 
     127             : /************************************************************************/
     128             : /*                            OGRSQLiteLayer                            */
     129             : /************************************************************************/
     130             : 
     131             : class OGRSQLiteDataSource;
     132             : 
     133             : class OGRSQLiteLayer CPL_NON_FINAL : public OGRLayer,
     134             :                                      public IOGRSQLiteGetSpatialWhere
     135             : {
     136             :   private:
     137             :     static OGRErr
     138             :     createFromSpatialiteInternal(const GByte *pabyData, OGRGeometry **ppoReturn,
     139             :                                  int nBytes, OGRwkbByteOrder eByteOrder,
     140             :                                  int *pnBytesConsumed, int nRecLevel);
     141             : 
     142             :     static int CanBeCompressedSpatialiteGeometry(const OGRGeometry *poGeometry);
     143             : 
     144             :     static int ComputeSpatiaLiteGeometrySize(const OGRGeometry *poGeometry,
     145             :                                              bool bSpatialite2D,
     146             :                                              bool bUseComprGeom);
     147             : 
     148             :     static int GetSpatialiteGeometryCode(const OGRGeometry *poGeometry,
     149             :                                          bool bSpatialite2D, bool bUseComprGeom,
     150             :                                          bool bAcceptMultiGeom);
     151             : 
     152             :     static int ExportSpatiaLiteGeometryInternal(const OGRGeometry *poGeometry,
     153             :                                                 OGRwkbByteOrder eByteOrder,
     154             :                                                 bool bSpatialite2D,
     155             :                                                 bool bUseComprGeom,
     156             :                                                 GByte *pabyData);
     157             : 
     158             :     CPL_DISALLOW_COPY_ASSIGN(OGRSQLiteLayer)
     159             : 
     160             :   protected:
     161             :     OGRSQLiteFeatureDefn *m_poFeatureDefn = nullptr;
     162             : 
     163             :     GIntBig m_iNextShapeId = 0;
     164             : 
     165             :     sqlite3_stmt *m_hStmt = nullptr;
     166             :     bool m_bDoStep = true;
     167             :     bool m_bEOF = false;
     168             : 
     169             :     OGRSQLiteDataSource *m_poDS = nullptr;
     170             : 
     171             :     char *m_pszFIDColumn = nullptr;
     172             : 
     173             :     int *m_panFieldOrdinals = nullptr;
     174             :     int m_iFIDCol = -1;
     175             :     int m_iOGRNativeDataCol = -1;
     176             :     int m_iOGRNativeMediaTypeCol = -1;
     177             : 
     178             :     bool m_bIsVirtualShape = false;
     179             : 
     180             :     void BuildFeatureDefn(const char *pszLayerName, bool bIsSelect,
     181             :                           sqlite3_stmt *hStmt,
     182             :                           const std::set<CPLString> *paosGeomCols,
     183             :                           const std::set<CPLString> &aosIgnoredCols);
     184             : 
     185             :     void ClearStatement();
     186             :     virtual OGRErr ResetStatement() = 0;
     187             : 
     188             :     bool m_bUseComprGeom = false;
     189             : 
     190             :     char **m_papszCompressedColumns = nullptr;
     191             : 
     192             :     bool m_bAllowMultipleGeomFields = false;
     193             : 
     194             :     static CPLString FormatSpatialFilterFromRTree(
     195             :         OGRGeometry *poFilterGeom, const char *pszRowIDName,
     196             :         const char *pszEscapedTable, const char *pszEscapedGeomCol);
     197             : 
     198             :     static CPLString
     199             :     FormatSpatialFilterFromMBR(OGRGeometry *poFilterGeom,
     200             :                                const char *pszEscapedGeomColName);
     201             : 
     202             :     explicit OGRSQLiteLayer(OGRSQLiteDataSource *poDSIn);
     203             : 
     204             :   public:
     205             :     virtual ~OGRSQLiteLayer();
     206             : 
     207             :     void Finalize();
     208             : 
     209             :     GDALDataset *GetDataset() override;
     210             : 
     211             :     virtual void ResetReading() override;
     212             :     virtual OGRFeature *GetNextRawFeature();
     213             :     virtual OGRFeature *GetNextFeature() override;
     214             : 
     215             :     virtual OGRFeature *GetFeature(GIntBig nFeatureId) override;
     216             : 
     217        1983 :     virtual OGRFeatureDefn *GetLayerDefn() override
     218             :     {
     219        1983 :         return m_poFeatureDefn;
     220             :     }
     221             : 
     222          26 :     virtual OGRSQLiteFeatureDefn *myGetLayerDefn()
     223             :     {
     224          26 :         return m_poFeatureDefn;
     225             :     }
     226             : 
     227             :     virtual const char *GetFIDColumn() override;
     228             : 
     229             :     virtual int TestCapability(const char *) override;
     230             : 
     231             :     virtual OGRErr StartTransaction() override;
     232             :     virtual OGRErr CommitTransaction() override;
     233             :     virtual OGRErr RollbackTransaction() override;
     234             : 
     235           1 :     virtual void InvalidateCachedFeatureCountAndExtent()
     236             :     {
     237           1 :     }
     238             : 
     239          17 :     virtual bool IsTableLayer()
     240             :     {
     241          17 :         return false;
     242             :     }
     243             : 
     244           0 :     virtual bool HasSpatialIndex(CPL_UNUSED int iGeomField)
     245             :     {
     246           0 :         return false;
     247             :     }
     248             : 
     249           0 :     virtual bool HasFastSpatialFilter(CPL_UNUSED int iGeomCol) override
     250             :     {
     251           0 :         return false;
     252             :     }
     253             : 
     254             :     virtual CPLString
     255           0 :     GetSpatialWhere(CPL_UNUSED int iGeomCol,
     256             :                     CPL_UNUSED OGRGeometry *poFilterGeom) override
     257             :     {
     258           0 :         return "";
     259             :     }
     260             : 
     261             :     static OGRErr GetSpatialiteGeometryHeader(const GByte *pabyData, int nBytes,
     262             :                                               int *pnSRID,
     263             :                                               OGRwkbGeometryType *peType,
     264             :                                               bool *pbIsEmpty, double *pdfMinX,
     265             :                                               double *pdfMinY, double *pdfMaxX,
     266             :                                               double *pdfMaxY);
     267             :     static OGRErr ImportSpatiaLiteGeometry(const GByte *, int, OGRGeometry **);
     268             :     static OGRErr ImportSpatiaLiteGeometry(const GByte *, int, OGRGeometry **,
     269             :                                            int *pnSRID);
     270             :     static OGRErr ExportSpatiaLiteGeometry(const OGRGeometry *, GInt32,
     271             :                                            OGRwkbByteOrder, bool,
     272             :                                            bool bUseComprGeom, GByte **, int *);
     273             : };
     274             : 
     275             : /************************************************************************/
     276             : /*                         OGRSQLiteTableLayer                          */
     277             : /************************************************************************/
     278             : 
     279             : class OGRSQLiteTableLayer final : public OGRSQLiteLayer
     280             : {
     281             :     bool m_bIsTable = true;
     282             : 
     283             :     bool m_bLaunderColumnNames = true;
     284             :     bool m_bSpatialite2D = false;
     285             :     bool m_bStrict = false;
     286             : 
     287             :     CPLString m_osWHERE{};
     288             :     CPLString m_osQuery{};
     289             :     bool m_bDeferredSpatialIndexCreation = false;
     290             : 
     291             :     char *m_pszTableName = nullptr;
     292             :     char *m_pszEscapedTableName = nullptr;
     293             : 
     294             :     bool m_bLayerDefnError = false;
     295             : 
     296             :     sqlite3_stmt *m_hInsertStmt = nullptr;
     297             :     CPLString m_osLastInsertStmt{};
     298             : 
     299             :     bool m_bHasCheckedTriggers = false;
     300             :     bool m_bHasTriedDetectingFID64 = false;
     301             : 
     302             :     bool m_bStatisticsNeedsToBeFlushed = false;
     303             :     GIntBig m_nFeatureCount = -1; /* if -1, means not up-to-date */
     304             : 
     305             :     int m_bDeferredCreation = false;
     306             : 
     307             :     char *m_pszCreationGeomFormat = nullptr;
     308             :     int m_iFIDAsRegularColumnIndex = -1;
     309             : 
     310             :     void ClearInsertStmt();
     311             : 
     312             :     void BuildWhere();
     313             : 
     314             :     virtual OGRErr ResetStatement() override;
     315             : 
     316             :     OGRErr RecomputeOrdinals();
     317             : 
     318             :     void AddColumnDef(char *pszNewFieldList, size_t nBufLen,
     319             :                       OGRFieldDefn *poFldDefn);
     320             : 
     321             :     void InitFieldListForRecrerate(char *&pszNewFieldList,
     322             :                                    char *&pszFieldListForSelect,
     323             :                                    size_t &nBufLenOut, int nExtraSpace = 0);
     324             :     OGRErr RecreateTable(const char *pszFieldListForSelect,
     325             :                          const char *pszNewFieldList,
     326             :                          const char *pszGenericErrorMessage,
     327             :                          const char *pszAdditionalDef = nullptr);
     328             :     OGRErr BindValues(OGRFeature *poFeature, sqlite3_stmt *hStmt,
     329             :                       bool bBindUnsetAsNull);
     330             : 
     331             :     bool CheckSpatialIndexTable(int iGeomCol);
     332             : 
     333             :     CPLErr EstablishFeatureDefn(const char *pszGeomCol, bool bMayEmitError);
     334             : 
     335             :     void LoadStatistics();
     336             :     void LoadStatisticsSpatialite4DB();
     337             : 
     338             :     CPLString FieldDefnToSQliteFieldDefn(OGRFieldDefn *poFieldDefn);
     339             : 
     340             :     OGRErr RunAddGeometryColumn(const OGRSQLiteGeomFieldDefn *poGeomField,
     341             :                                 bool bAddColumnsForNonSpatialite);
     342             : 
     343             :     CPL_DISALLOW_COPY_ASSIGN(OGRSQLiteTableLayer)
     344             : 
     345             :   public:
     346             :     explicit OGRSQLiteTableLayer(OGRSQLiteDataSource *);
     347             :     virtual ~OGRSQLiteTableLayer();
     348             : 
     349             :     CPLErr Initialize(const char *pszTableName, bool bIsTable,
     350             :                       bool bIsVirtualShapeIn, bool bDeferredCreation,
     351             :                       bool bMayEmitError);
     352             :     void SetCreationParameters(const char *pszFIDColumnName,
     353             :                                OGRwkbGeometryType eGeomType,
     354             :                                const char *pszGeomFormat,
     355             :                                const char *pszGeometryName,
     356             :                                OGRSpatialReference *poSRS, int nSRSId);
     357             :     virtual const char *GetName() override;
     358             : 
     359             :     virtual GIntBig GetFeatureCount(int) override;
     360             : 
     361             :     virtual OGRErr IGetExtent(int iGeomField, OGREnvelope *psExtent,
     362             :                               bool bForce) override;
     363             : 
     364             :     virtual OGRFeatureDefn *GetLayerDefn() override;
     365             : 
     366        6467 :     bool HasLayerDefnError()
     367             :     {
     368        6467 :         GetLayerDefn();
     369        6467 :         return m_bLayerDefnError;
     370             :     }
     371             : 
     372             :     virtual OGRErr ISetSpatialFilter(int iGeomField,
     373             :                                      const OGRGeometry *) override;
     374             :     virtual OGRErr SetAttributeFilter(const char *) override;
     375             :     virtual OGRErr ISetFeature(OGRFeature *poFeature) override;
     376             :     virtual OGRErr DeleteFeature(GIntBig nFID) override;
     377             :     virtual OGRErr ICreateFeature(OGRFeature *poFeature) override;
     378             : 
     379             :     virtual OGRErr CreateField(const OGRFieldDefn *poField,
     380             :                                int bApproxOK = TRUE) override;
     381             :     virtual OGRErr CreateGeomField(const OGRGeomFieldDefn *poGeomFieldIn,
     382             :                                    int bApproxOK = TRUE) override;
     383             :     virtual OGRErr DeleteField(int iField) override;
     384             :     virtual OGRErr ReorderFields(int *panMap) override;
     385             :     virtual OGRErr AlterFieldDefn(int iField, OGRFieldDefn *poNewFieldDefn,
     386             :                                   int nFlags) override;
     387             :     OGRErr AddForeignKeysToTable(const char *pszKeys);
     388             : 
     389             :     virtual OGRFeature *GetNextFeature() override;
     390             :     virtual OGRFeature *GetFeature(GIntBig nFeatureId) override;
     391             : 
     392             :     virtual int TestCapability(const char *) override;
     393             : 
     394             :     virtual char **GetMetadata(const char *pszDomain = "") override;
     395             :     virtual const char *GetMetadataItem(const char *pszName,
     396             :                                         const char *pszDomain = "") override;
     397             : 
     398             :     // follow methods are not base class overrides
     399         428 :     void SetLaunderFlag(bool bFlag)
     400             :     {
     401         428 :         m_bLaunderColumnNames = bFlag;
     402         428 :     }
     403             : 
     404          47 :     void SetUseCompressGeom(bool bFlag)
     405             :     {
     406          47 :         m_bUseComprGeom = bFlag;
     407          47 :     }
     408             : 
     409         148 :     void SetDeferredSpatialIndexCreation(bool bFlag)
     410             :     {
     411         148 :         m_bDeferredSpatialIndexCreation = bFlag;
     412         148 :     }
     413             : 
     414             :     void SetCompressedColumns(const char *pszCompressedColumns);
     415             : 
     416         428 :     void SetStrictFlag(bool bFlag)
     417             :     {
     418         428 :         m_bStrict = bFlag;
     419         428 :     }
     420             : 
     421             :     int CreateSpatialIndex(int iGeomCol);
     422             : 
     423             :     void CreateSpatialIndexIfNecessary();
     424             : 
     425             :     void InitFeatureCount();
     426             :     bool DoStatisticsNeedToBeFlushed();
     427             :     void ForceStatisticsToBeFlushed();
     428             :     bool AreStatisticsValid();
     429             :     int SaveStatistics();
     430             : 
     431             :     virtual void InvalidateCachedFeatureCountAndExtent() override;
     432             : 
     433       14143 :     virtual bool IsTableLayer() override
     434             :     {
     435       14143 :         return true;
     436             :     }
     437             : 
     438             :     virtual bool HasSpatialIndex(int iGeomField) override;
     439             :     virtual bool HasFastSpatialFilter(int iGeomCol) override;
     440             :     virtual CPLString GetSpatialWhere(int iGeomCol,
     441             :                                       OGRGeometry *poFilterGeom) override;
     442             : 
     443             :     OGRErr RunDeferredCreationIfNecessary();
     444             : };
     445             : 
     446             : /************************************************************************/
     447             : /*                         OGRSQLiteViewLayer                           */
     448             : /************************************************************************/
     449             : 
     450             : class OGRSQLiteViewLayer final : public OGRSQLiteLayer
     451             : {
     452             :     CPLString m_osWHERE{};
     453             :     CPLString m_osQuery{};
     454             :     bool m_bHasCheckedSpatialIndexTable = false;
     455             : 
     456             :     OGRSQLiteGeomFormat m_eGeomFormat = OSGF_None;
     457             :     CPLString m_osGeomColumn{};
     458             :     bool m_bHasSpatialIndex = false;
     459             : 
     460             :     char *m_pszViewName = nullptr;
     461             :     char *m_pszEscapedTableName = nullptr;
     462             :     char *m_pszEscapedUnderlyingTableName = nullptr;
     463             : 
     464             :     bool m_bLayerDefnError = false;
     465             : 
     466             :     CPLString m_osUnderlyingTableName{};
     467             :     CPLString m_osUnderlyingGeometryColumn{};
     468             : 
     469             :     OGRSQLiteLayer *m_poUnderlyingLayer = nullptr;
     470             : 
     471             :     OGRSQLiteLayer *GetUnderlyingLayer();
     472             : 
     473             :     void BuildWhere();
     474             : 
     475             :     virtual OGRErr ResetStatement() override;
     476             : 
     477             :     CPLErr EstablishFeatureDefn();
     478             : 
     479             :     CPL_DISALLOW_COPY_ASSIGN(OGRSQLiteViewLayer)
     480             : 
     481             :   public:
     482             :     explicit OGRSQLiteViewLayer(OGRSQLiteDataSource *);
     483             :     virtual ~OGRSQLiteViewLayer();
     484             : 
     485          27 :     virtual const char *GetName() override
     486             :     {
     487          27 :         return m_pszViewName;
     488             :     }
     489             : 
     490             :     virtual OGRwkbGeometryType GetGeomType() override;
     491             : 
     492             :     CPLErr Initialize(const char *pszViewName, const char *pszViewGeometry,
     493             :                       const char *pszViewRowid, const char *pszTableName,
     494             :                       const char *pszGeometryColumn);
     495             : 
     496             :     virtual OGRFeatureDefn *GetLayerDefn() override;
     497             : 
     498          19 :     bool HasLayerDefnError()
     499             :     {
     500          19 :         GetLayerDefn();
     501          19 :         return m_bLayerDefnError;
     502             :     }
     503             : 
     504             :     virtual OGRFeature *GetNextFeature() override;
     505             :     virtual GIntBig GetFeatureCount(int) override;
     506             : 
     507             :     virtual OGRErr ISetSpatialFilter(int iGeomField,
     508             :                                      const OGRGeometry *poGeom) override;
     509             : 
     510             :     virtual OGRErr SetAttributeFilter(const char *) override;
     511             : 
     512             :     virtual OGRFeature *GetFeature(GIntBig nFeatureId) override;
     513             : 
     514             :     virtual int TestCapability(const char *) override;
     515             : 
     516           0 :     virtual bool HasSpatialIndex(CPL_UNUSED int iGeomField) override
     517             :     {
     518           0 :         return m_bHasSpatialIndex;
     519             :     }
     520             : 
     521             :     virtual CPLString GetSpatialWhere(int iGeomCol,
     522             :                                       OGRGeometry *poFilterGeom) override;
     523             : };
     524             : 
     525             : /************************************************************************/
     526             : /*                         OGRSQLiteSelectLayer                         */
     527             : /************************************************************************/
     528             : 
     529             : class OGRSQLiteSelectLayer CPL_NON_FINAL : public OGRSQLiteLayer,
     530             :                                            public IOGRSQLiteSelectLayer
     531             : {
     532             :     OGRSQLiteSelectLayerCommonBehaviour *m_poBehavior = nullptr;
     533             :     bool m_bCanReopenBaseDS = false;
     534             : 
     535             :     virtual OGRErr ResetStatement() override;
     536             : 
     537             :     CPL_DISALLOW_COPY_ASSIGN(OGRSQLiteSelectLayer)
     538             : 
     539             :   public:
     540             :     OGRSQLiteSelectLayer(OGRSQLiteDataSource *, const CPLString &osSQL,
     541             :                          sqlite3_stmt *, bool bUseStatementForGetNextFeature,
     542             :                          bool bEmptyLayer, bool bAllowMultipleGeomFields,
     543             :                          bool bCanReopenBaseDS);
     544             :     virtual ~OGRSQLiteSelectLayer();
     545             : 
     546             :     virtual void ResetReading() override;
     547             : 
     548             :     virtual OGRFeature *GetNextFeature() override;
     549             :     virtual GIntBig GetFeatureCount(int) override;
     550             : 
     551             :     virtual OGRErr ISetSpatialFilter(int iGeomField,
     552             :                                      const OGRGeometry *) override;
     553             :     virtual OGRErr SetAttributeFilter(const char *) override;
     554             : 
     555             :     virtual int TestCapability(const char *) override;
     556             : 
     557             :     virtual OGRErr IGetExtent(int iGeomField, OGREnvelope *psExtent,
     558             :                               bool bForce) override;
     559             : 
     560        1983 :     virtual OGRFeatureDefn *GetLayerDefn() override
     561             :     {
     562        1983 :         return OGRSQLiteLayer::GetLayerDefn();
     563             :     }
     564             : 
     565         725 :     virtual char *&GetAttrQueryString() override
     566             :     {
     567         725 :         return m_pszAttrQueryString;
     568             :     }
     569             : 
     570         281 :     virtual OGRFeatureQuery *&GetFeatureQuery() override
     571             :     {
     572         281 :         return m_poAttrQuery;
     573             :     }
     574             : 
     575         533 :     virtual OGRGeometry *&GetFilterGeom() override
     576             :     {
     577         533 :         return m_poFilterGeom;
     578             :     }
     579             : 
     580         270 :     virtual int &GetIGeomFieldFilter() override
     581             :     {
     582         270 :         return m_iGeomFieldFilter;
     583             :     }
     584             : 
     585         351 :     virtual OGRSpatialReference *GetSpatialRef() override
     586             :     {
     587         351 :         return OGRSQLiteLayer::GetSpatialRef();
     588             :     }
     589             : 
     590         163 :     virtual int InstallFilter(const OGRGeometry *poGeomIn) override
     591             :     {
     592         163 :         return OGRSQLiteLayer::InstallFilter(poGeomIn);
     593             :     }
     594             : 
     595         629 :     virtual int HasReadFeature() override
     596             :     {
     597         629 :         return m_iNextShapeId > 0;
     598             :     }
     599             : 
     600         402 :     virtual void BaseResetReading() override
     601             :     {
     602         402 :         OGRSQLiteLayer::ResetReading();
     603         402 :     }
     604             : 
     605        3226 :     virtual OGRFeature *BaseGetNextFeature() override
     606             :     {
     607        3226 :         return OGRSQLiteLayer::GetNextFeature();
     608             :     }
     609             : 
     610           2 :     virtual OGRErr BaseSetAttributeFilter(const char *pszQuery) override
     611             :     {
     612           2 :         return OGRSQLiteLayer::SetAttributeFilter(pszQuery);
     613             :     }
     614             : 
     615          47 :     virtual GIntBig BaseGetFeatureCount(int bForce) override
     616             :     {
     617          47 :         return OGRSQLiteLayer::GetFeatureCount(bForce);
     618             :     }
     619             : 
     620          51 :     virtual int BaseTestCapability(const char *pszCap) override
     621             :     {
     622          51 :         return OGRSQLiteLayer::TestCapability(pszCap);
     623             :     }
     624             : 
     625           5 :     virtual OGRErr BaseGetExtent(int iGeomField, OGREnvelope *psExtent,
     626             :                                  bool bForce) override
     627             :     {
     628           5 :         return OGRSQLiteLayer::IGetExtent(iGeomField, psExtent, bForce);
     629             :     }
     630             : 
     631             :     bool
     632           2 :     ValidateGeometryFieldIndexForSetSpatialFilter(int iGeomField,
     633             :                                                   const OGRGeometry *poGeomIn,
     634             :                                                   bool bIsSelectLayer) override
     635             :     {
     636           2 :         return OGRSQLiteLayer::ValidateGeometryFieldIndexForSetSpatialFilter(
     637           2 :             iGeomField, poGeomIn, bIsSelectLayer);
     638             :     }
     639             : };
     640             : 
     641             : /************************************************************************/
     642             : /*                         OGRSQLiteDataSource                          */
     643             : /************************************************************************/
     644             : 
     645             : class OGR2SQLITEModule;
     646             : 
     647             : class OGRSQLiteDataSource final : public OGRSQLiteBaseDataSource
     648             : {
     649             :     std::vector<std::unique_ptr<OGRSQLiteLayer>> m_apoLayers{};
     650             : 
     651             :     // We maintain a list of known SRID to reduce the number of trips to
     652             :     // the database to get SRSes.
     653             :     std::map<int,
     654             :              std::unique_ptr<OGRSpatialReference, OGRSpatialReferenceReleaser>>
     655             :         m_oSRSCache{};
     656             : 
     657             :     OGRSpatialReference *AddSRIDToCache(
     658             :         int nId,
     659             :         std::unique_ptr<OGRSpatialReference, OGRSpatialReferenceReleaser>
     660             :             &&poSRS);
     661             : 
     662             :     bool m_bHaveGeometryColumns = false;
     663             :     bool m_bIsSpatiaLiteDB = false;
     664             :     bool m_bSpatialite4Layout = false;
     665             : 
     666             :     int m_nUndefinedSRID = -1;
     667             : 
     668             :     virtual void DeleteLayer(const char *pszLayer);
     669             : 
     670             :     const char *GetSRTEXTColName();
     671             : 
     672             :     bool InitWithEPSG();
     673             : 
     674             :     bool OpenVirtualTable(const char *pszName, const char *pszSQL);
     675             : 
     676             :     GIntBig m_nFileTimestamp = 0;
     677             :     bool m_bLastSQLCommandIsUpdateLayerStatistics = false;
     678             : 
     679             :     std::map<CPLString, std::set<CPLString>> m_aoMapTableToSetOfGeomCols{};
     680             : 
     681             :     void SaveStatistics();
     682             : 
     683             :     std::vector<std::unique_ptr<OGRLayer>> m_apoInvisibleLayers{};
     684             : 
     685             : #ifdef HAVE_RASTERLITE2
     686             :     void *m_hRL2Ctxt = nullptr;
     687             :     bool InitRasterLite2();
     688             :     void FinishRasterLite2();
     689             : 
     690             :     CPLString m_osCoverageName{};
     691             :     GIntBig m_nSectionId = -1;
     692             :     rl2CoveragePtr m_pRL2Coverage = nullptr;
     693             :     bool m_bRL2MixedResolutions = false;
     694             : #endif
     695             :     CPLStringList m_aosSubDatasets{};
     696             :     bool m_bGeoTransformValid = false;
     697             :     double m_adfGeoTransform[6];
     698             :     OGRSpatialReference m_oSRS{};
     699             :     bool m_bPromote1BitAs8Bit = false;
     700             :     bool OpenRaster();
     701             :     bool OpenRasterSubDataset(const char *pszConnectionId);
     702             :     OGRSQLiteDataSource *m_poParentDS = nullptr;
     703             :     std::vector<OGRSQLiteDataSource *> m_apoOverviewDS{};
     704             : 
     705             :     OGR2SQLITEModule *m_poSQLiteModule = nullptr;
     706             : 
     707             : #ifdef HAVE_RASTERLITE2
     708             :     void ListOverviews();
     709             :     void CreateRL2OverviewDatasetIfNeeded(double dfXRes, double dfYRes);
     710             : #endif
     711             : 
     712             :     bool OpenOrCreateDB(int flags, bool bRegisterOGR2SQLiteExtensions);
     713             : 
     714             :     CPLErr Close() override;
     715             : 
     716             :     void PostInitSpatialite();
     717             : 
     718             :     CPL_DISALLOW_COPY_ASSIGN(OGRSQLiteDataSource)
     719             : 
     720             :   public:
     721             :     OGRSQLiteDataSource();
     722             :     virtual ~OGRSQLiteDataSource();
     723             : 
     724             :     bool Open(GDALOpenInfo *poOpenInfo);
     725             :     bool Create(const char *, char **papszOptions);
     726             : 
     727             :     bool OpenTable(const char *pszTableName, bool IsTable, bool bIsVirtualShape,
     728             :                    bool bMayEmitError);
     729             :     bool OpenView(const char *pszViewName, const char *pszViewGeometry,
     730             :                   const char *pszViewRowid, const char *pszTableName,
     731             :                   const char *pszGeometryColumn);
     732             : 
     733       22969 :     virtual int GetLayerCount() override
     734             :     {
     735       22969 :         return static_cast<int>(m_apoLayers.size());
     736             :     }
     737             : 
     738             :     virtual OGRLayer *GetLayer(int) override;
     739             :     virtual OGRLayer *GetLayerByName(const char *) override;
     740             :     virtual bool IsLayerPrivate(int) const override;
     741             :     OGRLayer *GetLayerByNameNotVisible(const char *);
     742             :     virtual std::pair<OGRLayer *, IOGRSQLiteGetSpatialWhere *>
     743             :     GetLayerWithGetSpatialWhereByName(const char *pszName) override;
     744             : 
     745             :     virtual OGRLayer *ICreateLayer(const char *pszName,
     746             :                                    const OGRGeomFieldDefn *poGeomFieldDefn,
     747             :                                    CSLConstList papszOptions) override;
     748             :     virtual OGRErr DeleteLayer(int) override;
     749             : 
     750             :     virtual int TestCapability(const char *) override;
     751             : 
     752             :     virtual OGRLayer *ExecuteSQL(const char *pszSQLCommand,
     753             :                                  OGRGeometry *poSpatialFilter,
     754             :                                  const char *pszDialect) override;
     755             :     virtual void ReleaseResultSet(OGRLayer *poLayer) override;
     756             : 
     757             :     virtual CPLErr FlushCache(bool bAtClosing) override;
     758             : 
     759             :     virtual OGRErr StartTransaction(int bForce = FALSE) override;
     760             :     virtual OGRErr CommitTransaction() override;
     761             :     virtual OGRErr RollbackTransaction() override;
     762             : 
     763             :     virtual char **GetMetadata(const char *pszDomain = "") override;
     764             : 
     765             :     virtual CPLErr GetGeoTransform(double *padfGeoTransform) override;
     766             :     const OGRSpatialReference *GetSpatialRef() const override;
     767             : 
     768             :     static char *LaunderName(const char *);
     769             :     int FetchSRSId(const OGRSpatialReference *poSRS);
     770             :     OGRSpatialReference *FetchSRS(int nSRID);
     771             : 
     772           1 :     void DisableUpdate()
     773             :     {
     774           1 :         eAccess = GA_ReadOnly;
     775           1 :     }
     776             : 
     777             :     void SetName(const char *pszNameIn);
     778             : 
     779         789 :     const std::set<CPLString> &GetGeomColsForTable(const char *pszTableName)
     780             :     {
     781         789 :         return m_aoMapTableToSetOfGeomCols[pszTableName];
     782             :     }
     783             : 
     784          10 :     GIntBig GetFileTimestamp() const
     785             :     {
     786          10 :         return m_nFileTimestamp;
     787             :     }
     788             : 
     789        4140 :     bool IsSpatialiteDB() const
     790             :     {
     791        4140 :         return m_bIsSpatiaLiteDB;
     792             :     }
     793             : 
     794        3282 :     bool HasSpatialite4Layout() const
     795             :     {
     796        3282 :         return m_bSpatialite4Layout;
     797             :     }
     798             : 
     799         901 :     int GetUndefinedSRID() const
     800             :     {
     801         901 :         return m_nUndefinedSRID;
     802             :     }
     803             : 
     804         428 :     bool HasGeometryColumns() const
     805             :     {
     806         428 :         return m_bHaveGeometryColumns;
     807             :     }
     808             : 
     809             :     bool AddRelationship(std::unique_ptr<GDALRelationship> &&relationship,
     810             :                          std::string &failureReason) override;
     811             :     bool ValidateRelationship(const GDALRelationship *poRelationship,
     812             :                               std::string &failureReason);
     813             : 
     814             :     void ReloadLayers();
     815             : 
     816             : #ifdef HAVE_RASTERLITE2
     817             :     void *GetRL2Context() const
     818             :     {
     819             :         return m_hRL2Ctxt;
     820             :     }
     821             : 
     822             :     rl2CoveragePtr GetRL2CoveragePtr() const
     823             :     {
     824             :         return m_pRL2Coverage;
     825             :     }
     826             : 
     827             :     GIntBig GetSectionId() const
     828             :     {
     829             :         return m_nSectionId;
     830             :     }
     831             : 
     832             :     const double *GetGeoTransform() const
     833             :     {
     834             :         return m_adfGeoTransform;
     835             :     }
     836             : 
     837             :     bool IsRL2MixedResolutions() const
     838             :     {
     839             :         return m_bRL2MixedResolutions;
     840             :     }
     841             : 
     842             :     virtual CPLErr IBuildOverviews(const char *, int, const int *, int,
     843             :                                    const int *, GDALProgressFunc, void *,
     844             :                                    CSLConstList papszOptions) override;
     845             : 
     846             : #endif
     847             :     OGRSQLiteDataSource *GetParentDS() const
     848             :     {
     849             :         return m_poParentDS;
     850             :     }
     851             : 
     852             :     const std::vector<OGRSQLiteDataSource *> &GetOverviews() const
     853             :     {
     854             :         return m_apoOverviewDS;
     855             :     }
     856             : 
     857             :     bool HasPromote1BitAS8Bit() const
     858             :     {
     859             :         return m_bPromote1BitAs8Bit;
     860             :     }
     861             : };
     862             : 
     863             : #ifdef HAVE_RASTERLITE2
     864             : /************************************************************************/
     865             : /*                           RL2RasterBand                              */
     866             : /************************************************************************/
     867             : 
     868             : class RL2RasterBand final : public GDALPamRasterBand
     869             : {
     870             :     bool m_bHasNoData = false;
     871             :     double m_dfNoDataValue = 0;
     872             :     GDALColorInterp m_eColorInterp = GCI_Undefined;
     873             :     GDALColorTable *m_poCT = nullptr;
     874             : 
     875             :     CPL_DISALLOW_COPY_ASSIGN(RL2RasterBand)
     876             : 
     877             :   public:
     878             :     RL2RasterBand(int nBandIn, int nPixelType, GDALDataType eDT, int nBits,
     879             :                   bool bPromote1BitAs8Bit, int nBlockXSizeIn, int nBlockYSizeIn,
     880             :                   bool bHasNoDataIn, double dfNoDataValueIn);
     881             :     explicit RL2RasterBand(const RL2RasterBand *poOther);
     882             : 
     883             :     virtual ~RL2RasterBand();
     884             : 
     885             :   protected:
     886             :     virtual CPLErr IReadBlock(int, int, void *) override;
     887             : 
     888             :     virtual GDALColorInterp GetColorInterpretation() override
     889             :     {
     890             :         return m_eColorInterp;
     891             :     }
     892             : 
     893             :     virtual double GetNoDataValue(int *pbSuccess = nullptr) override;
     894             :     virtual GDALColorTable *GetColorTable() override;
     895             :     virtual int GetOverviewCount() override;
     896             :     virtual GDALRasterBand *GetOverview(int) override;
     897             : };
     898             : #endif  // HAVE_RASTERLITE2
     899             : 
     900             : CPLString OGRSQLiteFieldDefnToSQliteFieldDefn(OGRFieldDefn *poFieldDefn,
     901             :                                               bool bSQLiteDialectInternalUse,
     902             :                                               bool bStrict);
     903             : 
     904             : void OGRSQLiteRegisterInflateDeflate(sqlite3 *hDB);
     905             : 
     906             : void OGRSQLiteDriverUnload(GDALDriver *);
     907             : 
     908             : #ifdef HAVE_RASTERLITE2
     909             : GDALDataset *OGRSQLiteDriverCreateCopy(const char *, GDALDataset *, int,
     910             :                                        char **, GDALProgressFunc pfnProgress,
     911             :                                        void *pProgressData);
     912             : #endif
     913             : 
     914             : #endif /* ndef OGR_SQLITE_H_INCLUDED */

Generated by: LCOV version 1.14