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 2144 : virtual OGRFeatureDefn *GetLayerDefn() override
218 : {
219 2144 : 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 : virtual OGRErr GetExtent(OGREnvelope *psExtent, int bForce) override;
361 : virtual OGRErr GetExtent(int iGeomField, OGREnvelope *psExtent,
362 : int bForce) override;
363 :
364 : virtual OGRFeatureDefn *GetLayerDefn() override;
365 :
366 6131 : bool HasLayerDefnError()
367 : {
368 6131 : GetLayerDefn();
369 6131 : return m_bLayerDefnError;
370 : }
371 :
372 : virtual void SetSpatialFilter(OGRGeometry *) override;
373 : virtual void SetSpatialFilter(int iGeomField, 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 393 : void SetLaunderFlag(bool bFlag)
400 : {
401 393 : m_bLaunderColumnNames = bFlag;
402 393 : }
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 393 : void SetStrictFlag(bool bFlag)
417 : {
418 393 : m_bStrict = bFlag;
419 393 : }
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 13732 : virtual bool IsTableLayer() override
434 : {
435 13732 : 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 void SetSpatialFilter(OGRGeometry *) override;
508 :
509 0 : virtual void SetSpatialFilter(int iGeomField, OGRGeometry *poGeom) override
510 : {
511 0 : OGRSQLiteLayer::SetSpatialFilter(iGeomField, poGeom);
512 0 : }
513 :
514 : virtual OGRErr SetAttributeFilter(const char *) override;
515 :
516 : virtual OGRFeature *GetFeature(GIntBig nFeatureId) override;
517 :
518 : virtual int TestCapability(const char *) override;
519 :
520 0 : virtual bool HasSpatialIndex(CPL_UNUSED int iGeomField) override
521 : {
522 0 : return m_bHasSpatialIndex;
523 : }
524 :
525 : virtual CPLString GetSpatialWhere(int iGeomCol,
526 : OGRGeometry *poFilterGeom) override;
527 : };
528 :
529 : /************************************************************************/
530 : /* OGRSQLiteSelectLayer */
531 : /************************************************************************/
532 :
533 : class OGRSQLiteSelectLayer CPL_NON_FINAL : public OGRSQLiteLayer,
534 : public IOGRSQLiteSelectLayer
535 : {
536 : OGRSQLiteSelectLayerCommonBehaviour *m_poBehavior = nullptr;
537 : bool m_bCanReopenBaseDS = false;
538 :
539 : virtual OGRErr ResetStatement() override;
540 :
541 : CPL_DISALLOW_COPY_ASSIGN(OGRSQLiteSelectLayer)
542 :
543 : public:
544 : OGRSQLiteSelectLayer(OGRSQLiteDataSource *, const CPLString &osSQL,
545 : sqlite3_stmt *, bool bUseStatementForGetNextFeature,
546 : bool bEmptyLayer, bool bAllowMultipleGeomFields,
547 : bool bCanReopenBaseDS);
548 : virtual ~OGRSQLiteSelectLayer();
549 :
550 : virtual void ResetReading() override;
551 :
552 : virtual OGRFeature *GetNextFeature() override;
553 : virtual GIntBig GetFeatureCount(int) override;
554 :
555 117 : virtual void SetSpatialFilter(OGRGeometry *poGeom) override
556 : {
557 117 : SetSpatialFilter(0, poGeom);
558 117 : }
559 :
560 : virtual void SetSpatialFilter(int iGeomField, OGRGeometry *) override;
561 : virtual OGRErr SetAttributeFilter(const char *) override;
562 :
563 : virtual int TestCapability(const char *) override;
564 :
565 2 : virtual OGRErr GetExtent(OGREnvelope *psExtent, int bForce = TRUE) override
566 : {
567 2 : return GetExtent(0, psExtent, bForce);
568 : }
569 :
570 : virtual OGRErr GetExtent(int iGeomField, OGREnvelope *psExtent,
571 : int bForce = TRUE) override;
572 :
573 2144 : virtual OGRFeatureDefn *GetLayerDefn() override
574 : {
575 2144 : return OGRSQLiteLayer::GetLayerDefn();
576 : }
577 :
578 725 : virtual char *&GetAttrQueryString() override
579 : {
580 725 : return m_pszAttrQueryString;
581 : }
582 :
583 281 : virtual OGRFeatureQuery *&GetFeatureQuery() override
584 : {
585 281 : return m_poAttrQuery;
586 : }
587 :
588 533 : virtual OGRGeometry *&GetFilterGeom() override
589 : {
590 533 : return m_poFilterGeom;
591 : }
592 :
593 270 : virtual int &GetIGeomFieldFilter() override
594 : {
595 270 : return m_iGeomFieldFilter;
596 : }
597 :
598 348 : virtual OGRSpatialReference *GetSpatialRef() override
599 : {
600 348 : return OGRSQLiteLayer::GetSpatialRef();
601 : }
602 :
603 163 : virtual int InstallFilter(OGRGeometry *poGeomIn) override
604 : {
605 163 : return OGRSQLiteLayer::InstallFilter(poGeomIn);
606 : }
607 :
608 628 : virtual int HasReadFeature() override
609 : {
610 628 : return m_iNextShapeId > 0;
611 : }
612 :
613 402 : virtual void BaseResetReading() override
614 : {
615 402 : OGRSQLiteLayer::ResetReading();
616 402 : }
617 :
618 3224 : virtual OGRFeature *BaseGetNextFeature() override
619 : {
620 3224 : return OGRSQLiteLayer::GetNextFeature();
621 : }
622 :
623 2 : virtual OGRErr BaseSetAttributeFilter(const char *pszQuery) override
624 : {
625 2 : return OGRSQLiteLayer::SetAttributeFilter(pszQuery);
626 : }
627 :
628 47 : virtual GIntBig BaseGetFeatureCount(int bForce) override
629 : {
630 47 : return OGRSQLiteLayer::GetFeatureCount(bForce);
631 : }
632 :
633 50 : virtual int BaseTestCapability(const char *pszCap) override
634 : {
635 50 : return OGRSQLiteLayer::TestCapability(pszCap);
636 : }
637 :
638 5 : virtual OGRErr BaseGetExtent(OGREnvelope *psExtent, int bForce) override
639 : {
640 5 : return OGRSQLiteLayer::GetExtent(psExtent, bForce);
641 : }
642 :
643 0 : virtual OGRErr BaseGetExtent(int iGeomField, OGREnvelope *psExtent,
644 : int bForce) override
645 : {
646 0 : return OGRSQLiteLayer::GetExtent(iGeomField, psExtent, bForce);
647 : }
648 :
649 : bool
650 171 : ValidateGeometryFieldIndexForSetSpatialFilter(int iGeomField,
651 : const OGRGeometry *poGeomIn,
652 : bool bIsSelectLayer) override
653 : {
654 171 : return OGRSQLiteLayer::ValidateGeometryFieldIndexForSetSpatialFilter(
655 171 : iGeomField, poGeomIn, bIsSelectLayer);
656 : }
657 : };
658 :
659 : /************************************************************************/
660 : /* OGRSQLiteDataSource */
661 : /************************************************************************/
662 :
663 : class OGR2SQLITEModule;
664 :
665 : class OGRSQLiteDataSource final : public OGRSQLiteBaseDataSource
666 : {
667 : std::vector<std::unique_ptr<OGRSQLiteLayer>> m_apoLayers{};
668 :
669 : // We maintain a list of known SRID to reduce the number of trips to
670 : // the database to get SRSes.
671 : std::map<int,
672 : std::unique_ptr<OGRSpatialReference, OGRSpatialReferenceReleaser>>
673 : m_oSRSCache{};
674 :
675 : OGRSpatialReference *AddSRIDToCache(
676 : int nId,
677 : std::unique_ptr<OGRSpatialReference, OGRSpatialReferenceReleaser>
678 : &&poSRS);
679 :
680 : bool m_bHaveGeometryColumns = false;
681 : bool m_bIsSpatiaLiteDB = false;
682 : bool m_bSpatialite4Layout = false;
683 :
684 : int m_nUndefinedSRID = -1;
685 :
686 : virtual void DeleteLayer(const char *pszLayer);
687 :
688 : const char *GetSRTEXTColName();
689 :
690 : bool InitWithEPSG();
691 :
692 : bool OpenVirtualTable(const char *pszName, const char *pszSQL);
693 :
694 : GIntBig m_nFileTimestamp = 0;
695 : bool m_bLastSQLCommandIsUpdateLayerStatistics = false;
696 :
697 : std::map<CPLString, std::set<CPLString>> m_aoMapTableToSetOfGeomCols{};
698 :
699 : void SaveStatistics();
700 :
701 : std::vector<std::unique_ptr<OGRLayer>> m_apoInvisibleLayers{};
702 :
703 : #ifdef HAVE_RASTERLITE2
704 : void *m_hRL2Ctxt = nullptr;
705 : bool InitRasterLite2();
706 : void FinishRasterLite2();
707 :
708 : CPLString m_osCoverageName{};
709 : GIntBig m_nSectionId = -1;
710 : rl2CoveragePtr m_pRL2Coverage = nullptr;
711 : bool m_bRL2MixedResolutions = false;
712 : #endif
713 : CPLStringList m_aosSubDatasets{};
714 : bool m_bGeoTransformValid = false;
715 : double m_adfGeoTransform[6];
716 : OGRSpatialReference m_oSRS{};
717 : bool m_bPromote1BitAs8Bit = false;
718 : bool OpenRaster();
719 : bool OpenRasterSubDataset(const char *pszConnectionId);
720 : OGRSQLiteDataSource *m_poParentDS = nullptr;
721 : std::vector<OGRSQLiteDataSource *> m_apoOverviewDS{};
722 :
723 : OGR2SQLITEModule *m_poSQLiteModule = nullptr;
724 :
725 : #ifdef HAVE_RASTERLITE2
726 : void ListOverviews();
727 : void CreateRL2OverviewDatasetIfNeeded(double dfXRes, double dfYRes);
728 : #endif
729 :
730 : bool OpenOrCreateDB(int flags, bool bRegisterOGR2SQLiteExtensions);
731 :
732 : CPLErr Close() override;
733 :
734 : void PostInitSpatialite();
735 :
736 : CPL_DISALLOW_COPY_ASSIGN(OGRSQLiteDataSource)
737 :
738 : public:
739 : OGRSQLiteDataSource();
740 : virtual ~OGRSQLiteDataSource();
741 :
742 : bool Open(GDALOpenInfo *poOpenInfo);
743 : bool Create(const char *, char **papszOptions);
744 :
745 : bool OpenTable(const char *pszTableName, bool IsTable, bool bIsVirtualShape,
746 : bool bMayEmitError);
747 : bool OpenView(const char *pszViewName, const char *pszViewGeometry,
748 : const char *pszViewRowid, const char *pszTableName,
749 : const char *pszGeometryColumn);
750 :
751 19611 : virtual int GetLayerCount() override
752 : {
753 19611 : return static_cast<int>(m_apoLayers.size());
754 : }
755 :
756 : virtual OGRLayer *GetLayer(int) override;
757 : virtual OGRLayer *GetLayerByName(const char *) override;
758 : virtual bool IsLayerPrivate(int) const override;
759 : OGRLayer *GetLayerByNameNotVisible(const char *);
760 : virtual std::pair<OGRLayer *, IOGRSQLiteGetSpatialWhere *>
761 : GetLayerWithGetSpatialWhereByName(const char *pszName) override;
762 :
763 : virtual OGRLayer *ICreateLayer(const char *pszName,
764 : const OGRGeomFieldDefn *poGeomFieldDefn,
765 : CSLConstList papszOptions) override;
766 : virtual OGRErr DeleteLayer(int) override;
767 :
768 : virtual int TestCapability(const char *) override;
769 :
770 : virtual OGRLayer *ExecuteSQL(const char *pszSQLCommand,
771 : OGRGeometry *poSpatialFilter,
772 : const char *pszDialect) override;
773 : virtual void ReleaseResultSet(OGRLayer *poLayer) override;
774 :
775 : virtual CPLErr FlushCache(bool bAtClosing) override;
776 :
777 : virtual OGRErr StartTransaction(int bForce = FALSE) override;
778 : virtual OGRErr CommitTransaction() override;
779 : virtual OGRErr RollbackTransaction() override;
780 : bool IsInTransaction() const;
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 757 : const std::set<CPLString> &GetGeomColsForTable(const char *pszTableName)
799 : {
800 757 : return m_aoMapTableToSetOfGeomCols[pszTableName];
801 : }
802 :
803 10 : GIntBig GetFileTimestamp() const
804 : {
805 10 : return m_nFileTimestamp;
806 : }
807 :
808 3775 : bool IsSpatialiteDB() const
809 : {
810 3775 : return m_bIsSpatiaLiteDB;
811 : }
812 :
813 3247 : bool HasSpatialite4Layout() const
814 : {
815 3247 : return m_bSpatialite4Layout;
816 : }
817 :
818 866 : int GetUndefinedSRID() const
819 : {
820 866 : return m_nUndefinedSRID;
821 : }
822 :
823 393 : bool HasGeometryColumns() const
824 : {
825 393 : 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 */
|
