void expression_from_expression()
{
{
QgsExpression e( "my_column" );
QCOMPARE( e.expression() , QgsExpression( e.expression() ).expression() );
}
{
QgsExpression e( "\"my column\"" );
QCOMPARE( e.expression() , QgsExpression( e.expression() ).expression() );
}
}
void QgsScaleExpression::init()
{
bool ok;
if ( !rootNode() )
return;
const NodeFunction * f = dynamic_cast<const NodeFunction*>( rootNode() );
if ( !f )
return;
QList<Node*> args = f->args()->list();
if ( "scale_linear" == Functions()[f->fnIndex()]->name() )
{
mType = Linear;
}
else if ( "scale_exp" == Functions()[f->fnIndex()]->name() )
{
const double exp = QgsExpression( args[5]->dump() ).evaluate().toDouble( &ok );
if ( ! ok )
return;
if ( qgsDoubleNear( exp, 0.57, 0.001 ) )
mType = Flannery;
else if ( qgsDoubleNear( exp, 0.5, 0.001 ) )
mType = Area;
else
{
mType = Unknown;
return;
}
}
else
{
mType = Unknown;
return;
}
bool expOk = true;
mMinValue = QgsExpression( args[1]->dump() ).evaluate().toDouble( &ok );
expOk &= ok;
mMaxValue = QgsExpression( args[2]->dump() ).evaluate().toDouble( &ok );
expOk &= ok;
mMinSize = QgsExpression( args[3]->dump() ).evaluate().toDouble( &ok );
expOk &= ok;
mMaxSize = QgsExpression( args[4]->dump() ).evaluate().toDouble( &ok );
expOk &= ok;
if ( !expOk )
{
mType = Unknown;
return;
}
mExpression = args[0]->dump();
}
bool QgsLayoutAtlas::updateFilenameExpression( QString &error )
{
if ( !mCoverageLayer )
{
return false;
}
QgsExpressionContext expressionContext = createExpressionContext();
if ( !mFilenameExpressionString.isEmpty() )
{
mFilenameExpression = QgsExpression( mFilenameExpressionString );
// expression used to evaluate each filename
// test for evaluation errors
if ( mFilenameExpression.hasParserError() )
{
error = mFilenameExpression.parserErrorString();
return false;
}
// prepare the filename expression
mFilenameExpression.prepare( &expressionContext );
}
// regenerate current filename
evalFeatureFilename( expressionContext );
return true;
}
void QgsRendererV2DataDefinedMenus::sizeScaleFieldSelected( QAction* a )
{
if ( a == NULL )
return;
QString fldName = a->text();
#if 0
updateMenu( mSizeAttributeActionGroup, fldName );
#endif
if ( fldName == tr( "- no field -" ) )
{
fldName = QString();
}
else if ( fldName.startsWith( tr( "- expression -" ) ) )
{
QString expr( fldName );
expr.replace( 0, tr( "- expression -" ).length(), "" );
QgsExpressionBuilderDialog dialog( mLayer, expr );
if ( !dialog.exec() ) return;
fldName = dialog.expressionText();
Q_ASSERT( !QgsExpression( fldName ).hasParserError() );
a->setText( tr( "- expression -" ) + fldName );
}
emit sizeScaleFieldChanged( fldName );
}
bool QgsProperty::loadVariant( const QVariant &property )
{
QVariantMap propertyMap = property.toMap();
d.detach();
d->active = propertyMap.value( QStringLiteral( "active" ) ).toBool();
d->type = static_cast< Type >( propertyMap.value( QStringLiteral( "type" ), InvalidProperty ).toInt() );
switch ( d->type )
{
case StaticProperty:
d->staticValue = propertyMap.value( QStringLiteral( "val" ) );
// d->staticValue.convert( QVariant::nameToType( propertyElem.attribute( "valType", "QString" ).toLocal8Bit().constData() ) );
break;
case FieldBasedProperty:
d->fieldName = propertyMap.value( QStringLiteral( "field" ) ).toString();
if ( d->fieldName.isEmpty() )
d->active = false;
break;
case ExpressionBasedProperty:
d->expressionString = propertyMap.value( QStringLiteral( "expression" ) ).toString();
if ( d->expressionString.isEmpty() )
d->active = false;
d->expression = QgsExpression( d->expressionString );
d->expressionPrepared = false;
d->expressionReferencedCols.clear();
break;
case InvalidProperty:
break;
}
//restore transformer if present
if ( d->transformer )
delete d->transformer;
d->transformer = nullptr;
QVariant transform = propertyMap.value( QStringLiteral( "transformer" ) );
if ( transform.isValid() )
{
QVariantMap transformerMap = transform.toMap();
QgsPropertyTransformer::Type type = static_cast< QgsPropertyTransformer::Type >( transformerMap.value( QStringLiteral( "t" ), QgsPropertyTransformer::GenericNumericTransformer ).toInt() );
std::unique_ptr< QgsPropertyTransformer > transformer( QgsPropertyTransformer::create( type ) );
if ( transformer )
{
if ( transformer->loadVariant( transformerMap.value( QStringLiteral( "d" ) ) ) )
d->transformer = transformer.release();
}
}
return true;
}
void QgsProperty::setExpressionString( const QString &expression )
{
d.detach();
d->type = ExpressionBasedProperty;
d->expressionString = expression;
d->expression = QgsExpression( expression );
d->expressionPrepared = false;
}
void QgsFeatureFilterModel::setDisplayExpression( const QString &displayExpression )
{
if ( mDisplayExpression.expression() == displayExpression )
return;
mDisplayExpression = QgsExpression( displayExpression );
reload();
emit displayExpressionChanged();
}
void expression_from_expression()
{
QFETCH( QString, string );
QgsExpression e( string );
QVERIFY( !e.hasParserError() );
qDebug() << e.expression();
QCOMPARE( e.expression() , QgsExpression( e.expression() ).expression() );
}
void QgsAttributeTypeDialog::defaultExpressionChanged()
{
QString expression = mExpressionWidget->expression();
if ( expression.isEmpty() )
{
mDefaultPreviewLabel->setText( QString() );
return;
}
QgsExpressionContext context = mLayer->createExpressionContext();
if ( !mPreviewFeature.isValid() )
{
// get first feature
QgsFeatureIterator it = mLayer->getFeatures( QgsFeatureRequest().setLimit( 1 ) );
it.nextFeature( mPreviewFeature );
}
context.setFeature( mPreviewFeature );
QgsExpression exp = QgsExpression( expression );
exp.prepare( &context );
if ( exp.hasParserError() )
{
mDefaultPreviewLabel->setText( "<i>" + exp.parserErrorString() + "</i>" );
return;
}
QVariant val = exp.evaluate( &context );
if ( exp.hasEvalError() )
{
mDefaultPreviewLabel->setText( "<i>" + exp.evalErrorString() + "</i>" );
return;
}
QString previewText = val.toString();
QgsEditorWidgetFactory *factory = QgsEditorWidgetRegistry::instance()->factory( editorWidgetType() );
if ( factory )
{
previewText = factory->representValue( mLayer, mFieldIdx, editorWidgetConfig(), QVariant(), val );
}
mDefaultPreviewLabel->setText( "<i>" + previewText + "</i>" );
}
QVariant QmlExpression::evaluate( const QString &expression ) const
{
QgsExpression exp = QgsExpression( expression );
exp.prepare( &mExpressionContext );
return exp.evaluate( &mExpressionContext );
}
void QgsExpressionFieldBuffer::updateExpression( int index, const QString &exp )
{
mExpressions[index].cachedExpression = QgsExpression( exp );
}
void QgsScaleExpression::init()
{
bool ok;
mType = Unknown;
if ( !rootNode() )
return;
const NodeFunction * f = dynamic_cast<const NodeFunction*>( rootNode() );
if ( !f )
return;
QList<Node*> args = f->args()->list();
// the scale function may be enclosed in a coalesce(expr, 0) to avoid NULL value
// to be drawn with the default size
if ( "coalesce" == Functions()[f->fnIndex()]->name() )
{
f = dynamic_cast<const NodeFunction*>( args[0] );
if ( !f )
return;
mNullSize = QgsExpression( args[1]->dump() ).evaluate().toDouble( &ok );
if ( ! ok )
return;
args = f->args()->list();
}
if ( "scale_linear" == Functions()[f->fnIndex()]->name() )
{
mType = Linear;
}
else if ( "scale_exp" == Functions()[f->fnIndex()]->name() )
{
mExponent = QgsExpression( args[5]->dump() ).evaluate().toDouble( &ok );
if ( ! ok )
return;
if ( qgsDoubleNear( mExponent, 0.57, 0.001 ) )
mType = Flannery;
else if ( qgsDoubleNear( mExponent, 0.5, 0.001 ) )
mType = Area;
else
mType = Exponential;
}
else
{
return;
}
bool expOk = true;
mMinValue = QgsExpression( args[1]->dump() ).evaluate().toDouble( &ok );
expOk &= ok;
mMaxValue = QgsExpression( args[2]->dump() ).evaluate().toDouble( &ok );
expOk &= ok;
mMinSize = QgsExpression( args[3]->dump() ).evaluate().toDouble( &ok );
expOk &= ok;
mMaxSize = QgsExpression( args[4]->dump() ).evaluate().toDouble( &ok );
expOk &= ok;
if ( !expOk )
{
mType = Unknown;
return;
}
mExpression = args[0]->dump();
}
void TestQgsProjectStorage::testMemoryStorage()
{
QString dataDir( TEST_DATA_DIR ); // defined in CmakeLists.txt
QString layerPath = dataDir + "/points.shp";
QgsVectorLayer *layer1 = new QgsVectorLayer( layerPath, QStringLiteral( "points" ), QStringLiteral( "ogr" ) );
QVERIFY( layer1->isValid() );
MemoryStorage *memStorage = new MemoryStorage;
QgsApplication::projectStorageRegistry()->registerProjectStorage( memStorage );
QVERIFY( QgsApplication::projectStorageRegistry()->projectStorages().contains( memStorage ) );
QCOMPARE( memStorage->listProjects( QString() ).count(), 0 );
QgsProject prj1;
prj1.setTitle( "best project ever" );
prj1.addMapLayer( layer1 );
prj1.setFileName( "memory:project1" );
// let's use the aux storage as well - so that the project will include aux database as well
int fldCnt0 = layer1->fields().count();
QgsAuxiliaryLayer *layerAux = prj1.auxiliaryStorage()->createAuxiliaryLayer( layer1->fields().at( 0 ), layer1 );
layer1->setAuxiliaryLayer( layerAux );
layerAux->addAttribute( QgsField( "fld_aux", QVariant::Int ) );
layerAux->commitChanges();
QCOMPARE( fldCnt0, 6 );
QCOMPARE( layer1->fields().count(), 7 );
bool writeOk = prj1.write();
QVERIFY( writeOk );
QCOMPARE( memStorage->listProjects( QString() ).count(), 1 );
QVERIFY( prj1.absoluteFilePath().isEmpty() );
QCOMPARE( prj1.baseName(), QString( "project1" ) );
QVERIFY( prj1.lastModified().secsTo( QDateTime::currentDateTime() ) < 1 );
// read the project back
QgsProject prj2;
prj2.setFileName( "memory:project1" );
bool readOk = prj2.read();
QVERIFY( readOk );
QCOMPARE( prj2.mapLayers().count(), 1 );
QCOMPARE( prj2.title(), QString( "best project ever" ) );
// let's check that our stuff from auxiliary database got stored written and read
QgsVectorLayer *prj2layer1 = qobject_cast<QgsVectorLayer *>( prj2.mapLayers().constBegin().value() );
QVERIFY( prj2layer1 );
QCOMPARE( prj2layer1->fields().count(), 7 );
QCOMPARE( prj2layer1->fields().at( 6 ).name(), QString( "auxiliary_storage_fld_aux" ) );
// test project-related variables for project storage
QgsExpressionContext expressionContext;
expressionContext.appendScope( QgsExpressionContextUtils::projectScope( &prj2 ) );
QCOMPARE( QgsExpression( "@project_path" ).evaluate( &expressionContext ).toString(), QString( "memory:project1" ) );
QCOMPARE( QgsExpression( "@project_basename" ).evaluate( &expressionContext ).toString(), QString( "project1" ) );
// test access of non-existent project
QgsProject prj3;
prj3.setFileName( "memory:nooooooooo!" );
bool readInvalidOk = prj3.read();
QVERIFY( !readInvalidOk );
// test metadata access
QgsProjectStorage::Metadata meta1;
bool readMetaOk = memStorage->readProjectStorageMetadata( "memory:project1", meta1 );
QVERIFY( readMetaOk );
QCOMPARE( meta1.name, QString( "project1" ) );
QVERIFY( meta1.lastModified.secsTo( QDateTime::currentDateTime() ) < 1 );
QgsProjectStorage::Metadata metaX;
bool readMetaInvalidOk = memStorage->readProjectStorageMetadata( "memory:projectXYZ", metaX );
QVERIFY( !readMetaInvalidOk );
// test removal
bool removeInvalidOk = memStorage->removeProject( "memory:projectXYZ" );
QVERIFY( !removeInvalidOk );
QCOMPARE( memStorage->listProjects( QString() ).count(), 1 );
bool removeOk = memStorage->removeProject( "memory:project1" );
QVERIFY( removeOk );
QCOMPARE( memStorage->listProjects( QString() ).count(), 0 );
QgsApplication::projectStorageRegistry()->unregisterProjectStorage( memStorage );
}
