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 */
|
