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 1671 : const OGRFeatureDefn *GetLayerDefn() const override
220 : {
221 1671 : return m_poFeatureDefn;
222 : }
223 :
224 27 : OGRSQLiteFeatureDefn *myGetLayerDefn()
225 : {
226 27 : 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 11352 : bool HasLayerDefnError() const
376 : {
377 11352 : GetLayerDefn();
378 11352 : 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 : CSLConstList 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 440 : void SetLaunderFlag(bool bFlag)
409 : {
410 440 : m_bLaunderColumnNames = bFlag;
411 440 : }
412 :
413 47 : void SetUseCompressGeom(bool bFlag)
414 : {
415 47 : m_bUseComprGeom = bFlag;
416 47 : }
417 :
418 151 : void SetDeferredSpatialIndexCreation(bool bFlag)
419 : {
420 151 : m_bDeferredSpatialIndexCreation = bFlag;
421 151 : }
422 :
423 : void SetCompressedColumns(const char *pszCompressedColumns);
424 :
425 440 : void SetStrictFlag(bool bFlag)
426 : {
427 440 : m_bStrict = bFlag;
428 440 : }
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 11298 : bool IsTableLayer() override
443 : {
444 11298 : 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_Unknown;
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 1671 : const OGRFeatureDefn *GetLayerDefn() const override
572 : {
573 1671 : return OGRSQLiteLayer::GetLayerDefn();
574 : }
575 :
576 728 : char *&GetAttrQueryString() override
577 : {
578 728 : return m_pszAttrQueryString;
579 : }
580 :
581 195 : OGRFeatureQuery *&GetFeatureQuery() override
582 : {
583 195 : return m_poAttrQuery;
584 : }
585 :
586 496 : OGRGeometry *&GetFilterGeom() override
587 : {
588 496 : return m_poFilterGeom;
589 : }
590 :
591 278 : int &GetIGeomFieldFilter() override
592 : {
593 278 : return m_iGeomFieldFilter;
594 : }
595 :
596 365 : const OGRSpatialReference *GetSpatialRef() const override
597 : {
598 365 : return OGRSQLiteLayer::GetSpatialRef();
599 : }
600 :
601 168 : int InstallFilter(const OGRGeometry *poGeomIn) override
602 : {
603 168 : return OGRSQLiteLayer::InstallFilter(poGeomIn);
604 : }
605 :
606 646 : int HasReadFeature() override
607 : {
608 646 : return m_iNextShapeId > 0;
609 : }
610 :
611 411 : void BaseResetReading() override
612 : {
613 411 : OGRSQLiteLayer::ResetReading();
614 411 : }
615 :
616 3150 : OGRFeature *BaseGetNextFeature() override
617 : {
618 3150 : 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 58 : int BaseTestCapability(const char *pszCap) const override
632 : {
633 58 : 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 1330 : 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, OGRSpatialReferenceRefCountedPtr> m_oSRSCache{};
665 :
666 : OGRSpatialReference *AddSRIDToCache(int nId,
667 : OGRSpatialReferenceRefCountedPtr poSRS);
668 :
669 : bool m_bHaveGeometryColumns = false;
670 : bool m_bIsSpatiaLiteDB = false;
671 : bool m_bSpatialite4Layout = false;
672 :
673 : int m_nUndefinedSRID = -1;
674 :
675 : void DeleteLayer(const char *pszLayer);
676 :
677 : const char *GetSRTEXTColName();
678 :
679 : bool InitWithEPSG();
680 :
681 : bool OpenVirtualTable(const char *pszName, const char *pszSQL);
682 :
683 : GIntBig m_nFileTimestamp = 0;
684 : bool m_bLastSQLCommandIsUpdateLayerStatistics = false;
685 :
686 : std::map<CPLString, std::set<CPLString>> m_aoMapTableToSetOfGeomCols{};
687 :
688 : void SaveStatistics();
689 :
690 : std::vector<std::unique_ptr<OGRLayer>> m_apoInvisibleLayers{};
691 :
692 : #ifdef HAVE_RASTERLITE2
693 : void *m_hRL2Ctxt = nullptr;
694 : bool InitRasterLite2();
695 : void FinishRasterLite2();
696 :
697 : CPLString m_osCoverageName{};
698 : GIntBig m_nSectionId = -1;
699 : rl2CoveragePtr m_pRL2Coverage = nullptr;
700 : bool m_bRL2MixedResolutions = false;
701 : #endif
702 : CPLStringList m_aosSubDatasets{};
703 : bool m_bGeoTransformValid = false;
704 : GDALGeoTransform m_gt{};
705 : OGRSpatialReference m_oSRS{};
706 : bool m_bPromote1BitAs8Bit = false;
707 : bool OpenRaster();
708 : bool OpenRasterSubDataset(const char *pszConnectionId);
709 : OGRSQLiteDataSource *m_poParentDS = nullptr;
710 : std::vector<OGRSQLiteDataSource *> m_apoOverviewDS{};
711 :
712 : OGR2SQLITEModule *m_poSQLiteModule = nullptr;
713 :
714 : #ifdef HAVE_RASTERLITE2
715 : void ListOverviews();
716 : void CreateRL2OverviewDatasetIfNeeded(double dfXRes, double dfYRes);
717 : #endif
718 :
719 : bool OpenOrCreateDB(int flags, bool bRegisterOGR2SQLiteExtensions);
720 :
721 : CPLErr Close(GDALProgressFunc = nullptr, void * = nullptr) override;
722 :
723 : void PostInitSpatialite();
724 :
725 : CPL_DISALLOW_COPY_ASSIGN(OGRSQLiteDataSource)
726 :
727 : public:
728 : OGRSQLiteDataSource();
729 : ~OGRSQLiteDataSource() override;
730 :
731 : bool Open(GDALOpenInfo *poOpenInfo);
732 : bool Create(const char *, CSLConstList papszOptions);
733 :
734 : bool OpenTable(const char *pszTableName, bool IsTable, bool bIsVirtualShape,
735 : bool bMayEmitError);
736 : bool OpenView(const char *pszViewName, const char *pszViewGeometry,
737 : const char *pszViewRowid, const char *pszTableName,
738 : const char *pszGeometryColumn);
739 :
740 10045 : int GetLayerCount() const override
741 : {
742 10045 : return static_cast<int>(m_apoLayers.size());
743 : }
744 :
745 : using GDALDataset::GetLayer;
746 : const OGRLayer *GetLayer(int) const override;
747 : OGRLayer *GetLayerByName(const char *) override;
748 : bool IsLayerPrivate(int) const override;
749 : OGRLayer *GetLayerByNameNotVisible(const char *);
750 : virtual std::pair<OGRLayer *, IOGRSQLiteGetSpatialWhere *>
751 : GetLayerWithGetSpatialWhereByName(const char *pszName) override;
752 :
753 : virtual OGRLayer *ICreateLayer(const char *pszName,
754 : const OGRGeomFieldDefn *poGeomFieldDefn,
755 : CSLConstList papszOptions) override;
756 : OGRErr DeleteLayer(int) override;
757 :
758 : int TestCapability(const char *) const override;
759 :
760 : OGRLayer *ExecuteSQL(const char *pszSQLCommand,
761 : OGRGeometry *poSpatialFilter,
762 : const char *pszDialect) override;
763 : void ReleaseResultSet(OGRLayer *poLayer) override;
764 :
765 : CPLErr FlushCache(bool bAtClosing) override;
766 :
767 : OGRErr StartTransaction(int bForce = FALSE) override;
768 : OGRErr CommitTransaction() override;
769 : OGRErr RollbackTransaction() override;
770 :
771 : CSLConstList GetMetadata(const char *pszDomain = "") override;
772 :
773 : CPLErr GetGeoTransform(GDALGeoTransform >) const override;
774 : const OGRSpatialReference *GetSpatialRef() const override;
775 :
776 : static char *LaunderName(const char *);
777 : int FetchSRSId(const OGRSpatialReference *poSRS);
778 : OGRSpatialReference *FetchSRS(int nSRID);
779 :
780 1 : void DisableUpdate()
781 : {
782 1 : eAccess = GA_ReadOnly;
783 1 : }
784 :
785 : void SetName(const char *pszNameIn);
786 :
787 666 : const std::set<CPLString> &GetGeomColsForTable(const char *pszTableName)
788 : {
789 666 : return m_aoMapTableToSetOfGeomCols[pszTableName];
790 : }
791 :
792 3 : GIntBig GetFileTimestamp() const
793 : {
794 3 : return m_nFileTimestamp;
795 : }
796 :
797 4031 : bool IsSpatialiteDB() const
798 : {
799 4031 : return m_bIsSpatiaLiteDB;
800 : }
801 :
802 7960 : bool HasSpatialite4Layout() const
803 : {
804 7960 : return m_bSpatialite4Layout;
805 : }
806 :
807 896 : int GetUndefinedSRID() const
808 : {
809 896 : return m_nUndefinedSRID;
810 : }
811 :
812 440 : bool HasGeometryColumns() const
813 : {
814 440 : return m_bHaveGeometryColumns;
815 : }
816 :
817 : bool AddRelationship(std::unique_ptr<GDALRelationship> &&relationship,
818 : std::string &failureReason) override;
819 : bool ValidateRelationship(const GDALRelationship *poRelationship,
820 : std::string &failureReason);
821 :
822 : void ReloadLayers();
823 :
824 : #ifdef HAVE_RASTERLITE2
825 : void *GetRL2Context() const
826 : {
827 : return m_hRL2Ctxt;
828 : }
829 :
830 : rl2CoveragePtr GetRL2CoveragePtr() const
831 : {
832 : return m_pRL2Coverage;
833 : }
834 :
835 : GIntBig GetSectionId() const
836 : {
837 : return m_nSectionId;
838 : }
839 :
840 : const GDALGeoTransform &GetGeoTransform() const
841 : {
842 : return m_gt;
843 : }
844 :
845 : bool IsRL2MixedResolutions() const
846 : {
847 : return m_bRL2MixedResolutions;
848 : }
849 :
850 : CPLErr IBuildOverviews(const char *, int, const int *, int, const int *,
851 : GDALProgressFunc, void *,
852 : CSLConstList papszOptions) override;
853 :
854 : #endif
855 : OGRSQLiteDataSource *GetParentDS() const
856 : {
857 : return m_poParentDS;
858 : }
859 :
860 : const std::vector<OGRSQLiteDataSource *> &GetOverviews() const
861 : {
862 : return m_apoOverviewDS;
863 : }
864 :
865 : bool HasPromote1BitAS8Bit() const
866 : {
867 : return m_bPromote1BitAs8Bit;
868 : }
869 : };
870 :
871 : #ifdef HAVE_RASTERLITE2
872 : /************************************************************************/
873 : /* RL2RasterBand */
874 : /************************************************************************/
875 :
876 : class RL2RasterBand final : public GDALPamRasterBand
877 : {
878 : bool m_bHasNoData = false;
879 : double m_dfNoDataValue = 0;
880 : GDALColorInterp m_eColorInterp = GCI_Undefined;
881 : GDALColorTable *m_poCT = nullptr;
882 :
883 : CPL_DISALLOW_COPY_ASSIGN(RL2RasterBand)
884 :
885 : public:
886 : RL2RasterBand(int nBandIn, int nPixelType, GDALDataType eDT, int nBits,
887 : bool bPromote1BitAs8Bit, int nBlockXSizeIn, int nBlockYSizeIn,
888 : bool bHasNoDataIn, double dfNoDataValueIn);
889 : explicit RL2RasterBand(const RL2RasterBand *poOther);
890 :
891 : ~RL2RasterBand() override;
892 :
893 : protected:
894 : CPLErr IReadBlock(int, int, void *) override;
895 :
896 : GDALColorInterp GetColorInterpretation() override
897 : {
898 : return m_eColorInterp;
899 : }
900 :
901 : double GetNoDataValue(int *pbSuccess = nullptr) override;
902 : GDALColorTable *GetColorTable() override;
903 : int GetOverviewCount() override;
904 : GDALRasterBand *GetOverview(int) override;
905 : };
906 : #endif // HAVE_RASTERLITE2
907 :
908 : CPLString OGRSQLiteFieldDefnToSQliteFieldDefn(const OGRFieldDefn *poFieldDefn,
909 : bool bSQLiteDialectInternalUse,
910 : bool bStrict);
911 :
912 : void OGRSQLiteRegisterInflateDeflate(sqlite3 *hDB);
913 :
914 : void OGRSQLiteDriverUnload(GDALDriver *);
915 :
916 : #ifdef HAVE_RASTERLITE2
917 : GDALDataset *OGRSQLiteDriverCreateCopy(const char *, GDALDataset *, int,
918 : CSLConstList,
919 : GDALProgressFunc pfnProgress,
920 : void *pProgressData);
921 : #endif
922 :
923 : #endif /* ndef OGR_SQLITE_H_INCLUDED */
|
