Many use cases of the Asset Administration Shell require the involvement of a high number of Asset Administration Shells at the same time. Executing the business logic on all potentially involved Asset Administration Shells solely by the client application requires a huge amount of transferred data objects and bandwidth. It is therefore necessary to send parts of the selection conditions to the AAS hosting systems. The AAS Query Language enables AAS clients to describe and handover their interests and AAS servers to only respond with the needed data objects.
The Asset Administration Shell propagates a Query Language inspired by the so-called Resource Query Language (RQL [11]). This language follows a simplified grammar and expressiveness compared with RQL and other languages with a similar scope, e.g. SPARQL [12], GQL [13], or JsonPath [14]. The same language shall be used independent of the communication protocol, therefore, it is not limited to the HTTP API of the AAS. However, different communication protocols may treat aspects differently, e.g., by requiring different query or result set serialisations, variations in the order of constructs, or endpoint patterns. Nevertheless, all share the same expressiveness, and under same conditions a query shall lead to the same results independently of the chosen communication protocol.
Note: The AAS Query Language and the AAS Access Rules [3] share the same BNF grammar. Therefore, the result is a superset, with query as the entrypoint for the Query Language.
Examples for Use Cases are search queries in the submodels DigitalNameplate, TechnicalData or HandoverDocumentation.
DigitalNameplate has a fixed structure, only the bottom part with Markings and AssetSpecificProperties is variable. Queries in DigitalNameplate can be well done by providing idShortPaths to the elements in the query, e.g. searching for all DigitalNameplates with a certain ManufacturerName and CountryOfOrigin.
TechnicalData has its major variable part on the bottom and a small fixed structure on the top.
TechnicalData includes ProductClassifications with ProductClassId, so that e.g. by ECLASS ClassId a certain product type can be queried.
TechnicalData includes all the technical properties, e.g. width of the product.
An example is to search for motor starters (ProductClassifications[].ProductClassId = 27-37-09-05) with a width less than 100 mm (semanticId = 0173-1#02-BAF016#006, value < 100).
HandoverDocumentation consists basically of a list of document information according VDI 2770 (DocumentedEntity{00}). It is expected, that this will be changed to SubmodelElementList like other V3 Submodels. An example is to search for Documents of a certain ClassId (semanticId = 0173-1#02-ABH996#001, ClassId = "03-01", i.e. Commissioning) in a certain language (semanticId = 0173-1#02-AAN468#006, e.g. value = "nl").
link:partial$diagrams/query-language-overview.puml[role=include]
The AAS Query Language is not intended as feature-comparable to existing query languages like SPARQL or GQL. In case the expressiveness of such technologies is needed, a software vendor might additionally extend his service accordingly. However, in order to keep the additional overhead for AAS Query Language implementers as small as possible, the following limitations apply:
-
The AAS Query Language focusses on Identifiables: It is only possible to formulate queries for Asset Administration Shells, Submodels, and their according Descriptors, as well as ConceptDescription objects. In addition, also their identifiers (values of the "id" attributes) can be queried. This means in particular that not every Referable can be queried.
-
Only Repository and Registry Services have specified query functionalities: Querys on Asset Administration Shell Services or Submodel Services are not defined.
-
Only selected attributes defined by the AAS data model [1] can be used as conditions for returned objects: Usage of custom or vendor-specific attributes outside of the AAS specifications is generally not recommended and may lead to a rejections of the query by the receiving systems.
-
It is not possible to traverse through the specific fields of the SubmodelElements Entity (e.g. Entity/statements), AnnotatedRelationshipElement (e.g. AnnotatedRelationshipElement/annotations), or Operation (e.g. Operation/outputVariables). Only the fields
semanticIdidShort,value, andvalueTypeare available for SubmodelElements. -
The rendering of the "oneOf" clause of logicalExpressions does not work in SwaggerHub. This issue has no effect on the functionality of the requirement.
AAS consists of a hierarchical structure. An AAS references its "contained" submodels. A submodel contains a list of SubmodelElements, which may include further SubmodelElements, and so on.
The query language allows to both address a specific instance of the data or to search all data in a repository. A specific instance is addressed by specifying the id of an Identifiable and the idShortPath to a Referable in a Submodel.
If such explicit information is not specified, a hierarchical search is made. By the $aas FieldIdentifier conditions for all the relevant AAS are defined. By the $sm FieldIdentifier conditions for all the relevant submodels are defined. $sm can be used with and without $aas. If $aas and $sm are used together, only the submodels referenced by the matching $aas are searched by the $sm expression. The same search principle is used, when combining $sm and $sme. In such case only the SubmodelElements which are part of matching submodels by $sm expression are searched by the $sme expression. Several such hierarchical conditions may even be combined by $match expressions.
The content and structure of the AAS Query Language is defined in the context-free Backus-Naur form (BNF). See Appendix Backus-Naur-Form for more details on BNF. The detailed serialisation and interaction patterns are defined by the different technology mappings, e.g., the AAS HTTP API represents AAS Queries as JSON objects (see Clause Serialisation). Other mappings may define different serialisations, however, all have to follow the general structure of queries defined in the following grammar.
This is the combined grammar for the AAS Query Language and the AAS Access Rules defined by the AAS Security specification [3].
link:partial$bnf/grammar.bnf[role=include]The default return type is a list containing the respective AAS objects. For an AAS Repository, it’s a list of Asset Administration Shells, while a Submodel Registry returns a list of SubmodelDescriptors. The optional $select statement declares whether the response shall deviate from this default behavior, and only return a list of identifiers instead of a list of objects ($select id).
Elements relevant for comparisons are described using an adapted IdShortPath notation. The declaration starts with kind of element that shall serve as the root of the expression, followed with an optional '.' as the separator symbol and an optional IdShortPath, and a mandatory declaration of the AAS attribute that shall be examined, separated via '#'. A recursive search is made through the Submodel Elements, when the optional IdShortPath is left out.
FieldIdentifier ::= <RootDeclaration> ( "." <IdShortPath> | "" ) "#" <AttributeDeclaration>
{aasa005}
Root Element |
Definition |
Example(s) |
|---|---|---|
|
Starting point for fields available in Asset Administration Shells |
|
|
Starting point for fields available in Submodels |
|
|
Starting point for fields available in Submodel Elements. Can be followed with an IdShortPath, see Constraint AASa-005.
Can start at any possible Submodel Element, is not restricted to Submodel Elements directly in the |
|
|
Starting point for fields available in Concept Descriptions |
|
|
Starting point for fields available in Asset Administration Shell Descriptors |
|
|
Starting point for fields available in Submodel Descriptors |
|
Attribute declarations point to literal values that provide the input for comparisons. It is not possible to point to objects or lists, only atomic values. Attribute declarations present a subset of the attributes defined by the AAS Metamodel and the extension classes of Clause Data Types for Payload.
<index> is an optional nonNegativeInteger value. No <index> shall be interpreted as 'anywhere in the list'.
Root Element |
Definition |
Example |
|---|---|---|
|
Identifier, e.g., of an AAS, Submodel, or Condept Description |
|
|
Value of the idShort attribute |
|
|
Value of the assetKind attribute of an AAS |
|
|
Value of the assetKind attribute of an AAS |
|
|
Value of the globalAssetId attribute of an AAS |
|
|
Name of a SpecificAssetId of an AAS |
|
|
Value of a SpecificAssetId of an AAS |
|
|
Type of a Reference used as an externalSubjectId in a SpecificAssetId of an AAS |
|
|
Value of a key of a Reference used as an externalSubjectId in a SpecificAssetId of an AAS |
|
|
Type of a key of a Reference used as an externalSubjectId in a SpecificAssetId of an AAS |
|
|
Shortcut for Submodels referenced by an AAS, see Clause References |
|
|
Type of a Reference that associates an AAS with a Submodel |
|
|
Value of a key used in a Reference that associates an AAS with a Submodel |
|
|
Value of a key used in a Reference that associates an AAS with a Submodel |
|
|
Shortcut for semanticIds, see Clause References |
|
|
ReferenceType of a semanticId Reference |
|
|
KeyType of a semanticId Reference |
|
|
Value of a key of a semanticId Reference |
|
|
Shortcut for supplementalSemanticIds, see Clause References |
|
|
ReferenceType of a supplementalSemanticId Reference |
|
|
KeyType of a supplementalSemanticId Reference |
|
|
Value of a key of a supplementalSemanticId Reference |
|
|
Value of a Submodel Element |
|
|
ValueType of a Submodel Element |
|
|
Language of a Multilanguage Property |
|
|
Value of the assetKind attribute of an AAS Descriptor |
|
|
Value of the assetKind attribute of an AAS Descriptor |
|
|
Value of the globalAssetId attribute of an AAS Descriptor |
|
|
Name of a SpecificAssetId of an AAS Descriptor |
|
|
Value of a SpecificAssetId of an AAS Descriptor |
|
|
Type of a Reference used as an externalSubjectId in a SpecificAssetId of an AAS Descriptor |
|
|
Value of a key of a Reference used as an externalSubjectId in a SpecificAssetId of an AAS Descriptor |
|
|
Type of a key of a Reference used as an externalSubjectId in a SpecificAssetId of an AAS Descriptor |
|
|
Interface of an endpoint of an AAS or Submodel Note: Can only be used with Asset Administration Shell Descriptors or Submodel Descriptors. |
|
|
Href of an endpoint of an AAS or Submodel Note: Can only be used with Asset Administration Shell Descriptors or Submodel Descriptors. |
|
|
Shortcut for semanticIds, see Clause References |
|
|
ReferenceType of a semanticId Reference used in a referenced Submodel of an Asset Administration Shell Descriptor |
|
|
KeyType of a semanticId Reference used in a referenced Submodel of an Asset Administration Shell Descriptor |
|
|
Value of a key of a semanticId Reference used in a referenced Submodel of an Asset Administration Shell Descriptor |
|
|
Shortcut for supplementalSemanticIds, see Clause References |
|
|
ReferenceType of a supplementalSemanticId Reference used in a referenced Submodel of an Asset Administration Shell Descriptor |
|
|
KeyType of a supplementalSemanticId Reference used in a referenced Submodel of an Asset Administration Shell Descriptor |
|
|
Value of a key of a supplementalSemanticId Reference used in a referenced Submodel of an Asset Administration Shell Descriptor |
|
|
Identifier of a referenced Submodel as available in an Asset Administration Shell Descriptor |
|
|
idShort of a referenced Submodel as available in an Asset Administration Shell Descriptor |
|
|
Endpoint interface of a referenced Submodel as available in an Asset Administration Shell Descriptor |
|
|
Endpoint href of a referenced Submodel as available in an Asset Administration Shell Descriptor |
|
The following comparison operators are part of the query language. The result of a comparison shall always be (a) of type xs:boolean or (b) a comparison error, e.g., due to invalid inputs.
In case of an error the comparison result is invalid. Any further combinations with the invalid result will also have an invalid result. In that case all condition expressions will be ignored for the evaluated element and no result will be returned. Only the elements with valid results will be returned.
The comparisons $eq $ne $gt $lt $ge $le are overloaded in the BNF grammar, which means that the same comparison can deal with several input types. For instance, $eq can be used both for values of type xs:string and xs:int. The comparisons $contains $starts-with $ends-with $regex only allow xs:string.
Operator |
Description |
Definition |
|---|---|---|
|
Compares two values if they are identical. |
Operator 'A eq B' in https://www.w3.org/TR/xpath-30/#mapping |
|
Compares two values if they are not identical. |
Operator 'A eq B' in https://www.w3.org/TR/xpath-30/#mapping |
|
Checks whether one parameter is greater than another. |
Operator 'A gt B' in https://www.w3.org/TR/xpath-30/#mapping |
|
Checks whether one parameter is lower than another. |
Operator 'A lt B' in https://www.w3.org/TR/xpath-30/#mapping |
|
Checks whether one parameter is greater or equal than another. |
Operator 'A ge B' in https://www.w3.org/TR/xpath-30/#mapping |
|
Checks whether one parameter is lower or equal than another. |
Operator 'A ne B' in https://www.w3.org/TR/xpath-30/#mapping |
|
Compares two string expressions whether the second parameter appears as a substring inside of the first. |
Defined as fn:contains in https://www.w3.org/TR/xpath-functions-30/#func-contains |
|
Compares two string expressions whether the second parameter appears character-equal at the beginning of the first. |
Defined as fn:starts-with in https://www.w3.org/TR/xpath-functions-30/#func-starts-with |
|
Compares two string expressions whether the second parameter appears character-equal at the end of the first. |
Defined as fn:starts-with in https://www.w3.org/TR/xpath-functions-30/#func-ends-with |
|
Compares two string expressions whether the first parameter matches the regex of the second. |
Defined as fn:starts-with in https://www.w3.org/TR/xpath-functions-30/#func-matches |
The following example is used to illustrate the comparisons. The following Asset Administration Shell is used for the evaluations of the different operators.
{
"modelType": "AssetAdministrationShell",
"id": "https://example.com/asset-administration-shell-1",
"assetInformation": {
"assetKind": "Instance",
"globalAssetId": "urn:asset-administration-shell-1",
"specificAssetIds": [
{
"name": "supplierId",
"value": "aas-1"
},
{
"name": "customerId",
"value": "aas-2"
}
],
},
"submodels": [
{
"type": "ModelReference",
"keys": [
{
"type": "Submodel",
"value": "https://example.com/submodel-1"
}
]
},
{
"type": "ModelReference",
"keys": [
{
"type": "Submodel",
"value": "https://example.com/submodel-2"
}
]
}
]
}Comparison |
Result |
Comment |
|---|---|---|
|
true |
Both items are empty, therefore, they are equal. |
|
true |
|
|
false |
Both items are empty, therefore, they are equal. |
|
true |
Numeric comparison |
|
false |
Numeric comparison |
|
false |
Type mismatch |
|
true |
String comparison |
|
false |
String comparison |
|
false |
String comparison is executed character-wise: The first character of the left parameter ("1") comes before the first character of the right parameter ("2"). |
|
false |
|
|
true |
|
|
true |
Comparison of identical values |
|
false |
Comparison of identical values |
|
true |
By definition. |
|
false |
|
|
true |
|
|
true |
|
|
true |
|
|
false |
Booleans do not offer |
|
true |
"https://example.com/asset-administration" is a substring of the |
Logical expressions allow the combination of two or more single comparisons through AND or OR relations, and to negate the result of an expression. Furthermore, logical expressions can also be used to combine other logical expressions. Combinations with invalid results will be ignored, as explained above.
Logical Operator |
Description |
Definition |
|---|---|---|
|
Connects two or more expressions through a logical AND. |
Defined by https://www.w3.org/TR/xpath-30/#doc-xpath30-AndExpr |
|
Connects two or more expressions through a logical OR. |
Defined by https://www.w3.org/TR/xpath-30/#doc-xpath30-OrExpr |
|
Negates an expression. |
The "not" operator inverts the truth value of its operand. If the operand is true, the result is false, and if the operand is false, the result is true. Defined by https://www.w3.org/TR/xpath-functions-30/#func-not |
Paranthesises ( ) allow to combine logical expressions to define precedence. LogicalExpressions with paranthesises can be nested.
For explicite casting the following casting operators are used:
Casting Operator |
Description |
Definition |
|---|---|---|
|
Casts the |
Defined by https://www.w3.org/TR/xpath-functions-30/#func-string |
|
Casts the |
Defined by https://www.w3.org/TR/xpath-functions-30/#func-number |
|
Casts the |
Defined by https://www.w3.org/TR/xpath-functions-30/#func-dateTime |
|
Casts the |
Defined by https://www.w3.org/TR/xpath-functions-30/#func-boolean |
|
Casts the |
Defined by https://www.w3.org/TR/xpath-functions/#casting-to-binary |
|
Casts the |
Defined by https://www.w3.org/TR/xpath-functions/#casting-to-datetimes |
|
Casts the |
Defined by https://www.w3.org/TR/xpath-functions/#casting-to-datetimes |
Implicite casting is used together with FieldIdentifiers. FieldIdentifiers are generally treated as xs:string in the query language.
If a FieldIdentifier is used in a logicalExpression, it will be implicitely casted to xs:boolean, which can only create a valid result for the values true and false.
If a FieldIdentifier is used in a comparison, the second parameter decides implicite casting. If the second parameter is a constant (string, number, hex, boolean, dateTime, time) or a corresponding explicite casting operator, the value of the FieldIdentifier will be implicitely casted to the corresponding data type.
The AAS Metamodel defines several objects with lists as child elements, e.g., SubmodelElementList/value, AssetInformation/specificAssetIds, or Reference/keys. The AAS Query Language contains two different patterns to refer to elements inside these lists:
In case the position inside the list is known, the query can directly leverage the index number inside square brackets.
<fieldIdentifier>[<index>]
For the first element of a SubmodelElementList with the idShort "smlIdShort", this notation may lead to a following declaration:
$sme.<someIdShortPath>.smlIdShort[0]
For the first key of a semanticId reference, this notation may lead to a following declaration:
$sme.<someIdShortPath>#semanticId.keys[0]
In case the position in the list is not known, the index inside the square brackets can be skipped.
This means that at least one element has to fulfill the comparison to make the expression evaluate to true.
<fieldIdentifier>[]
To refer to any element inside a SubmodelElementList with the idShort "smlIdShort", this notation may lead to a following declaration:
$sme.<somePath>.smlIdShort[]
For any key of a semanticId reference, this notation may lead to a following declaration:
$sme.<somePath>#semanticId.keys[]
References include a list of keys, i.e. .keys[]. Very often the value of the first key in the list is needed, e.g. for semanticId.
To ease writing, .keys[0].value can be left off for References.
semanticId is defined as the "value" of the first key of the semanticId Reference object. The following two expressions are equivilant:
<somePath>.semanticId <somePath>.semanticId.keys[0].value
A comparison using the semanticId as a shortcut could look like the following:
$sme#semanticId $eq "https://example.com/a/semantic/id"
This shall also work for supplementalSemanticIds, e.g.:
$sme#supplementalSemanticIds $eq "https://example.com/a/supplemental/semantic/id"
Which is equivilant to:
$sme#supplementalSemanticIds[0].keys[0].value $eq "https://example.com/a/supplemental/semantic/id"
The $match operator signals that the following clauses (a) contain at least 1 list of elements with [] syntax, and that (b) all conditions shall be evaluated on the same element of this list.
The common path prefix left to a [] determines the list to be searched.
FieldIdentifiers in a $match may contain several [], which define nested lists. In such case the path prefix of the first [] must always be the same and the path prefixes of the following [] accordingly.
$match is similar to $and, since all conditions inside must result to true. But as explained above, [] can be specified in addition.
$match can include $match and comparisions. logicalExpressions are not allowed inside $match.
$match inside $match further restricts the subset of possible elements inside nested [].
Note 1: If the comparisons inside an $match clause contains expressions that are not pointing to the list under consideration, an error shall be returned.
The table illustrates the behavior using the example Asset Administration Shell above.
Comparison |
Result |
Comment |
|---|---|---|
|
[
{
"modelType": "AssetAdministrationShell",
"id": "https://example.com/asset-administration-shell-1",
...
}
] |
The values for 'supplierId' and 'aas-1' exist in the same SpecificAssetId object. |
|
|
The values for 'supplierId' and 'aas-2' do not exist in the same SpecificAssetId object. |
|
[
{
"modelType": "AssetAdministrationShell",
"id": "https://example.com/asset-administration-shell-1",
...
}
] |
The values for 'supplierId' and 'aas-2' exist in the example AAS, even though in different SpecificAssetId objects. As no |
|
[
{
"modelType": "AssetAdministrationShell",
"id": "https://example.com/asset-administration-shell-1",
...
}
] |
Both $match conditions are fulfilled, even though for different SpecificAssetIds. Therefore the OR clause also evaluates to |
The AAS Query Language does not introduce additional functionalities to control the pagination or sorting of the result sets. The general capabilities available for Operations apply as well for queries. See for instance Pagination for the pagination mechanism for the HTTP APIs, which also define the pagination and sorting behavior for AAS queries that are exchanged via HTTP.
The AAS HTTP API represents AAS Queries as JSON objects. A JSON schema according to the grammar above has been defined.
This JSON schema allows immediate validation of queries but also automatic code generation which has been validated with jsonschema2pojo.
To allow such automatic code generation, polymorhism by the use of oneOf in the JSON schema must be avoided.
In addition, several constructs introduced in BNF form require a slightly differing representation. For instance, a basic comparison follows the pattern <operand> <operator> <operand> but appears as "<operator>": [<operand>, <operand>] in the JSON representation.
JSON schema allows to use regular expressions. Such regular expressions are used to validate the syntax of FieldIdentifiers.
To be able to use common JSON schema validators, the depth and details have been limited in the corresponding regular expressions.
The table below explains the mapping between the grammar and the JSON schema. The table follows the structure of the JSON schema top to bottom.
JSON Schema |
Grammar |
Comment |
|---|---|---|
modelStringPattern |
<FieldIdentifier> |
AAS model elements are strings which start with a $ |
standardString |
All other value strings |
|
hexLiteralPattern |
<HexLiteral> |
|
dateTimeLiteralPattern |
<DateTimeLiteral> |
|
timeLiteralPattern |
<TimeLiteral> |
|
Value |
<operand> |
Comparisons eq, ne, gt, ge, lt, le; explicit properties for automatic code generation: strModel etc. |
stringValue |
<stringOperand> |
String operations contains, starts-with, ends-with, regex; explicit properties for automatic code generation: strModel etc. |
$field |
- |
string following the modelStringPattern |
$strVal |
- |
string following the standardString |
$attribute |
- |
explained in Security Access Rules; not used for query language |
$numVal |
<NumericalLiteral> |
Number constant |
$hexVal |
<HexLiteral> |
Hex number constant |
$dateTimeVal |
<DateTimeLiteral> |
DateTime constant |
$timeVal |
<TimeLiteral> |
Time constant |
$boolean |
<BoolLiteral> |
Boolean constant |
$strCast |
<castToString> |
any Value can be used as input |
$numCast |
<castToNumerical> |
any Value can be used as input |
$hexCast |
<castToHex> |
any Value can be used as input |
$boolCast |
<castToBool> |
any Value can be used as input |
$dateTimeCast |
<castToDateTime> |
any Value can be used as input |
$timeCast |
<castToTime> |
any Value can be used as input |
$dayOfWeek |
<dateTimeToNum> |
extract day of week from DateTime; needed for Security Access Rules |
$dayOfMonth |
<dateTimeToNum> |
extract day of month from DateTime; needed for Security Access Rules |
$month |
<dateTimeToNum> |
extract month from DateTime; needed for Security Access Rules |
$year |
<dateTimeToNum> |
extract year from DateTime; needed for Security Access Rules |
comparisonItems |
- |
Comparisons eq, ne, gt, ge, lt, le |
stringItems |
- |
String operations contains, starts-with, ends-with, regex |
matchExpression |
<matchExpression> |
nested match and comparisons and string operations |
logicalExpression |
<logicalExpression> |
nested logicalExpression (including match) and comparisons and string operations |
attributeItem |
- |
explained in Security Access Rules; not used for query language |
ACL |
- |
explained in Security Access Rules; not used for query language |
rightsEnum |
- |
explained in Security Access Rules; not used for query language |
AccessPermissionRule |
- |
explained in Security Access Rules; not used for query language |
AllAccessPermissionRules |
- |
explained in Security Access Rules; not used for query language |
$condition |
<logicalExpression> |
Root object for the query condition expression |
$select |
<selectStatement> |
Optional expresion to control the returned fields. Only 'id' is possible. |
Single comparison
Grammar |
JSON Schema |
|---|---|
|
{
"$condition": {
"$eq": [
{ "$field": "$aas#idShort" },
{
"$field":
"$aas#assetInformation.assetType"
}
]
}
} |
HandoverDocumentation with VDI 2770 Class 03-01 Commissioning and language NL (as expected with SubmodelElementList)+
Grammar |
JSON Schema |
|---|---|
|
{
"$condition": {
"$match": [
{ "$eq": [
{ "$field": "$sme.Documents[].
DocumentClassification.Class
#value" },
{ "$strVal": "03-01" }
]
},
{ "$eq": [
{ "$field": "$sme.Documents[].
DocumentVersion.SMLLanguages[]
#language" },
{ "$strVal": "nl" }
]
}
]
}
} |
TechnicalData with motor starter (ECLASS ClassId = 27-37-09-05) and width less than 100 mm
Grammar |
JSON Schema |
|---|---|
|
{
"$condition": {
"$and": [
{ "$match": [
{ "$eq": [
{ "$field": "$sm#idShort" },
{ "$strVal": "TechnicalData" }
]
},
{ "$eq": [
{
"$field":
"$sme.ProductClassifications[]
.ProductClassId#value"
},
{ "$strVal": "27-37-09-05" }
]
}
]
},
{ "$match": [
{
"$eq": [
{ "$field": "$sm#idShort" },
{ "$strVal": "TechnicalData" }
]
},
{
"$eq": [
{ "$field": "$sme#semanticId" },
{ "$strVal": "0173-1#02-BAF016#006" }
]
},
{
"$lt": [
{ "$field": "$sme#value" },
{ "$numVal": 100 }
]
}
]
}
]
}
} |
Match specificAssetIDs
Grammar |
JSON Schema |
|---|---|
|
{
"$condition": {
"$or": [
{
"$match": [
{ "$eq": [
{ "$field": "$aas#assetInformation.
specificAssetIds[].name" },
{ "$strVal": "supplierId" }
]
},
{ "$eq": [
{ "$field": "$aas#assetInformation
.specificAssetIds[].value" },
{ "$strVal": "aas-1" }
]
}
]
},
{
"$match": [
{
"$eq": [
{ "$field": "$aas#assetInformation
.specificAssetIds[].name" },
{ "$strVal": "customerId" }
]
},
{
"$eq": [
{ "$field": "$aas#assetInformation
.specificAssetIds[].value" },
{ "$strVal": "aas-2" }
]
}
]
}
]
}
} |