QgsSqlAnywhereFeatureIterator::QgsSqlAnywhereFeatureIterator( QgsSqlAnywhereProvider* p, const QgsFeatureRequest & request ) : QgsAbstractFeatureIterator( request ), P( p ) , mStmt( NULL ), mStmtRect() { mClosed = false; QString whereClause = P->getWhereClause(); if ( request.filterType() == QgsFeatureRequest::FilterRect && !P->mGeometryColumn.isNull() ) { mStmtRect = mRequest.filterRect(); SaDebugMsg( "initial rectangle =" + mStmtRect.toString() ); mStmtRect = mStmtRect.intersect( &P->mSrsExtent ); SaDebugMsg( "rectangle clipped to SRS extent =" + mStmtRect.toString() ); whereClause += " AND " + whereClauseRect(); } else if ( request.filterType() == QgsFeatureRequest::FilterFid ) { whereClause += " AND " + whereClauseFid(); } if ( !prepareStatement( whereClause ) ) { mStmt = NULL; mClosed = true; return; } }
QgsGrassFeatureIterator::QgsGrassFeatureIterator( QgsGrassProvider* p, const QgsFeatureRequest& request ) : QgsAbstractFeatureIterator( request ), P( p ) { // make sure that only one iterator is active if ( P->mActiveIterator ) { QgsMessageLog::logMessage( QObject::tr( "Already active iterator on this provider was closed." ), QObject::tr( "GRASS" ) ); P->mActiveIterator->close(); } P->mActiveIterator = this; // check if outdated and update if necessary P->ensureUpdated(); // Init structures mPoints = Vect_new_line_struct(); mCats = Vect_new_cats_struct(); mList = Vect_new_list(); // Create selection array allocateSelection( P->mMap ); resetSelection( 1 ); if ( request.filterType() == QgsFeatureRequest::FilterRect ) { setSelectionRect( request.filterRect(), request.flags() & QgsFeatureRequest::ExactIntersect ); } else { // TODO: implement fast lookup by feature id //no filter - use all features resetSelection( 1 ); } }
QgsGrassFeatureIterator::QgsGrassFeatureIterator( QgsGrassFeatureSource* source, bool ownSource, const QgsFeatureRequest& request ) : QgsAbstractFeatureIteratorFromSource<QgsGrassFeatureSource>( source, ownSource, request ) { sMutex.lock(); // Init structures mPoints = Vect_new_line_struct(); mCats = Vect_new_cats_struct(); mList = Vect_new_list(); // Create selection array allocateSelection( mSource->mMap ); resetSelection( 1 ); if ( request.filterType() == QgsFeatureRequest::FilterRect ) { setSelectionRect( request.filterRect(), request.flags() & QgsFeatureRequest::ExactIntersect ); } else { // TODO: implement fast lookup by feature id //no filter - use all features resetSelection( 1 ); } }
void QgsMssqlFeatureIterator::BuildStatement( const QgsFeatureRequest& request ) { mFallbackStatement.clear(); mStatement.clear(); bool limitAtProvider = ( mRequest.limit() >= 0 ); // build sql statement // note: 'SELECT ' is added later, to account for 'SELECT TOP...' type queries mStatement += QString( "[%1]" ).arg( mSource->mFidColName ); mFidCol = mSource->mFields.indexFromName( mSource->mFidColName ); mAttributesToFetch.append( mFidCol ); bool subsetOfAttributes = mRequest.flags() & QgsFeatureRequest::SubsetOfAttributes; QgsAttributeList attrs = subsetOfAttributes ? mRequest.subsetOfAttributes() : mSource->mFields.allAttributesList(); // ensure that all attributes required for expression filter are being fetched if ( subsetOfAttributes && request.filterType() == QgsFeatureRequest::FilterExpression ) { Q_FOREACH ( const QString& field, request.filterExpression()->referencedColumns() ) { int attrIdx = mSource->mFields.fieldNameIndex( field ); if ( !attrs.contains( attrIdx ) ) attrs << attrIdx; } }
QgsWFSFeatureIterator::QgsWFSFeatureIterator( QgsWFSProvider* provider, const QgsFeatureRequest& request ) : QgsAbstractFeatureIterator( request ) , mProvider( provider ) { //select ids //get iterator if ( !mProvider ) { return; } mProvider->mActiveIterators << this; switch ( request.filterType() ) { case QgsFeatureRequest::FilterRect: if ( mProvider->mSpatialIndex ) { mSelectedFeatures = mProvider->mSpatialIndex->intersects( request.filterRect() ); } break; case QgsFeatureRequest::FilterFid: mSelectedFeatures.push_back( request.filterFid() ); break; case QgsFeatureRequest::FilterNone: mSelectedFeatures = mProvider->mFeatures.keys(); default: //QgsFeatureRequest::FilterNone mSelectedFeatures = mProvider->mFeatures.keys(); } mFeatureIterator = mSelectedFeatures.constBegin(); }
QgsVectorLayerFeatureIterator::QgsVectorLayerFeatureIterator( QgsVectorLayerFeatureSource* source, bool ownSource, const QgsFeatureRequest& request ) : QgsAbstractFeatureIteratorFromSource( source, ownSource, request ) , mEditGeometrySimplifier( 0 ) { // prepare joins: may add more attributes to fetch (in order to allow join) if ( mSource->mJoinBuffer->containsJoins() ) prepareJoins(); prepareExpressions(); // by default provider's request is the same mProviderRequest = mRequest; if ( mProviderRequest.flags() & QgsFeatureRequest::SubsetOfAttributes ) { // prepare list of attributes to match provider fields QgsAttributeList providerSubset; QgsAttributeList subset = mProviderRequest.subsetOfAttributes(); int nPendingFields = mSource->mFields.count(); for ( int i = 0; i < subset.count(); ++i ) { int attrIndex = subset[i]; if ( attrIndex < 0 || attrIndex >= nPendingFields ) continue; if ( mSource->mFields.fieldOrigin( attrIndex ) == QgsFields::OriginProvider ) providerSubset << mSource->mFields.fieldOriginIndex( attrIndex ); } mProviderRequest.setSubsetOfAttributes( providerSubset ); } if ( mSource->mHasEditBuffer ) { mChangedFeaturesRequest = mProviderRequest; mChangedFeaturesRequest.setFilterFids( mSource->mChangedAttributeValues.keys().toSet() ); } if ( request.filterType() == QgsFeatureRequest::FilterFid ) { mFetchedFid = false; } else // no filter or filter by rect { if ( mSource->mHasEditBuffer ) { mChangedFeaturesIterator = mSource->mProviderFeatureSource->getFeatures( mChangedFeaturesRequest ); } else { mProviderIterator = mSource->mProviderFeatureSource->getFeatures( mProviderRequest ); } rewindEditBuffer(); } if ( mRequest.filterType() == QgsFeatureRequest::FilterExpression ) { mRequest.filterExpression()->prepare( mSource->mFields ); } }
QgsSpatiaLiteFeatureIterator::QgsSpatiaLiteFeatureIterator( QgsSpatiaLiteFeatureSource* source, bool ownSource, const QgsFeatureRequest& request ) : QgsAbstractFeatureIteratorFromSource<QgsSpatiaLiteFeatureSource>( source, ownSource, request ) , sqliteStatement( NULL ) { mHandle = QgsSpatiaLiteConnPool::instance()->acquireConnection( mSource->mSqlitePath ); mFetchGeometry = !mSource->mGeometryColumn.isNull() && !( mRequest.flags() & QgsFeatureRequest::NoGeometry ); mHasPrimaryKey = !mSource->mPrimaryKey.isEmpty(); mRowNumber = 0; QString whereClause; if ( request.filterType() == QgsFeatureRequest::FilterRect && !mSource->mGeometryColumn.isNull() ) { // some kind of MBR spatial filtering is required whereClause += whereClauseRect(); } if ( request.filterType() == QgsFeatureRequest::FilterFid ) { whereClause += whereClauseFid(); } if ( request.filterType() == QgsFeatureRequest::FilterFids ) { whereClause += whereClauseFids(); } if ( !mSource->mSubsetString.isEmpty() ) { if ( !whereClause.isEmpty() ) { whereClause += " AND "; } whereClause += "( " + mSource->mSubsetString + ")"; } // preparing the SQL statement if ( !prepareStatement( whereClause ) ) { // some error occurred sqliteStatement = NULL; close(); return; } }
QgsPostgresFeatureIterator::QgsPostgresFeatureIterator( QgsPostgresFeatureSource* source, bool ownSource, const QgsFeatureRequest& request ) : QgsAbstractFeatureIteratorFromSource( source, ownSource, request ) , mFeatureQueueSize( sFeatureQueueSize ) { mConn = QgsPostgresConnPool::instance()->acquireConnection( mSource->mConnInfo ); if ( !mConn ) { mClosed = true; iteratorClosed(); return; } mCursorName = mConn->uniqueCursorName(); QString whereClause; if ( request.filterType() == QgsFeatureRequest::FilterRect && !mSource->mGeometryColumn.isNull() ) { whereClause = whereClauseRect(); } else if ( request.filterType() == QgsFeatureRequest::FilterFid ) { whereClause = QgsPostgresUtils::whereClause( mRequest.filterFid(), mSource->mFields, mConn, mSource->mPrimaryKeyType, mSource->mPrimaryKeyAttrs, mSource->mShared ); } else if ( request.filterType() == QgsFeatureRequest::FilterFids ) { whereClause = QgsPostgresUtils::whereClause( mRequest.filterFids(), mSource->mFields, mConn, mSource->mPrimaryKeyType, mSource->mPrimaryKeyAttrs, mSource->mShared ); } if ( !mSource->mSqlWhereClause.isEmpty() ) { if ( !whereClause.isEmpty() ) whereClause += " AND "; whereClause += "(" + mSource->mSqlWhereClause + ")"; } if ( !declareCursor( whereClause ) ) { mClosed = true; iteratorClosed(); return; } mFetched = 0; }
QgsPostgresFeatureIterator::QgsPostgresFeatureIterator( QgsPostgresProvider* p, const QgsFeatureRequest& request ) : QgsAbstractFeatureIterator( request ), P( p ) , mFeatureQueueSize( sFeatureQueueSize ) { // make sure that only one iterator is active if ( P->mActiveIterator ) { QgsMessageLog::logMessage( QObject::tr( "Already active iterator on this provider was closed." ), QObject::tr( "PostgreSQL" ) ); P->mActiveIterator->close(); } mCursorName = QString( "qgisf%1" ).arg( P->mProviderId ); QString whereClause; if ( request.filterType() == QgsFeatureRequest::FilterRect && !P->mGeometryColumn.isNull() ) { whereClause = whereClauseRect(); } else if ( request.filterType() == QgsFeatureRequest::FilterFid ) { whereClause = P->whereClause( request.filterFid() ); } if ( !P->mSqlWhereClause.isEmpty() ) { if ( !whereClause.isEmpty() ) whereClause += " AND "; whereClause += "(" + P->mSqlWhereClause + ")"; } if ( !declareCursor( whereClause ) ) { mClosed = true; return; } P->mActiveIterator = this; mFetched = 0; }
QgsOgrFeatureIterator::QgsOgrFeatureIterator( QgsOgrFeatureSource* source, bool ownSource, const QgsFeatureRequest& request ) : QgsAbstractFeatureIteratorFromSource<QgsOgrFeatureSource>( source, ownSource, request ) , mFeatureFetched( false ) , mConn( nullptr ) , ogrLayer( nullptr ) , mSubsetStringSet( false ) , mFetchGeometry( false ) , mExpressionCompiled( false ) , mFilterFids( mRequest.filterFids() ) , mFilterFidsIt( mFilterFids.constBegin() ) { mConn = QgsOgrConnPool::instance()->acquireConnection( mSource->mProvider->dataSourceUri() ); if ( !mConn->ds ) { return; } if ( mSource->mLayerName.isNull() ) { ogrLayer = OGR_DS_GetLayer( mConn->ds, mSource->mLayerIndex ); } else { ogrLayer = OGR_DS_GetLayerByName( mConn->ds, TO8( mSource->mLayerName ) ); } if ( !ogrLayer ) { return; } if ( !mSource->mSubsetString.isEmpty() ) { ogrLayer = QgsOgrProviderUtils::setSubsetString( ogrLayer, mConn->ds, mSource->mEncoding, mSource->mSubsetString ); if ( !ogrLayer ) { return; } mSubsetStringSet = true; } mFetchGeometry = ( !mRequest.filterRect().isNull() ) || !( mRequest.flags() & QgsFeatureRequest::NoGeometry ); QgsAttributeList attrs = ( mRequest.flags() & QgsFeatureRequest::SubsetOfAttributes ) ? mRequest.subsetOfAttributes() : mSource->mFields.allAttributesList(); // ensure that all attributes required for expression filter are being fetched if ( mRequest.flags() & QgsFeatureRequest::SubsetOfAttributes && request.filterType() == QgsFeatureRequest::FilterExpression ) { Q_FOREACH ( const QString& field, request.filterExpression()->referencedColumns() ) { int attrIdx = mSource->mFields.fieldNameIndex( field ); if ( !attrs.contains( attrIdx ) ) attrs << attrIdx; } mRequest.setSubsetOfAttributes( attrs ); }
void QgsDualView::updateSelectedFeatures() { QgsFeatureRequest r = mMasterModel->request(); if ( r.filterType() == QgsFeatureRequest::FilterNone && r.filterRect().isNull() ) return; // already requested all features r.setFilterFids( masterModel()->layer()->selectedFeatureIds() ); mMasterModel->setRequest( r ); mMasterModel->loadLayer(); emit filterChanged(); }
void QgsDualView::extentChanged() { QgsFeatureRequest r = mMasterModel->request(); if ( mFilterModel->mapCanvas() && ( r.filterType() != QgsFeatureRequest::FilterNone || !r.filterRect().isNull() ) ) { QgsRectangle rect = mFilterModel->mapCanvas()->mapSettings().mapToLayerCoordinates( mLayer, mFilterModel->mapCanvas()->extent() ); r.setFilterRect( rect ); mMasterModel->setRequest( r ); mMasterModel->loadLayer(); } emit filterChanged(); }
QgsPostgresFeatureIterator::QgsPostgresFeatureIterator( QgsPostgresProvider* p, const QgsFeatureRequest& request ) : QgsAbstractFeatureIterator( request ), P( p ) , mFeatureQueueSize( sFeatureQueueSize ) { mCursorName = QString( "qgisf%1_%2" ).arg( P->mProviderId ).arg( P->mIteratorCounter++ ); P->mActiveIterators << this; QString whereClause; if ( request.filterType() == QgsFeatureRequest::FilterRect && !P->mGeometryColumn.isNull() ) { whereClause = whereClauseRect(); } else if ( request.filterType() == QgsFeatureRequest::FilterFid ) { whereClause = P->whereClause( request.filterFid() ); } else if ( request.filterType() == QgsFeatureRequest::FilterFids ) { whereClause = P->whereClause( request.filterFids() ); } if ( !P->mSqlWhereClause.isEmpty() ) { if ( !whereClause.isEmpty() ) whereClause += " AND "; whereClause += "(" + P->mSqlWhereClause + ")"; } if ( !declareCursor( whereClause ) ) { mClosed = true; return; } mFetched = 0; }
QgsSpatiaLiteFeatureIterator::QgsSpatiaLiteFeatureIterator( QgsSpatiaLiteProvider* p, const QgsFeatureRequest& request ) : QgsAbstractFeatureIterator( request ) , P( p ) , sqliteStatement( NULL ) { P->mActiveIterators << this; mFetchGeometry = !P->mGeometryColumn.isNull() && !( mRequest.flags() & QgsFeatureRequest::NoGeometry ); QString whereClause; if ( request.filterType() == QgsFeatureRequest::FilterRect && !P->mGeometryColumn.isNull() ) { // some kind of MBR spatial filtering is required whereClause += whereClauseRect(); } if ( request.filterType() == QgsFeatureRequest::FilterFid ) { whereClause += whereClauseFid(); } if ( !P->mSubsetString.isEmpty() ) { if ( !whereClause.isEmpty() ) { whereClause += " AND "; } whereClause += "( " + P->mSubsetString + ")"; } // preparing the SQL statement if ( !prepareStatement( whereClause ) ) { // some error occurred sqliteStatement = NULL; return; } }
QgsVectorLayerFeatureIterator::QgsVectorLayerFeatureIterator( QgsVectorLayer* layer, const QgsFeatureRequest& request ) : QgsAbstractFeatureIterator( request ), L( layer ) { QgsVectorLayerJoinBuffer* joinBuffer = L->mJoinBuffer; if ( L->editBuffer() ) { mAddedFeatures = QgsFeatureMap( L->editBuffer()->addedFeatures() ); mChangedGeometries = QgsGeometryMap( L->editBuffer()->changedGeometries() ); mDeletedFeatureIds = QgsFeatureIds( L->editBuffer()->deletedFeatureIds() ); mChangedAttributeValues = QgsChangedAttributesMap( L->editBuffer()->changedAttributeValues() ); mAddedAttributes = QList<QgsField>( L->editBuffer()->addedAttributes() ); mDeletedAttributeIds = QgsAttributeList( L->editBuffer()->deletedAttributeIds() ); } // prepare joins: may add more attributes to fetch (in order to allow join) if ( joinBuffer->containsJoins() ) prepareJoins(); // by default provider's request is the same mProviderRequest = mRequest; if ( mProviderRequest.flags() & QgsFeatureRequest::SubsetOfAttributes ) { // prepare list of attributes to match provider fields QgsAttributeList providerSubset; QgsAttributeList subset = mProviderRequest.subsetOfAttributes(); const QgsFields &pendingFields = L->pendingFields(); int nPendingFields = pendingFields.count(); for ( int i = 0; i < subset.count(); ++i ) { int attrIndex = subset[i]; if ( attrIndex < 0 || attrIndex >= nPendingFields ) continue; if ( L->pendingFields().fieldOrigin( attrIndex ) == QgsFields::OriginProvider ) providerSubset << L->pendingFields().fieldOriginIndex( attrIndex ); } mProviderRequest.setSubsetOfAttributes( providerSubset ); } if ( request.filterType() == QgsFeatureRequest::FilterFid ) { mFetchedFid = false; } else // no filter or filter by rect { mProviderIterator = L->dataProvider()->getFeatures( mProviderRequest ); rewindEditBuffer(); } }
QgsWFSFeatureIterator::QgsWFSFeatureIterator( QgsWFSFeatureSource* source, bool ownSource, const QgsFeatureRequest& request ) : QgsAbstractFeatureIteratorFromSource<QgsWFSFeatureSource>( source, ownSource, request ) { if ( !request.filterRect().isNull() && mSource->mSpatialIndex ) { mSelectedFeatures = mSource->mSpatialIndex->intersects( request.filterRect() ); } else if ( request.filterType() == QgsFeatureRequest::FilterFid ) { mSelectedFeatures.push_back( request.filterFid() ); } else { mSelectedFeatures = mSource->mFeatures.keys(); } mFeatureIterator = mSelectedFeatures.constBegin(); }
QgsCachedFeatureIterator::QgsCachedFeatureIterator( QgsVectorLayerCache *vlCache, const QgsFeatureRequest &featureRequest ) : QgsAbstractFeatureIterator( featureRequest ) , mVectorLayerCache( vlCache ) { if ( mRequest.destinationCrs().isValid() && mRequest.destinationCrs() != mVectorLayerCache->sourceCrs() ) { mTransform = QgsCoordinateTransform( mVectorLayerCache->sourceCrs(), mRequest.destinationCrs() ); } try { mFilterRect = filterRectToSourceCrs( mTransform ); } catch ( QgsCsException & ) { // can't reproject mFilterRect close(); return; } if ( !mFilterRect.isNull() ) { // update request to be the unprojected filter rect mRequest.setFilterRect( mFilterRect ); } switch ( featureRequest.filterType() ) { case QgsFeatureRequest::FilterFids: mFeatureIds = featureRequest.filterFids(); break; case QgsFeatureRequest::FilterFid: mFeatureIds = QgsFeatureIds() << featureRequest.filterFid(); break; default: mFeatureIds = mVectorLayerCache->mCache.keys().toSet(); break; } mFeatureIdIterator = mFeatureIds.constBegin(); if ( mFeatureIdIterator == mFeatureIds.constEnd() ) close(); }
QgsCachedFeatureIterator::QgsCachedFeatureIterator( QgsVectorLayerCache *vlCache, QgsFeatureRequest featureRequest ) : QgsAbstractFeatureIterator( featureRequest ) , mVectorLayerCache( vlCache ) { switch ( featureRequest.filterType() ) { case QgsFeatureRequest::FilterFids: mFeatureIds = featureRequest.filterFids(); break; case QgsFeatureRequest::FilterFid: mFeatureIds = QgsFeatureIds() << featureRequest.filterFid(); break; default: mFeatureIds = mVectorLayerCache->mCache.keys().toSet(); break; } mFeatureIdIterator = mFeatureIds.begin(); }
void QgsDb2FeatureIterator::BuildStatement( const QgsFeatureRequest &request ) { bool limitAtProvider = ( mRequest.limit() >= 0 ); QString delim; // build sql statement mStatement = QStringLiteral( "SELECT " ); if ( !mSource->mFidColName.isEmpty() ) { mStatement += mSource->mFidColName; mFidCol = mSource->mFields.indexFromName( mSource->mFidColName ); mAttributesToFetch.append( mFidCol ); delim = QStringLiteral( "," ); } bool subsetOfAttributes = mRequest.flags() & QgsFeatureRequest::SubsetOfAttributes; QgsAttributeList attrs = subsetOfAttributes ? mRequest.subsetOfAttributes() : mSource->mFields.allAttributesList(); // ensure that all attributes required for expression filter are being fetched if ( subsetOfAttributes && request.filterType() == QgsFeatureRequest::FilterExpression ) { //ensure that all fields required for filter expressions are prepared QSet<int> attributeIndexes = request.filterExpression()->referencedAttributeIndexes( mSource->mFields ); attributeIndexes += attrs.toSet(); attrs = attributeIndexes.toList(); } Q_FOREACH ( int i, attrs ) { QString fieldname = mSource->mFields.at( i ).name(); if ( mSource->mFidColName == fieldname ) continue; mStatement += delim + fieldname; delim = QStringLiteral( "," ); mAttributesToFetch.append( i ); QgsDebugMsg( QString( "i: %1; name: %2" ).arg( i ).arg( fieldname ) ); }
void QgsMssqlFeatureIterator::BuildStatement( const QgsFeatureRequest &request ) { mFallbackStatement.clear(); mStatement.clear(); bool limitAtProvider = ( mRequest.limit() >= 0 ); // build sql statement // note: 'SELECT ' is added later, to account for 'SELECT TOP...' type queries mStatement += QStringLiteral( "[%1]" ).arg( mSource->mFidColName ); mFidCol = mSource->mFields.indexFromName( mSource->mFidColName ); mAttributesToFetch.append( mFidCol ); bool subsetOfAttributes = mRequest.flags() & QgsFeatureRequest::SubsetOfAttributes; QgsAttributeList attrs = subsetOfAttributes ? mRequest.subsetOfAttributes() : mSource->mFields.allAttributesList(); // ensure that all attributes required for expression filter are being fetched if ( subsetOfAttributes && request.filterType() == QgsFeatureRequest::FilterExpression ) { //ensure that all fields required for filter expressions are prepared QSet<int> attributeIndexes = request.filterExpression()->referencedAttributeIndexes( mSource->mFields ); attributeIndexes += attrs.toSet(); attrs = attributeIndexes.toList(); } Q_FOREACH ( int i, attrs ) { QString fieldname = mSource->mFields.at( i ).name(); if ( mSource->mFidColName == fieldname ) continue; mStatement += QStringLiteral( ",[%1]" ).arg( fieldname ); mAttributesToFetch.append( i ); }
bool QgsCacheIndexFeatureId::getCacheIterator( QgsFeatureIterator &featureIterator, const QgsFeatureRequest &featureRequest ) { switch ( featureRequest.filterType() ) { case QgsFeatureRequest::FilterFid: { if ( C->isFidCached( featureRequest.filterFid() ) ) { featureIterator = QgsFeatureIterator( new QgsCachedFeatureIterator( C, featureRequest ) ); return true; } break; } case QgsFeatureRequest::FilterFids: { if ( C->cachedFeatureIds().contains( featureRequest.filterFids() ) ) { featureIterator = QgsFeatureIterator( new QgsCachedFeatureIterator( C, featureRequest ) ); return true; } break; } case QgsFeatureRequest::FilterNone: case QgsFeatureRequest::FilterExpression: { if ( C->hasFullCache() ) { featureIterator = QgsFeatureIterator( new QgsCachedFeatureIterator( C, featureRequest ) ); return true; } break; } } return false; }
void QgsMssqlFeatureIterator::BuildStatement( const QgsFeatureRequest& request ) { // build sql statement mStatement = QString( "SELECT " ); mStatement += QString( "[%1]" ).arg( mSource->mFidColName ); mFidCol = mSource->mFields.indexFromName( mSource->mFidColName ); mAttributesToFetch.append( mFidCol ); bool subsetOfAttributes = mRequest.flags() & QgsFeatureRequest::SubsetOfAttributes; foreach ( int i, subsetOfAttributes ? mRequest.subsetOfAttributes() : mSource->mFields.allAttributesList() ) { QString fieldname = mSource->mFields[i].name(); if ( mSource->mFidColName == fieldname ) continue; mStatement += QString( ",[%1]" ).arg( fieldname ); mAttributesToFetch.append( i ); } // get geometry col if ( !( request.flags() & QgsFeatureRequest::NoGeometry ) && mSource->isSpatial() ) { mStatement += QString( ",[%1]" ).arg( mSource->mGeometryColName ); } mStatement += QString( "FROM [%1].[%2]" ).arg( mSource->mSchemaName, mSource->mTableName ); bool filterAdded = false; // set spatial filter if ( request.filterType() == QgsFeatureRequest::FilterRect && mSource->isSpatial() && !request.filterRect().isEmpty() ) { // polygons should be CCW for SqlGeography QString r; QTextStream foo( &r ); foo.setRealNumberPrecision( 8 ); foo.setRealNumberNotation( QTextStream::FixedNotation ); foo << qgsDoubleToString( request.filterRect().xMinimum() ) << " " << qgsDoubleToString( request.filterRect().yMinimum() ) << ", " << qgsDoubleToString( request.filterRect().xMaximum() ) << " " << qgsDoubleToString( request.filterRect().yMinimum() ) << ", " << qgsDoubleToString( request.filterRect().xMaximum() ) << " " << qgsDoubleToString( request.filterRect().yMaximum() ) << ", " << qgsDoubleToString( request.filterRect().xMinimum() ) << " " << qgsDoubleToString( request.filterRect().yMaximum() ) << ", " << qgsDoubleToString( request.filterRect().xMinimum() ) << " " << qgsDoubleToString( request.filterRect().yMinimum() ); mStatement += QString( " where [%1].STIntersects([%2]::STGeomFromText('POLYGON((%3))',%4)) = 1" ).arg( mSource->mGeometryColName, mSource->mGeometryColType, r, QString::number( mSource->mSRId ) ); filterAdded = true; } // set fid filter if ( request.filterType() == QgsFeatureRequest::FilterFid && !mSource->mFidColName.isEmpty() ) { QString fidfilter = QString( " [%1] = %2" ).arg( mSource->mFidColName, QString::number( request.filterFid() ) ); // set attribute filter if ( !filterAdded ) mStatement += " WHERE "; else mStatement += " AND "; mStatement += fidfilter; filterAdded = true; } if ( !mSource->mSqlWhereClause.isEmpty() ) { if ( !filterAdded ) mStatement += " WHERE (" + mSource->mSqlWhereClause + ")"; else mStatement += " AND (" + mSource->mSqlWhereClause + ")"; } QgsDebugMsg( mStatement ); #if 0 if ( fieldCount == 0 ) { QgsDebugMsg( "QgsMssqlProvider::select no fields have been requested" ); mStatement.clear(); } #endif }
QgsOgrFeatureIterator::QgsOgrFeatureIterator( QgsOgrFeatureSource* source, bool ownSource, const QgsFeatureRequest& request ) : QgsAbstractFeatureIteratorFromSource<QgsOgrFeatureSource>( source, ownSource, request ) , mFeatureFetched( false ) , mConn( nullptr ) , ogrLayer( nullptr ) , mSubsetStringSet( false ) , mFetchGeometry( false ) , mExpressionCompiled( false ) , mFilterFids( mRequest.filterFids() ) , mFilterFidsIt( mFilterFids.constBegin() ) { mConn = QgsOgrConnPool::instance()->acquireConnection( mSource->mProvider->dataSourceUri() ); if ( !mConn->ds ) { return; } if ( mSource->mLayerName.isNull() ) { ogrLayer = OGR_DS_GetLayer( mConn->ds, mSource->mLayerIndex ); } else { ogrLayer = OGR_DS_GetLayerByName( mConn->ds, TO8( mSource->mLayerName ) ); } if ( !ogrLayer ) { return; } if ( !mSource->mSubsetString.isEmpty() ) { ogrLayer = QgsOgrProviderUtils::setSubsetString( ogrLayer, mConn->ds, mSource->mEncoding, mSource->mSubsetString ); if ( !ogrLayer ) { return; } mSubsetStringSet = true; } mFetchGeometry = ( !mRequest.filterRect().isNull() ) || !( mRequest.flags() & QgsFeatureRequest::NoGeometry ); QgsAttributeList attrs = ( mRequest.flags() & QgsFeatureRequest::SubsetOfAttributes ) ? mRequest.subsetOfAttributes() : mSource->mFields.allAttributesList(); // ensure that all attributes required for expression filter are being fetched if ( mRequest.flags() & QgsFeatureRequest::SubsetOfAttributes && request.filterType() == QgsFeatureRequest::FilterExpression ) { //ensure that all fields required for filter expressions are prepared QSet<int> attributeIndexes = request.filterExpression()->referencedAttributeIndexes( mSource->mFields ); attributeIndexes += attrs.toSet(); attrs = attributeIndexes.toList(); mRequest.setSubsetOfAttributes( attrs ); } if ( request.filterType() == QgsFeatureRequest::FilterExpression && request.filterExpression()->needsGeometry() ) { mFetchGeometry = true; } // make sure we fetch just relevant fields // unless it's a VRT data source filtered by geometry as we don't know which // attributes make up the geometry and OGR won't fetch them to evaluate the // filter if we choose to ignore them (fixes #11223) if (( mSource->mDriverName != "VRT" && mSource->mDriverName != "OGR_VRT" ) || mRequest.filterRect().isNull() ) { QgsOgrProviderUtils::setRelevantFields( ogrLayer, mSource->mFields.count(), mFetchGeometry, attrs, mSource->mFirstFieldIsFid ); } // spatial query to select features if ( !mRequest.filterRect().isNull() ) { const QgsRectangle& rect = mRequest.filterRect(); OGR_L_SetSpatialFilterRect( ogrLayer, rect.xMinimum(), rect.yMinimum(), rect.xMaximum(), rect.yMaximum() ); } else { OGR_L_SetSpatialFilter( ogrLayer, nullptr ); } if ( request.filterType() == QgsFeatureRequest::FilterExpression && QSettings().value( "/qgis/compileExpressions", true ).toBool() ) { QgsSqlExpressionCompiler* compiler; if ( source->mDriverName == "SQLite" || source->mDriverName == "GPKG" ) { compiler = new QgsSQLiteExpressionCompiler( source->mFields ); } else { compiler = new QgsOgrExpressionCompiler( source ); } QgsSqlExpressionCompiler::Result result = compiler->compile( request.filterExpression() ); if ( result == QgsSqlExpressionCompiler::Complete || result == QgsSqlExpressionCompiler::Partial ) { QString whereClause = compiler->result(); if ( OGR_L_SetAttributeFilter( ogrLayer, mSource->mEncoding->fromUnicode( whereClause ).constData() ) == OGRERR_NONE ) { //if only partial success when compiling expression, we need to double-check results using QGIS' expressions mExpressionCompiled = ( result == QgsSqlExpressionCompiler::Complete ); mCompileStatus = ( mExpressionCompiled ? Compiled : PartiallyCompiled ); } } else { OGR_L_SetAttributeFilter( ogrLayer, nullptr ); } delete compiler; } else { OGR_L_SetAttributeFilter( ogrLayer, nullptr ); } //start with first feature rewind(); }
QgsOgrFeatureIterator::QgsOgrFeatureIterator( QgsOgrFeatureSource *source, bool ownSource, const QgsFeatureRequest &request ) : QgsAbstractFeatureIteratorFromSource<QgsOgrFeatureSource>( source, ownSource, request ) , mSharedDS( source->mSharedDS ) , mFirstFieldIsFid( source->mFirstFieldIsFid ) , mFieldsWithoutFid( source->mFieldsWithoutFid ) { for ( const auto &id : mRequest.filterFids() ) { mFilterFids.insert( id ); } mFilterFidsIt = mFilterFids.begin(); // Since connection timeout for OGR connections is problematic and can lead to crashes, disable for now. mRequest.setTimeout( -1 ); if ( mSharedDS ) { mOgrLayer = mSharedDS->getLayerFromNameOrIndex( mSource->mLayerName, mSource->mLayerIndex ); if ( !mOgrLayer ) { return; } } else { //QgsDebugMsg( "Feature iterator of " + mSource->mLayerName + ": acquiring connection"); mConn = QgsOgrConnPool::instance()->acquireConnection( QgsOgrProviderUtils::connectionPoolId( mSource->mDataSource, mSource->mShareSameDatasetAmongLayers ), mRequest.timeout(), mRequest.requestMayBeNested() ); if ( !mConn || !mConn->ds ) { return; } if ( mSource->mLayerName.isNull() ) { mOgrLayer = GDALDatasetGetLayer( mConn->ds, mSource->mLayerIndex ); } else { mOgrLayer = GDALDatasetGetLayerByName( mConn->ds, mSource->mLayerName.toUtf8().constData() ); } if ( !mOgrLayer ) { return; } if ( !mSource->mSubsetString.isEmpty() ) { mOgrLayerOri = mOgrLayer; mOgrLayer = QgsOgrProviderUtils::setSubsetString( mOgrLayer, mConn->ds, mSource->mEncoding, mSource->mSubsetString ); // If the mSubsetString was a full SELECT ...., then mOgrLayer will be a OGR SQL layer != mOgrLayerOri mFieldsWithoutFid.clear(); for ( int i = ( mFirstFieldIsFid ) ? 1 : 0; i < mSource->mFields.size(); i++ ) mFieldsWithoutFid.append( mSource->mFields.at( i ) ); if ( !mOgrLayer ) { close(); return; } } } QMutexLocker locker( mSharedDS ? &mSharedDS->mutex() : nullptr ); if ( mRequest.destinationCrs().isValid() && mRequest.destinationCrs() != mSource->mCrs ) { mTransform = QgsCoordinateTransform( mSource->mCrs, mRequest.destinationCrs(), mRequest.transformContext() ); } try { mFilterRect = filterRectToSourceCrs( mTransform ); } catch ( QgsCsException & ) { // can't reproject mFilterRect close(); return; } mFetchGeometry = ( !mFilterRect.isNull() ) || !( mRequest.flags() & QgsFeatureRequest::NoGeometry ) || ( mSource->mOgrGeometryTypeFilter != wkbUnknown ); QgsAttributeList attrs = ( mRequest.flags() & QgsFeatureRequest::SubsetOfAttributes ) ? mRequest.subsetOfAttributes() : mSource->mFields.allAttributesList(); // ensure that all attributes required for expression filter are being fetched if ( mRequest.flags() & QgsFeatureRequest::SubsetOfAttributes && request.filterType() == QgsFeatureRequest::FilterExpression ) { //ensure that all fields required for filter expressions are prepared QSet<int> attributeIndexes = request.filterExpression()->referencedAttributeIndexes( mSource->mFields ); attributeIndexes += attrs.toSet(); attrs = attributeIndexes.toList(); mRequest.setSubsetOfAttributes( attrs ); } // also need attributes required by order by if ( mRequest.flags() & QgsFeatureRequest::SubsetOfAttributes && !mRequest.orderBy().isEmpty() ) { QSet<int> attributeIndexes; Q_FOREACH ( const QString &attr, mRequest.orderBy().usedAttributes() ) { attributeIndexes << mSource->mFields.lookupField( attr ); } attributeIndexes += attrs.toSet(); attrs = attributeIndexes.toList(); mRequest.setSubsetOfAttributes( attrs ); }
QgsDelimitedTextFeatureIterator::QgsDelimitedTextFeatureIterator( QgsDelimitedTextFeatureSource* source, bool ownSource, const QgsFeatureRequest& request ) : QgsAbstractFeatureIteratorFromSource<QgsDelimitedTextFeatureSource>( source, ownSource, request ) , mTestGeometryExact( false ) { // Determine mode to use based on request... QgsDebugMsg( "Setting up QgsDelimitedTextIterator" ); // Does the layer have geometry - will revise later to determine if we actually need to // load it. bool hasGeometry = mSource->mGeomRep != QgsDelimitedTextProvider::GeomNone; // Does the layer have an explicit or implicit subset (implicit subset is if we have geometry which can // be invalid) mTestSubset = mSource->mSubsetExpression; mTestGeometry = false; mMode = FileScan; if ( request.filterType() == QgsFeatureRequest::FilterFid ) { QgsDebugMsg( "Configuring for returning single id" ); mFeatureIds.append( request.filterFid() ); mMode = FeatureIds; mTestSubset = false; } // If have geometry and testing geometry then evaluate options... // If we don't have geometry then all records pass geometry filter. // CC: 2013-05-09 // Not sure about intended relationship between filtering on geometry and // requesting no geometry? Have preserved current logic of ignoring spatial filter // if not requesting geometry. else if ( request.filterType() == QgsFeatureRequest::FilterRect && hasGeometry ) { QgsDebugMsg( "Configuring for rectangle select" ); mTestGeometry = true; // Exact intersection test only applies for WKT geometries mTestGeometryExact = mRequest.flags() & QgsFeatureRequest::ExactIntersect && mSource->mGeomRep == QgsDelimitedTextProvider::GeomAsWkt; QgsRectangle rect = request.filterRect(); // If request doesn't overlap extents, then nothing to return if ( ! rect.intersects( mSource->mExtent ) ) { QgsDebugMsg( "Rectangle outside layer extents - no features to return" ); mMode = FeatureIds; } // If the request extents include the entire layer, then revert to // a file scan else if ( rect.contains( mSource->mExtent ) ) { QgsDebugMsg( "Rectangle contains layer extents - bypass spatial filter" ); mTestGeometry = false; } // If we have a spatial index then use it. The spatial index already accounts // for the subset. Also means we don't have to test geometries unless doing exact // intersection else if ( mSource->mUseSpatialIndex ) { mFeatureIds = mSource->mSpatialIndex->intersects( rect ); // Sort for efficient sequential retrieval qSort( mFeatureIds.begin(), mFeatureIds.end() ); QgsDebugMsg( QString( "Layer has spatial index - selected %1 features from index" ).arg( mFeatureIds.size() ) ); mMode = FeatureIds; mTestSubset = false; mTestGeometry = mTestGeometryExact; } } // If we have a subset index then use it.. if ( mMode == FileScan && mSource->mUseSubsetIndex ) { QgsDebugMsg( QString( "Layer has subset index - use %1 items from subset index" ).arg( mSource->mSubsetIndex.size() ) ); mTestSubset = false; mMode = SubsetIndex; } // Otherwise just have to scan the file if ( mMode == FileScan ) { QgsDebugMsg( "File will be scanned for desired features" ); } // If the layer has geometry, do we really need to load it? // We need it if it is asked for explicitly in the request, // if we are testing geometry (ie spatial filter), or // if testing the subset expression. if ( hasGeometry && ( !( mRequest.flags() & QgsFeatureRequest::NoGeometry ) || mTestGeometry || ( mTestSubset && mSource->mSubsetExpression->needsGeometry() ) ) ) { mLoadGeometry = true; } else { QgsDebugMsgLevel( "Feature geometries not required", 4 ); mLoadGeometry = false; } QgsDebugMsg( QString( "Iterator is scanning file: " ) + ( mMode == FileScan ? "Yes" : "No" ) ); QgsDebugMsg( QString( "Iterator is loading geometries: " ) + ( mLoadGeometry ? "Yes" : "No" ) ); QgsDebugMsg( QString( "Iterator is testing geometries: " ) + ( mTestGeometry ? "Yes" : "No" ) ); QgsDebugMsg( QString( "Iterator is testing subset: " ) + ( mTestSubset ? "Yes" : "No" ) ); rewind(); }
QgsOgrFeatureIterator::QgsOgrFeatureIterator( QgsOgrFeatureSource* source, bool ownSource, const QgsFeatureRequest& request ) : QgsAbstractFeatureIteratorFromSource<QgsOgrFeatureSource>( source, ownSource, request ) , ogrLayer( 0 ) , mSubsetStringSet( false ) , mGeometrySimplifier( NULL ) , mExpressionCompiled( false ) { mFeatureFetched = false; mConn = QgsOgrConnPool::instance()->acquireConnection( mSource->mFilePath ); if ( mSource->mLayerName.isNull() ) { ogrLayer = OGR_DS_GetLayer( mConn->ds, mSource->mLayerIndex ); } else { ogrLayer = OGR_DS_GetLayerByName( mConn->ds, TO8( mSource->mLayerName ) ); } if ( !mSource->mSubsetString.isEmpty() ) { ogrLayer = QgsOgrUtils::setSubsetString( ogrLayer, mConn->ds, mSource->mEncoding, mSource->mSubsetString ); mSubsetStringSet = true; } mFetchGeometry = ( !mRequest.filterRect().isNull() ) || !( mRequest.flags() & QgsFeatureRequest::NoGeometry ); QgsAttributeList attrs = ( mRequest.flags() & QgsFeatureRequest::SubsetOfAttributes ) ? mRequest.subsetOfAttributes() : mSource->mFields.allAttributesList(); // make sure we fetch just relevant fields // unless it's a VRT data source filtered by geometry as we don't know which // attributes make up the geometry and OGR won't fetch them to evaluate the // filter if we choose to ignore them (fixes #11223) if (( mSource->mDriverName != "VRT" && mSource->mDriverName != "OGR_VRT" ) || mRequest.filterRect().isNull() ) { QgsOgrUtils::setRelevantFields( ogrLayer, mSource->mFields.count(), mFetchGeometry, attrs ); } // spatial query to select features if ( !mRequest.filterRect().isNull() ) { const QgsRectangle& rect = mRequest.filterRect(); OGR_L_SetSpatialFilterRect( ogrLayer, rect.xMinimum(), rect.yMinimum(), rect.xMaximum(), rect.yMaximum() ); } else { OGR_L_SetSpatialFilter( ogrLayer, 0 ); } if ( request.filterType() == QgsFeatureRequest::FilterExpression && QSettings().value( "/qgis/compileExpressions", true ).toBool() ) { QgsOgrExpressionCompiler compiler = QgsOgrExpressionCompiler( source ); QgsSqlExpressionCompiler::Result result = compiler.compile( request.filterExpression() ); if ( result == QgsSqlExpressionCompiler::Complete || result == QgsSqlExpressionCompiler::Partial ) { QString whereClause = compiler.result(); if ( OGR_L_SetAttributeFilter( ogrLayer, whereClause.toLocal8Bit().data() ) == OGRERR_NONE ) { //if only partial success when compiling expression, we need to double-check results using QGIS' expressions mExpressionCompiled = ( result == QgsSqlExpressionCompiler::Complete ); } } else { OGR_L_SetAttributeFilter( ogrLayer, 0 ); } } else { OGR_L_SetAttributeFilter( ogrLayer, 0 ); } //start with first feature rewind(); }
QgsDelimitedTextFeatureIterator::QgsDelimitedTextFeatureIterator( QgsDelimitedTextFeatureSource *source, bool ownSource, const QgsFeatureRequest &request ) : QgsAbstractFeatureIteratorFromSource<QgsDelimitedTextFeatureSource>( source, ownSource, request ) , mTestSubset( mSource->mSubsetExpression ) { // Determine mode to use based on request... QgsDebugMsg( "Setting up QgsDelimitedTextIterator" ); // Does the layer have geometry - will revise later to determine if we actually need to // load it. bool hasGeometry = mSource->mGeomRep != QgsDelimitedTextProvider::GeomNone; if ( mRequest.destinationCrs().isValid() && mRequest.destinationCrs() != mSource->mCrs ) { mTransform = QgsCoordinateTransform( mSource->mCrs, mRequest.destinationCrs() ); } try { mFilterRect = filterRectToSourceCrs( mTransform ); } catch ( QgsCsException & ) { // can't reproject mFilterRect mClosed = true; return; } if ( !mFilterRect.isNull() && hasGeometry ) { QgsDebugMsg( "Configuring for rectangle select" ); mTestGeometry = true; // Exact intersection test only applies for WKT geometries mTestGeometryExact = mRequest.flags() & QgsFeatureRequest::ExactIntersect && mSource->mGeomRep == QgsDelimitedTextProvider::GeomAsWkt; // If request doesn't overlap extents, then nothing to return if ( ! mFilterRect.intersects( mSource->mExtent ) && !mTestSubset ) { QgsDebugMsg( "Rectangle outside layer extents - no features to return" ); mMode = FeatureIds; } // If the request extents include the entire layer, then revert to // a file scan else if ( mFilterRect.contains( mSource->mExtent ) && !mTestSubset ) { QgsDebugMsg( "Rectangle contains layer extents - bypass spatial filter" ); mTestGeometry = false; } // If we have a spatial index then use it. The spatial index already accounts // for the subset. Also means we don't have to test geometries unless doing exact // intersection else if ( mSource->mUseSpatialIndex ) { mFeatureIds = mSource->mSpatialIndex->intersects( mFilterRect ); // Sort for efficient sequential retrieval std::sort( mFeatureIds.begin(), mFeatureIds.end() ); QgsDebugMsg( QString( "Layer has spatial index - selected %1 features from index" ).arg( mFeatureIds.size() ) ); mMode = FeatureIds; mTestSubset = false; mTestGeometry = mTestGeometryExact; } } if ( request.filterType() == QgsFeatureRequest::FilterFid ) { QgsDebugMsg( "Configuring for returning single id" ); if ( mFilterRect.isNull() || mFeatureIds.contains( request.filterFid() ) ) { mFeatureIds = QList<QgsFeatureId>() << request.filterFid(); } mMode = FeatureIds; mTestSubset = false; } // If have geometry and testing geometry then evaluate options... // If we don't have geometry then all records pass geometry filter. // CC: 2013-05-09 // Not sure about intended relationship between filtering on geometry and // requesting no geometry? Have preserved current logic of ignoring spatial filter // if not requesting geometry. else // If we have a subset index then use it.. if ( mMode == FileScan && mSource->mUseSubsetIndex ) { QgsDebugMsg( QString( "Layer has subset index - use %1 items from subset index" ).arg( mSource->mSubsetIndex.size() ) ); mTestSubset = false; mMode = SubsetIndex; } // Otherwise just have to scan the file if ( mMode == FileScan ) { QgsDebugMsg( "File will be scanned for desired features" ); } // If the layer has geometry, do we really need to load it? // We need it if it is asked for explicitly in the request, // if we are testing geometry (ie spatial filter), or // if testing the subset expression. if ( hasGeometry && ( !( mRequest.flags() & QgsFeatureRequest::NoGeometry ) || mTestGeometry || ( mTestSubset && mSource->mSubsetExpression->needsGeometry() ) || ( request.filterType() == QgsFeatureRequest::FilterExpression && request.filterExpression()->needsGeometry() ) ) ) { mLoadGeometry = true; } else { QgsDebugMsgLevel( "Feature geometries not required", 4 ); mLoadGeometry = false; } // ensure that all attributes required for expression filter are being fetched if ( mRequest.flags() & QgsFeatureRequest::SubsetOfAttributes && request.filterType() == QgsFeatureRequest::FilterExpression ) { QgsAttributeList attrs = request.subsetOfAttributes(); //ensure that all fields required for filter expressions are prepared QSet<int> attributeIndexes = request.filterExpression()->referencedAttributeIndexes( mSource->mFields ); attributeIndexes += attrs.toSet(); mRequest.setSubsetOfAttributes( attributeIndexes.toList() ); } // also need attributes required by order by if ( mRequest.flags() & QgsFeatureRequest::SubsetOfAttributes && !mRequest.orderBy().isEmpty() ) { QgsAttributeList attrs = request.subsetOfAttributes(); Q_FOREACH ( const QString &attr, mRequest.orderBy().usedAttributes() ) { int attrIndex = mSource->mFields.lookupField( attr ); if ( !attrs.contains( attrIndex ) ) attrs << attrIndex; } mRequest.setSubsetOfAttributes( attrs ); }
void QgsDualView::setFilterMode( QgsAttributeTableFilterModel::FilterMode filterMode ) { // cleanup any existing connections switch ( mFilterModel->filterMode() ) { case QgsAttributeTableFilterModel::ShowVisible: disconnect( mFilterModel->mapCanvas(), &QgsMapCanvas::extentsChanged, this, &QgsDualView::extentChanged ); break; case QgsAttributeTableFilterModel::ShowAll: case QgsAttributeTableFilterModel::ShowEdited: case QgsAttributeTableFilterModel::ShowFilteredList: break; case QgsAttributeTableFilterModel::ShowSelected: disconnect( masterModel()->layer(), &QgsVectorLayer::selectionChanged, this, &QgsDualView::updateSelectedFeatures ); break; } QgsFeatureRequest r = mMasterModel->request(); bool needsGeometry = filterMode == QgsAttributeTableFilterModel::ShowVisible; bool requiresTableReload = ( r.filterType() != QgsFeatureRequest::FilterNone || !r.filterRect().isNull() ) // previous request was subset || ( needsGeometry && r.flags() & QgsFeatureRequest::NoGeometry ) // no geometry for last request || ( mMasterModel->rowCount() == 0 ); // no features if ( !needsGeometry ) r.setFlags( r.flags() | QgsFeatureRequest::NoGeometry ); else r.setFlags( r.flags() & ~( QgsFeatureRequest::NoGeometry ) ); r.setFilterFids( QgsFeatureIds() ); r.setFilterRect( QgsRectangle() ); r.disableFilter(); // setup new connections and filter request parameters switch ( filterMode ) { case QgsAttributeTableFilterModel::ShowVisible: connect( mFilterModel->mapCanvas(), &QgsMapCanvas::extentsChanged, this, &QgsDualView::extentChanged ); if ( mFilterModel->mapCanvas() ) { QgsRectangle rect = mFilterModel->mapCanvas()->mapSettings().mapToLayerCoordinates( mLayer, mFilterModel->mapCanvas()->extent() ); r.setFilterRect( rect ); } break; case QgsAttributeTableFilterModel::ShowAll: case QgsAttributeTableFilterModel::ShowEdited: case QgsAttributeTableFilterModel::ShowFilteredList: break; case QgsAttributeTableFilterModel::ShowSelected: connect( masterModel()->layer(), &QgsVectorLayer::selectionChanged, this, &QgsDualView::updateSelectedFeatures ); r.setFilterFids( masterModel()->layer()->selectedFeatureIds() ); break; } if ( requiresTableReload ) { mMasterModel->setRequest( r ); whileBlocking( mLayerCache )->setCacheGeometry( needsGeometry ); mMasterModel->loadLayer(); } //update filter model mFilterModel->setFilterMode( filterMode ); emit filterChanged(); }
void QgsMssqlFeatureIterator::BuildStatement( const QgsFeatureRequest& request ) { // build sql statement mStatement = QString( "select " ); int fieldCount = 0; mFidCol = -1; mGeometryCol = -1; if ( !request.subsetOfAttributes().empty() ) { // subset of attributes has been specified for ( QgsAttributeList::const_iterator it = request.subsetOfAttributes().begin(); it != request.subsetOfAttributes().end(); ++it ) { if ( fieldCount != 0 ) mStatement += ","; mStatement += "[" + mSource->mFields[*it].name() + "]"; if ( !mSource->mFidColName.isEmpty() && mSource->mFidColName == mSource->mFields[*it].name() ) mFidCol = fieldCount; ++fieldCount; mAttributesToFetch.append( *it ); } } else { // get all attributes for ( int i = 0; i < mSource->mFields.count(); i++ ) { if ( fieldCount != 0 ) mStatement += ","; mStatement += "[" + mSource->mFields[i].name() + "]"; if ( !mSource->mFidColName.isEmpty() && mSource->mFidColName == mSource->mFields[i].name() ) mFidCol = fieldCount; ++fieldCount; mAttributesToFetch.append( i ); } } // get fid col if not yet required if ( mFidCol == -1 && !mSource->mFidColName.isEmpty() ) { if ( fieldCount != 0 ) mStatement += ","; mStatement += "[" + mSource->mFidColName + "]"; mFidCol = fieldCount; ++fieldCount; } // get geometry col if ( !( request.flags() & QgsFeatureRequest::NoGeometry ) && !mSource->mGeometryColName.isEmpty() ) { if ( fieldCount != 0 ) mStatement += ","; mStatement += "[" + mSource->mGeometryColName + "]"; mGeometryCol = fieldCount; ++fieldCount; } mStatement += " from "; if ( !mSource->mSchemaName.isEmpty() ) mStatement += "[" + mSource->mSchemaName + "]."; mStatement += "[" + mSource->mTableName + "]"; bool filterAdded = false; // set spatial filter if ( request.filterType() & QgsFeatureRequest::FilterRect ) { // polygons should be CCW for SqlGeography QString r; QTextStream foo( &r ); foo.setRealNumberPrecision( 8 ); foo.setRealNumberNotation( QTextStream::FixedNotation ); foo << request.filterRect().xMinimum() << " " << request.filterRect().yMinimum() << ", " << request.filterRect().xMaximum() << " " << request.filterRect().yMinimum() << ", " << request.filterRect().xMaximum() << " " << request.filterRect().yMaximum() << ", " << request.filterRect().xMinimum() << " " << request.filterRect().yMaximum() << ", " << request.filterRect().xMinimum() << " " << request.filterRect().yMinimum(); mStatement += QString( " where [%1].STIntersects([%2]::STGeomFromText('POLYGON((%3))',%4)) = 1" ).arg( mSource->mGeometryColName, mSource->mGeometryColType, r, QString::number( mSource->mSRId ) ); filterAdded = true; } // set fid filter if (( request.filterType() & QgsFeatureRequest::FilterFid ) && !mSource->mFidColName.isEmpty() ) { // set attribute filter if ( !filterAdded ) mStatement += QString( " where [%1] = %2" ).arg( mSource->mFidColName, QString::number( request.filterFid() ) ); else mStatement += QString( " and [%1] = %2" ).arg( mSource->mFidColName, QString::number( request.filterFid() ) ); filterAdded = true; } if ( !mSource->mSqlWhereClause.isEmpty() ) { if ( !filterAdded ) mStatement += " where (" + mSource->mSqlWhereClause + ")"; else mStatement += " and (" + mSource->mSqlWhereClause + ")"; } if ( fieldCount == 0 ) { QgsDebugMsg( "QgsMssqlProvider::select no fields have been requested" ); mStatement.clear(); } }
QgsSpatiaLiteFeatureIterator::QgsSpatiaLiteFeatureIterator( QgsSpatiaLiteFeatureSource* source, bool ownSource, const QgsFeatureRequest& request ) : QgsAbstractFeatureIteratorFromSource<QgsSpatiaLiteFeatureSource>( source, ownSource, request ) , sqliteStatement( NULL ) , mExpressionCompiled( false ) { mHandle = QgsSpatiaLiteConnPool::instance()->acquireConnection( mSource->mSqlitePath ); mFetchGeometry = !mSource->mGeometryColumn.isNull() && !( mRequest.flags() & QgsFeatureRequest::NoGeometry ); mHasPrimaryKey = !mSource->mPrimaryKey.isEmpty(); mRowNumber = 0; QStringList whereClauses; bool useFallbackWhereClause = false; QString fallbackWhereClause; QString whereClause; //beware - limitAtProvider needs to be set to false if the request cannot be completely handled //by the provider (eg utilising QGIS expression filters) bool limitAtProvider = ( mRequest.limit() >= 0 ); if ( !request.filterRect().isNull() && !mSource->mGeometryColumn.isNull() ) { // some kind of MBR spatial filtering is required whereClause = whereClauseRect(); if ( ! whereClause.isEmpty() ) { whereClauses.append( whereClause ); } } if ( !mSource->mSubsetString.isEmpty() ) { whereClause = "( " + mSource->mSubsetString + ')'; if ( ! whereClause.isEmpty() ) { whereClauses.append( whereClause ); } } if ( request.filterType() == QgsFeatureRequest::FilterFid ) { whereClause = whereClauseFid(); if ( ! whereClause.isEmpty() ) { whereClauses.append( whereClause ); } } else if ( request.filterType() == QgsFeatureRequest::FilterFids ) { whereClause = whereClauseFids(); if ( ! whereClause.isEmpty() ) { whereClauses.append( whereClause ); } } //IMPORTANT - this MUST be the last clause added! else if ( request.filterType() == QgsFeatureRequest::FilterExpression ) { if ( QSettings().value( "/qgis/compileExpressions", true ).toBool() ) { QgsSpatiaLiteExpressionCompiler compiler = QgsSpatiaLiteExpressionCompiler( source ); QgsSqlExpressionCompiler::Result result = compiler.compile( request.filterExpression() ); if ( result == QgsSqlExpressionCompiler::Complete || result == QgsSqlExpressionCompiler::Partial ) { whereClause = compiler.result(); if ( !whereClause.isEmpty() ) { useFallbackWhereClause = true; fallbackWhereClause = whereClauses.join( " AND " ); whereClauses.append( whereClause ); //if only partial success when compiling expression, we need to double-check results using QGIS' expressions mExpressionCompiled = ( result == QgsSqlExpressionCompiler::Complete ); } } if ( result != QgsSqlExpressionCompiler::Complete ) { //can't apply limit at provider side as we need to check all results using QGIS expressions limitAtProvider = false; } } else { limitAtProvider = false; } } whereClause = whereClauses.join( " AND " ); // preparing the SQL statement bool success = prepareStatement( whereClause, limitAtProvider ? mRequest.limit() : -1 ); if ( !success && useFallbackWhereClause ) { //try with the fallback where clause, eg for cases when using compiled expression failed to prepare mExpressionCompiled = false; success = prepareStatement( fallbackWhereClause, -1 ); } if ( !success ) { // some error occurred sqliteStatement = NULL; close(); } }