Branch data     Line data    Source code

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