-
-
Notifications
You must be signed in to change notification settings - Fork 3k
/
qgsvirtuallayerdefinition.h
199 lines (164 loc) · 7.47 KB
/
qgsvirtuallayerdefinition.h
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
/***************************************************************************
qgsvirtuallayerdefinition.h
begin : Feb, 2015
copyright : (C) 2015 Hugo Mercier, Oslandia
email : hugo dot mercier at oslandia dot com
***************************************************************************/
/***************************************************************************
* *
* This program is free software; you can redistribute it and/or modify *
* it under the terms of the GNU General Public License as published by *
* the Free Software Foundation; either version 2 of the License, or *
* (at your option) any later version. *
* *
***************************************************************************/
#ifndef QGSVIRTUALLAYERDEFINITION_H
#define QGSVIRTUALLAYERDEFINITION_H
#include "qgis_core.h"
#include "qgsfields.h"
#include "qgis.h"
/**
* \ingroup core
* Class to manipulate the definition of a virtual layer
*
* It is used to extract parameters from an initial virtual layer definition as well as
* to store the complete, expanded definition once types have been detected.
*/
class CORE_EXPORT QgsVirtualLayerDefinition
{
public:
/**
* \ingroup core
* A SourceLayer is either a reference to a live layer in the registry
* or all the parameters needed to load it (provider key, source, etc.)
*/
class CORE_EXPORT SourceLayer
{
public:
//! Constructor variant to build a live layer reference
SourceLayer( const QString &name, const QString &ref )
: mName( name )
, mRef( ref )
{}
//! Constructor variant to build a layer with a provider and a source
SourceLayer( const QString &name, const QString &source, const QString &provider, const QString &encoding )
: mName( name )
, mSource( source )
, mProvider( provider )
, mEncoding( encoding )
{}
//! Is it a live layer or not ?
bool isReferenced() const { return !mRef.isEmpty(); }
//! The reference (id) of the live layer
QString reference() const { return mRef; }
//! Name of the layer
QString name() const { return mName; }
//! Provider key
QString provider() const { return mProvider; }
//! The source url used by the provider to build the layer
QString source() const { return mSource; }
//! Optional encoding for the provider
QString encoding() const { return mEncoding; }
private:
QString mName;
QString mSource;
QString mProvider;
QString mRef;
QString mEncoding;
};
//! Constructor with an optional file path
QgsVirtualLayerDefinition( const QString &filePath = "" );
/**
* Constructor to build a definition from a QUrl
* The path part of the URL is extracted as well as the following optional keys:
* layer_ref=layer_id[:name] represents a live layer referenced by its ID. An optional name can be given
* layer=provider:source[:name[:encoding]] represents a layer given by its provider key, its source url (URL-encoded).
* An optional name and encoding can be given
* geometry=column_name[:type:srid] gives the definition of the geometry column.
* Type can be either a WKB type code or a string (point, linestring, etc.)
* srid is an integer
* uid=column_name is the name of a column with unique integer values.
* nogeometry is a flag to force the layer to be a non-geometry layer
* query=sql represents the SQL query. Must be URL-encoded
* field=column_name:[int|real|text] represents a field with its name and its type
*/
static QgsVirtualLayerDefinition fromUrl( const QUrl &url );
//! Convert the definition into a QUrl
QUrl toUrl() const;
//! Convert into a QString that can be read by the virtual layer provider
QString toString() const;
//! Add a live layer source layer
void addSource( const QString &name, const QString &ref );
//! Add a layer with a source, a provider and an encoding
void addSource( const QString &name, const QString &source, const QString &provider, const QString &encoding = "" );
//! List of source layers
typedef QList<QgsVirtualLayerDefinition::SourceLayer> SourceLayers;
//! Get access to the source layers
const QgsVirtualLayerDefinition::SourceLayers &sourceLayers() const { return mSourceLayers; }
//! Get the SQL query
QString query() const { return mQuery; }
//! Set the SQL query
void setQuery( const QString &query ) { mQuery = query; }
//! Get the file path. May be empty
QString filePath() const { return mFilePath; }
//! Set the file path
void setFilePath( const QString &filePath ) { mFilePath = filePath; }
//! Get the name of the field with unique identifiers
QString uid() const { return mUid; }
//! Set the name of the field with unique identifiers
void setUid( const QString &uid ) { mUid = uid; }
/**
* Sets the lazy mode. If \a lazy is true, then the loading is
* delayed until an explicit reloading of the layer.
* \param lazy True to delay the loading, false otherwise
* \since QGIS 3.2
*/
void setLazy( bool lazy ) { mLazy = lazy; }
/**
* Returns the lazy mode.
* \returns True if the loading is delayed, false otherwise.
* \since QGIS 3.2
*/
bool isLazy() const { return mLazy; }
//! Get the name of the geometry field. Empty if no geometry field
QString geometryField() const { return mGeometryField; }
//! Set the name of the geometry field
void setGeometryField( const QString &geometryField ) { mGeometryField = geometryField; }
/**
* Get the type of the geometry
* QgsWkbTypes::NoGeometry to hide any geometry
* QgsWkbTypes::Unknown for unknown types
*/
QgsWkbTypes::Type geometryWkbType() const { return mGeometryWkbType; }
//! Set the type of the geometry
void setGeometryWkbType( QgsWkbTypes::Type t ) { mGeometryWkbType = t; }
//! Get the SRID of the geometry
long geometrySrid() const { return mGeometrySrid; }
//! Set the SRID of the geometry
void setGeometrySrid( long srid ) { mGeometrySrid = srid; }
//! Get field definitions
QgsFields fields() const { return mFields; }
//! Set field definitions
void setFields( const QgsFields &fields ) { mFields = fields; }
//! Convenience method to test if a given source layer is part of the definition
bool hasSourceLayer( const QString &name ) const;
//! Convenience method to test whether the definition has referenced (live) layers
bool hasReferencedLayers() const;
//! Convenient method to test if the geometry is defined (not NoGeometry and not Unknown)
bool hasDefinedGeometry() const
{
return geometryWkbType() != QgsWkbTypes::NoGeometry && geometryWkbType() != QgsWkbTypes::Unknown;
}
private:
SourceLayers mSourceLayers;
QString mQuery;
QString mUid;
QString mGeometryField;
QString mFilePath;
QgsFields mFields;
bool mLazy = false;
QgsWkbTypes::Type mGeometryWkbType = QgsWkbTypes::Unknown;
long mGeometrySrid = 0;
};
// clazy:excludeall=qstring-allocations
#endif