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 : mutable 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 : ~OGRSQLiteLayer() override;
206 :
207 : void Finalize();
208 :
209 : GDALDataset *GetDataset() override;
210 :
211 : void ResetReading() override;
212 : virtual OGRFeature *GetNextRawFeature();
213 : OGRFeature *GetNextFeature() override;
214 :
215 : OGRFeature *GetFeature(GIntBig nFeatureId) override;
216 :
217 : using OGRLayer::GetLayerDefn;
218 :
219 1643 : const OGRFeatureDefn *GetLayerDefn() const override
220 : {
221 1643 : return m_poFeatureDefn;
222 : }
223 :
224 23 : OGRSQLiteFeatureDefn *myGetLayerDefn()
225 : {
226 23 : return m_poFeatureDefn;
227 : }
228 :
229 6 : const OGRSQLiteFeatureDefn *myGetLayerDefn() const
230 : {
231 6 : return m_poFeatureDefn;
232 : }
233 :
234 : const char *GetFIDColumn() const override;
235 :
236 : int TestCapability(const char *) const override;
237 :
238 : OGRErr StartTransaction() override;
239 : OGRErr CommitTransaction() override;
240 : OGRErr RollbackTransaction() override;
241 :
242 1 : virtual void InvalidateCachedFeatureCountAndExtent()
243 : {
244 1 : }
245 :
246 17 : virtual bool IsTableLayer()
247 : {
248 17 : return false;
249 : }
250 :
251 0 : virtual bool HasSpatialIndex(int /*iGeomField*/) const
252 : {
253 0 : return false;
254 : }
255 :
256 0 : bool HasFastSpatialFilter(CPL_UNUSED int iGeomCol) override
257 : {
258 0 : return false;
259 : }
260 :
261 : virtual CPLString
262 0 : GetSpatialWhere(CPL_UNUSED int iGeomCol,
263 : CPL_UNUSED OGRGeometry *poFilterGeom) override
264 : {
265 0 : return "";
266 : }
267 :
268 : static OGRErr GetSpatialiteGeometryHeader(const GByte *pabyData, int nBytes,
269 : int *pnSRID,
270 : OGRwkbGeometryType *peType,
271 : bool *pbIsEmpty, double *pdfMinX,
272 : double *pdfMinY, double *pdfMaxX,
273 : double *pdfMaxY);
274 : static OGRErr ImportSpatiaLiteGeometry(const GByte *, int, OGRGeometry **);
275 : static OGRErr ImportSpatiaLiteGeometry(const GByte *, int, OGRGeometry **,
276 : int *pnSRID);
277 : static OGRErr ExportSpatiaLiteGeometry(const OGRGeometry *, GInt32,
278 : OGRwkbByteOrder, bool,
279 : bool bUseComprGeom, GByte **, int *);
280 : };
281 :
282 : /************************************************************************/
283 : /* OGRSQLiteTableLayer */
284 : /************************************************************************/
285 :
286 : class OGRSQLiteTableLayer final : public OGRSQLiteLayer
287 : {
288 : bool m_bIsTable = true;
289 :
290 : bool m_bLaunderColumnNames = true;
291 : bool m_bSpatialite2D = false;
292 : bool m_bStrict = false;
293 :
294 : CPLString m_osWHERE{};
295 : CPLString m_osQuery{};
296 : bool m_bDeferredSpatialIndexCreation = false;
297 :
298 : char *m_pszTableName = nullptr;
299 : char *m_pszEscapedTableName = nullptr;
300 :
301 : mutable bool m_bLayerDefnError = false;
302 :
303 : sqlite3_stmt *m_hInsertStmt = nullptr;
304 : CPLString m_osLastInsertStmt{};
305 :
306 : bool m_bHasCheckedTriggers = false;
307 : bool m_bHasTriedDetectingFID64 = false;
308 :
309 : bool m_bStatisticsNeedsToBeFlushed = false;
310 : GIntBig m_nFeatureCount = -1; /* if -1, means not up-to-date */
311 :
312 : int m_bDeferredCreation = false;
313 :
314 : char *m_pszCreationGeomFormat = nullptr;
315 : int m_iFIDAsRegularColumnIndex = -1;
316 :
317 : void ClearInsertStmt();
318 :
319 : void BuildWhere();
320 :
321 : OGRErr ResetStatement() override;
322 :
323 : void BuildLayerDefn();
324 :
325 : OGRErr RecomputeOrdinals();
326 :
327 : void AddColumnDef(char *pszNewFieldList, size_t nBufLen,
328 : OGRFieldDefn *poFldDefn);
329 :
330 : void InitFieldListForRecrerate(char *&pszNewFieldList,
331 : char *&pszFieldListForSelect,
332 : size_t &nBufLenOut, int nExtraSpace = 0);
333 : OGRErr RecreateTable(const char *pszFieldListForSelect,
334 : const char *pszNewFieldList,
335 : const char *pszGenericErrorMessage,
336 : const char *pszAdditionalDef = nullptr);
337 : OGRErr BindValues(OGRFeature *poFeature, sqlite3_stmt *hStmt,
338 : bool bBindUnsetAsNull);
339 :
340 : bool CheckSpatialIndexTable(int iGeomCol);
341 :
342 : CPLErr EstablishFeatureDefn(const char *pszGeomCol, bool bMayEmitError);
343 :
344 : void LoadStatistics();
345 : void LoadStatisticsSpatialite4DB();
346 :
347 : CPLString FieldDefnToSQliteFieldDefn(OGRFieldDefn *poFieldDefn);
348 :
349 : OGRErr RunAddGeometryColumn(const OGRSQLiteGeomFieldDefn *poGeomField,
350 : bool bAddColumnsForNonSpatialite);
351 :
352 : CPL_DISALLOW_COPY_ASSIGN(OGRSQLiteTableLayer)
353 :
354 : public:
355 : explicit OGRSQLiteTableLayer(OGRSQLiteDataSource *);
356 : ~OGRSQLiteTableLayer() override;
357 :
358 : CPLErr Initialize(const char *pszTableName, bool bIsTable,
359 : bool bIsVirtualShapeIn, bool bDeferredCreation,
360 : bool bMayEmitError);
361 : void SetCreationParameters(const char *pszFIDColumnName,
362 : OGRwkbGeometryType eGeomType,
363 : const char *pszGeomFormat,
364 : const char *pszGeometryName,
365 : OGRSpatialReference *poSRS, int nSRSId);
366 : const char *GetName() const override;
367 :
368 : GIntBig GetFeatureCount(int) override;
369 :
370 : OGRErr IGetExtent(int iGeomField, OGREnvelope *psExtent,
371 : bool bForce) override;
372 :
373 : const OGRFeatureDefn *GetLayerDefn() const override;
374 :
375 11331 : bool HasLayerDefnError() const
376 : {
377 11331 : GetLayerDefn();
378 11331 : return m_bLayerDefnError;
379 : }
380 :
381 : virtual OGRErr ISetSpatialFilter(int iGeomField,
382 : const OGRGeometry *) override;
383 : OGRErr SetAttributeFilter(const char *) override;
384 : OGRErr ISetFeature(OGRFeature *poFeature) override;
385 : OGRErr DeleteFeature(GIntBig nFID) override;
386 : OGRErr ICreateFeature(OGRFeature *poFeature) override;
387 :
388 : virtual OGRErr CreateField(const OGRFieldDefn *poField,
389 : int bApproxOK = TRUE) override;
390 : virtual OGRErr CreateGeomField(const OGRGeomFieldDefn *poGeomFieldIn,
391 : int bApproxOK = TRUE) override;
392 : OGRErr DeleteField(int iField) override;
393 : OGRErr ReorderFields(int *panMap) override;
394 : virtual OGRErr AlterFieldDefn(int iField, OGRFieldDefn *poNewFieldDefn,
395 : int nFlags) override;
396 : OGRErr AddForeignKeysToTable(const char *pszKeys);
397 :
398 : OGRFeature *GetNextFeature() override;
399 : OGRFeature *GetFeature(GIntBig nFeatureId) override;
400 :
401 : int TestCapability(const char *) const override;
402 :
403 : char **GetMetadata(const char *pszDomain = "") override;
404 : virtual const char *GetMetadataItem(const char *pszName,
405 : const char *pszDomain = "") override;
406 :
407 : // follow methods are not base class overrides
408 436 : void SetLaunderFlag(bool bFlag)
409 : {
410 436 : m_bLaunderColumnNames = bFlag;
411 436 : }
412 :
413 47 : void SetUseCompressGeom(bool bFlag)
414 : {
415 47 : m_bUseComprGeom = bFlag;
416 47 : }
417 :
418 149 : void SetDeferredSpatialIndexCreation(bool bFlag)
419 : {
420 149 : m_bDeferredSpatialIndexCreation = bFlag;
421 149 : }
422 :
423 : void SetCompressedColumns(const char *pszCompressedColumns);
424 :
425 436 : void SetStrictFlag(bool bFlag)
426 : {
427 436 : m_bStrict = bFlag;
428 436 : }
429 :
430 : int CreateSpatialIndex(int iGeomCol);
431 :
432 : void CreateSpatialIndexIfNecessary();
433 :
434 : void InitFeatureCount();
435 : bool DoStatisticsNeedToBeFlushed();
436 : void ForceStatisticsToBeFlushed();
437 : bool AreStatisticsValid();
438 : int SaveStatistics();
439 :
440 : void InvalidateCachedFeatureCountAndExtent() override;
441 :
442 11509 : bool IsTableLayer() override
443 : {
444 11509 : return true;
445 : }
446 :
447 : bool HasSpatialIndex(int iGeomField) const override;
448 : bool HasFastSpatialFilter(int iGeomCol) override;
449 : virtual CPLString GetSpatialWhere(int iGeomCol,
450 : OGRGeometry *poFilterGeom) override;
451 :
452 : OGRErr RunDeferredCreationIfNecessary();
453 : };
454 :
455 : /************************************************************************/
456 : /* OGRSQLiteViewLayer */
457 : /************************************************************************/
458 :
459 : class OGRSQLiteViewLayer final : public OGRSQLiteLayer
460 : {
461 : CPLString m_osWHERE{};
462 : CPLString m_osQuery{};
463 : bool m_bHasCheckedSpatialIndexTable = false;
464 :
465 : OGRSQLiteGeomFormat m_eGeomFormat = OSGF_None;
466 : CPLString m_osGeomColumn{};
467 : bool m_bHasSpatialIndex = false;
468 :
469 : char *m_pszViewName = nullptr;
470 : char *m_pszEscapedTableName = nullptr;
471 : char *m_pszEscapedUnderlyingTableName = nullptr;
472 :
473 : mutable bool m_bLayerDefnError = false;
474 :
475 : CPLString m_osUnderlyingTableName{};
476 : CPLString m_osUnderlyingGeometryColumn{};
477 :
478 : OGRSQLiteLayer *m_poUnderlyingLayer = nullptr;
479 :
480 : OGRSQLiteLayer *GetUnderlyingLayer();
481 :
482 : void BuildLayerDefn();
483 :
484 : void BuildWhere();
485 :
486 : OGRErr ResetStatement() override;
487 :
488 : CPLErr EstablishFeatureDefn();
489 :
490 : CPL_DISALLOW_COPY_ASSIGN(OGRSQLiteViewLayer)
491 :
492 : public:
493 : explicit OGRSQLiteViewLayer(OGRSQLiteDataSource *);
494 : ~OGRSQLiteViewLayer() override;
495 :
496 27 : const char *GetName() const override
497 : {
498 27 : return m_pszViewName;
499 : }
500 :
501 : OGRwkbGeometryType GetGeomType() const override;
502 :
503 : CPLErr Initialize(const char *pszViewName, const char *pszViewGeometry,
504 : const char *pszViewRowid, const char *pszTableName,
505 : const char *pszGeometryColumn);
506 :
507 : const OGRFeatureDefn *GetLayerDefn() const override;
508 :
509 19 : bool HasLayerDefnError() const
510 : {
511 19 : GetLayerDefn();
512 19 : return m_bLayerDefnError;
513 : }
514 :
515 : OGRFeature *GetNextFeature() override;
516 : GIntBig GetFeatureCount(int) override;
517 :
518 : virtual OGRErr ISetSpatialFilter(int iGeomField,
519 : const OGRGeometry *poGeom) override;
520 :
521 : OGRErr SetAttributeFilter(const char *) override;
522 :
523 : OGRFeature *GetFeature(GIntBig nFeatureId) override;
524 :
525 : int TestCapability(const char *) const override;
526 :
527 0 : bool HasSpatialIndex(int) const override
528 : {
529 0 : return m_bHasSpatialIndex;
530 : }
531 :
532 : virtual CPLString GetSpatialWhere(int iGeomCol,
533 : OGRGeometry *poFilterGeom) override;
534 : };
535 :
536 : /************************************************************************/
537 : /* OGRSQLiteSelectLayer */
538 : /************************************************************************/
539 :
540 : class OGRSQLiteSelectLayer CPL_NON_FINAL : public OGRSQLiteLayer,
541 : public IOGRSQLiteSelectLayer
542 : {
543 : OGRSQLiteSelectLayerCommonBehaviour *m_poBehavior = nullptr;
544 : bool m_bCanReopenBaseDS = false;
545 :
546 : OGRErr ResetStatement() override;
547 :
548 : CPL_DISALLOW_COPY_ASSIGN(OGRSQLiteSelectLayer)
549 :
550 : public:
551 : OGRSQLiteSelectLayer(OGRSQLiteDataSource *, const CPLString &osSQL,
552 : sqlite3_stmt *, bool bUseStatementForGetNextFeature,
553 : bool bEmptyLayer, bool bAllowMultipleGeomFields,
554 : bool bCanReopenBaseDS);
555 : ~OGRSQLiteSelectLayer() override;
556 :
557 : void ResetReading() override;
558 :
559 : OGRFeature *GetNextFeature() override;
560 : GIntBig GetFeatureCount(int) override;
561 :
562 : virtual OGRErr ISetSpatialFilter(int iGeomField,
563 : const OGRGeometry *) override;
564 : OGRErr SetAttributeFilter(const char *) override;
565 :
566 : int TestCapability(const char *) const override;
567 :
568 : OGRErr IGetExtent(int iGeomField, OGREnvelope *psExtent,
569 : bool bForce) override;
570 :
571 1643 : const OGRFeatureDefn *GetLayerDefn() const override
572 : {
573 1643 : return OGRSQLiteLayer::GetLayerDefn();
574 : }
575 :
576 725 : char *&GetAttrQueryString() override
577 : {
578 725 : return m_pszAttrQueryString;
579 : }
580 :
581 195 : OGRFeatureQuery *&GetFeatureQuery() override
582 : {
583 195 : return m_poAttrQuery;
584 : }
585 :
586 490 : OGRGeometry *&GetFilterGeom() override
587 : {
588 490 : return m_poFilterGeom;
589 : }
590 :
591 270 : int &GetIGeomFieldFilter() override
592 : {
593 270 : return m_iGeomFieldFilter;
594 : }
595 :
596 354 : const OGRSpatialReference *GetSpatialRef() const override
597 : {
598 354 : return OGRSQLiteLayer::GetSpatialRef();
599 : }
600 :
601 163 : int InstallFilter(const OGRGeometry *poGeomIn) override
602 : {
603 163 : return OGRSQLiteLayer::InstallFilter(poGeomIn);
604 : }
605 :
606 635 : int HasReadFeature() override
607 : {
608 635 : return m_iNextShapeId > 0;
609 : }
610 :
611 406 : void BaseResetReading() override
612 : {
613 406 : OGRSQLiteLayer::ResetReading();
614 406 : }
615 :
616 3099 : OGRFeature *BaseGetNextFeature() override
617 : {
618 3099 : return OGRSQLiteLayer::GetNextFeature();
619 : }
620 :
621 2 : OGRErr BaseSetAttributeFilter(const char *pszQuery) override
622 : {
623 2 : return OGRSQLiteLayer::SetAttributeFilter(pszQuery);
624 : }
625 :
626 47 : GIntBig BaseGetFeatureCount(int bForce) override
627 : {
628 47 : return OGRSQLiteLayer::GetFeatureCount(bForce);
629 : }
630 :
631 54 : int BaseTestCapability(const char *pszCap) const override
632 : {
633 54 : return OGRSQLiteLayer::TestCapability(pszCap);
634 : }
635 :
636 5 : virtual OGRErr BaseGetExtent(int iGeomField, OGREnvelope *psExtent,
637 : bool bForce) override
638 : {
639 5 : return OGRSQLiteLayer::IGetExtent(iGeomField, psExtent, bForce);
640 : }
641 :
642 : bool
643 2 : ValidateGeometryFieldIndexForSetSpatialFilter(int iGeomField,
644 : const OGRGeometry *poGeomIn,
645 : bool bIsSelectLayer) override
646 : {
647 2 : return OGRSQLiteLayer::ValidateGeometryFieldIndexForSetSpatialFilter(
648 2 : iGeomField, poGeomIn, bIsSelectLayer);
649 : }
650 : };
651 :
652 : /************************************************************************/
653 : /* OGRSQLiteDataSource */
654 : /************************************************************************/
655 :
656 : class OGR2SQLITEModule;
657 :
658 1287 : class OGRSQLiteDataSource final : public OGRSQLiteBaseDataSource
659 : {
660 : std::vector<std::unique_ptr<OGRSQLiteLayer>> m_apoLayers{};
661 :
662 : // We maintain a list of known SRID to reduce the number of trips to
663 : // the database to get SRSes.
664 : std::map<int,
665 : std::unique_ptr<OGRSpatialReference, OGRSpatialReferenceReleaser>>
666 : m_oSRSCache{};
667 :
668 : OGRSpatialReference *AddSRIDToCache(
669 : int nId,
670 : std::unique_ptr<OGRSpatialReference, OGRSpatialReferenceReleaser>
671 : &&poSRS);
672 :
673 : bool m_bHaveGeometryColumns = false;
674 : bool m_bIsSpatiaLiteDB = false;
675 : bool m_bSpatialite4Layout = false;
676 :
677 : int m_nUndefinedSRID = -1;
678 :
679 : void DeleteLayer(const char *pszLayer);
680 :
681 : const char *GetSRTEXTColName();
682 :
683 : bool InitWithEPSG();
684 :
685 : bool OpenVirtualTable(const char *pszName, const char *pszSQL);
686 :
687 : GIntBig m_nFileTimestamp = 0;
688 : bool m_bLastSQLCommandIsUpdateLayerStatistics = false;
689 :
690 : std::map<CPLString, std::set<CPLString>> m_aoMapTableToSetOfGeomCols{};
691 :
692 : void SaveStatistics();
693 :
694 : std::vector<std::unique_ptr<OGRLayer>> m_apoInvisibleLayers{};
695 :
696 : #ifdef HAVE_RASTERLITE2
697 : void *m_hRL2Ctxt = nullptr;
698 : bool InitRasterLite2();
699 : void FinishRasterLite2();
700 :
701 : CPLString m_osCoverageName{};
702 : GIntBig m_nSectionId = -1;
703 : rl2CoveragePtr m_pRL2Coverage = nullptr;
704 : bool m_bRL2MixedResolutions = false;
705 : #endif
706 : CPLStringList m_aosSubDatasets{};
707 : bool m_bGeoTransformValid = false;
708 : GDALGeoTransform m_gt{};
709 : OGRSpatialReference m_oSRS{};
710 : bool m_bPromote1BitAs8Bit = false;
711 : bool OpenRaster();
712 : bool OpenRasterSubDataset(const char *pszConnectionId);
713 : OGRSQLiteDataSource *m_poParentDS = nullptr;
714 : std::vector<OGRSQLiteDataSource *> m_apoOverviewDS{};
715 :
716 : OGR2SQLITEModule *m_poSQLiteModule = nullptr;
717 :
718 : #ifdef HAVE_RASTERLITE2
719 : void ListOverviews();
720 : void CreateRL2OverviewDatasetIfNeeded(double dfXRes, double dfYRes);
721 : #endif
722 :
723 : bool OpenOrCreateDB(int flags, bool bRegisterOGR2SQLiteExtensions);
724 :
725 : CPLErr Close() override;
726 :
727 : void PostInitSpatialite();
728 :
729 : CPL_DISALLOW_COPY_ASSIGN(OGRSQLiteDataSource)
730 :
731 : public:
732 : OGRSQLiteDataSource();
733 : ~OGRSQLiteDataSource() override;
734 :
735 : bool Open(GDALOpenInfo *poOpenInfo);
736 : bool Create(const char *, char **papszOptions);
737 :
738 : bool OpenTable(const char *pszTableName, bool IsTable, bool bIsVirtualShape,
739 : bool bMayEmitError);
740 : bool OpenView(const char *pszViewName, const char *pszViewGeometry,
741 : const char *pszViewRowid, const char *pszTableName,
742 : const char *pszGeometryColumn);
743 :
744 20181 : int GetLayerCount() const override
745 : {
746 20181 : return static_cast<int>(m_apoLayers.size());
747 : }
748 :
749 : using GDALDataset::GetLayer;
750 : const OGRLayer *GetLayer(int) const override;
751 : OGRLayer *GetLayerByName(const char *) override;
752 : bool IsLayerPrivate(int) const override;
753 : OGRLayer *GetLayerByNameNotVisible(const char *);
754 : virtual std::pair<OGRLayer *, IOGRSQLiteGetSpatialWhere *>
755 : GetLayerWithGetSpatialWhereByName(const char *pszName) override;
756 :
757 : virtual OGRLayer *ICreateLayer(const char *pszName,
758 : const OGRGeomFieldDefn *poGeomFieldDefn,
759 : CSLConstList papszOptions) override;
760 : OGRErr DeleteLayer(int) override;
761 :
762 : int TestCapability(const char *) const override;
763 :
764 : OGRLayer *ExecuteSQL(const char *pszSQLCommand,
765 : OGRGeometry *poSpatialFilter,
766 : const char *pszDialect) override;
767 : void ReleaseResultSet(OGRLayer *poLayer) override;
768 :
769 : CPLErr FlushCache(bool bAtClosing) override;
770 :
771 : OGRErr StartTransaction(int bForce = FALSE) override;
772 : OGRErr CommitTransaction() override;
773 : OGRErr RollbackTransaction() override;
774 :
775 : char **GetMetadata(const char *pszDomain = "") override;
776 :
777 : CPLErr GetGeoTransform(GDALGeoTransform >) const override;
778 : const OGRSpatialReference *GetSpatialRef() const override;
779 :
780 : static char *LaunderName(const char *);
781 : int FetchSRSId(const OGRSpatialReference *poSRS);
782 : OGRSpatialReference *FetchSRS(int nSRID);
783 :
784 1 : void DisableUpdate()
785 : {
786 1 : eAccess = GA_ReadOnly;
787 1 : }
788 :
789 : void SetName(const char *pszNameIn);
790 :
791 655 : const std::set<CPLString> &GetGeomColsForTable(const char *pszTableName)
792 : {
793 655 : return m_aoMapTableToSetOfGeomCols[pszTableName];
794 : }
795 :
796 3 : GIntBig GetFileTimestamp() const
797 : {
798 3 : return m_nFileTimestamp;
799 : }
800 :
801 3977 : bool IsSpatialiteDB() const
802 : {
803 3977 : return m_bIsSpatiaLiteDB;
804 : }
805 :
806 7916 : bool HasSpatialite4Layout() const
807 : {
808 7916 : return m_bSpatialite4Layout;
809 : }
810 :
811 874 : int GetUndefinedSRID() const
812 : {
813 874 : return m_nUndefinedSRID;
814 : }
815 :
816 436 : bool HasGeometryColumns() const
817 : {
818 436 : return m_bHaveGeometryColumns;
819 : }
820 :
821 : bool AddRelationship(std::unique_ptr<GDALRelationship> &&relationship,
822 : std::string &failureReason) override;
823 : bool ValidateRelationship(const GDALRelationship *poRelationship,
824 : std::string &failureReason);
825 :
826 : void ReloadLayers();
827 :
828 : #ifdef HAVE_RASTERLITE2
829 : void *GetRL2Context() const
830 : {
831 : return m_hRL2Ctxt;
832 : }
833 :
834 : rl2CoveragePtr GetRL2CoveragePtr() const
835 : {
836 : return m_pRL2Coverage;
837 : }
838 :
839 : GIntBig GetSectionId() const
840 : {
841 : return m_nSectionId;
842 : }
843 :
844 : const GDALGeoTransform &GetGeoTransform() const
845 : {
846 : return m_gt;
847 : }
848 :
849 : bool IsRL2MixedResolutions() const
850 : {
851 : return m_bRL2MixedResolutions;
852 : }
853 :
854 : CPLErr IBuildOverviews(const char *, int, const int *, int, const int *,
855 : GDALProgressFunc, void *,
856 : CSLConstList papszOptions) override;
857 :
858 : #endif
859 : OGRSQLiteDataSource *GetParentDS() const
860 : {
861 : return m_poParentDS;
862 : }
863 :
864 : const std::vector<OGRSQLiteDataSource *> &GetOverviews() const
865 : {
866 : return m_apoOverviewDS;
867 : }
868 :
869 : bool HasPromote1BitAS8Bit() const
870 : {
871 : return m_bPromote1BitAs8Bit;
872 : }
873 : };
874 :
875 : #ifdef HAVE_RASTERLITE2
876 : /************************************************************************/
877 : /* RL2RasterBand */
878 : /************************************************************************/
879 :
880 : class RL2RasterBand final : public GDALPamRasterBand
881 : {
882 : bool m_bHasNoData = false;
883 : double m_dfNoDataValue = 0;
884 : GDALColorInterp m_eColorInterp = GCI_Undefined;
885 : GDALColorTable *m_poCT = nullptr;
886 :
887 : CPL_DISALLOW_COPY_ASSIGN(RL2RasterBand)
888 :
889 : public:
890 : RL2RasterBand(int nBandIn, int nPixelType, GDALDataType eDT, int nBits,
891 : bool bPromote1BitAs8Bit, int nBlockXSizeIn, int nBlockYSizeIn,
892 : bool bHasNoDataIn, double dfNoDataValueIn);
893 : explicit RL2RasterBand(const RL2RasterBand *poOther);
894 :
895 : ~RL2RasterBand() override;
896 :
897 : protected:
898 : CPLErr IReadBlock(int, int, void *) override;
899 :
900 : GDALColorInterp GetColorInterpretation() override
901 : {
902 : return m_eColorInterp;
903 : }
904 :
905 : double GetNoDataValue(int *pbSuccess = nullptr) override;
906 : GDALColorTable *GetColorTable() override;
907 : int GetOverviewCount() override;
908 : GDALRasterBand *GetOverview(int) override;
909 : };
910 : #endif // HAVE_RASTERLITE2
911 :
912 : CPLString OGRSQLiteFieldDefnToSQliteFieldDefn(const OGRFieldDefn *poFieldDefn,
913 : bool bSQLiteDialectInternalUse,
914 : bool bStrict);
915 :
916 : void OGRSQLiteRegisterInflateDeflate(sqlite3 *hDB);
917 :
918 : void OGRSQLiteDriverUnload(GDALDriver *);
919 :
920 : #ifdef HAVE_RASTERLITE2
921 : GDALDataset *OGRSQLiteDriverCreateCopy(const char *, GDALDataset *, int,
922 : char **, GDALProgressFunc pfnProgress,
923 : void *pProgressData);
924 : #endif
925 :
926 : #endif /* ndef OGR_SQLITE_H_INCLUDED */
|
