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