Expression Grammatik

Quino enthält eine einfache Sprache für Ausdrücke welche innerhalb der Applikation verwendet werden kann um Filter oder Bedingung zu erstellen. Es ist auch Möglich Werte aus dem Expression Daten-Kontext und von Funktionen zu zuzugreifen.

Daten-Kontext

Expressions werden in einem Kontext ausgewertet. Dieser bezieht sich auf die Daten eines Datensatzes in der die Expression ausgeführt wird.

Für den Aufbau sehen Sie Expression Daten-Kontext

Basistypen

Type	Beispiel	XML
Ganze Zahlen	`6`
Dezimalzahlen	`45.678` oder `45.678f`
Dezimalzahlen (hohe Präzision)	`45.678m`
null - Konstante	`null`
Boolsche - Konstanten	`true`, `false`
Einfache Zeichenkette mit ''	`'A ''quoted'' string'`
Alternative Zeichenkette mit ““	`"A \"quoted\" string"`	Nicht zulässig. Hier müssen die einfachen Hochkommas verwendet werden.
Liste	`[A, B, 2, "three"]`

Sehen Sie auch Expression Typen

Operatoren

Vergleichsoperatoren

Die folgenden Operatoren vergleichen zwei Werte. Die Operatoren machen am meisten Sinn für numerische Vergleiche. Jedoch sind auch Vergleiche mit anderen Typen möglich.

Operator	XML	Beschreibung	Beispiel	Resultat
`==`		Gleich	`2 == 2`	Wahr
`!=`		Nicht gleich	`2 != 2`	Falsch
`>`	`>`	Grösser als	`2 > 2`	Falsch
`<`	`<`	Kleiner als	`2 < 2`	Falsch
`>=`	`>=`	Grösser als oder gleich	`2 >= 2`	Wahr
`<=`	`<=`	Kleiner als oder gleich	`2 <= 2`	Wahr

String Operatoren

Die folgenden Operatoren können für Zeichenketten verwendet werden. CI referenziert dabei auf Case Insensitive. Die anderen Methoden berücksichtigten Gross-/Kleinschreibung.

Operator	Synonym	Beschreibung	Beispiel	Resultat
`%=`	`BeginsWith()`	Startet mit	`'bla' %= 'b'`	Wahr
`=%`	`EndsWith()`	Endet mit	`'bla' =% 'a'`	Wahr
`%=%`	`Contains()`	enthält	`'bla' %=% 'la'`	Wahr
`~~`	`EqualsCI()`	Gleich*	`'bla' ~~ 'Bla'`	Wahr
`!~`	`NotEqualsCI()`	Nicht gleich*	`'bla' !~ 'Bla'`	Falsch
`%~`	`BeginsWithCI()`	Startet mit*	`'bla' %= 'B'`	Wahr
`~%`	`EndsWithCI()`	Endet mit*	`'bla' =% 'A'`	Wahr
`%~%`	`ContainsCI()`	Enthält*	`'bla' %=% 'LA'`	Wahr

Arithmetische Operatoren

Für arithmetische Funktionen stehen folgende Operatoren zur Verfügung:

Operator	Beschreibung	Typen	Beispiel	Resultat
`*`	Multiplikation	Numerisch	`2 * 2`	4
`/`	Division	Numerisch	`2 / 2`	1
`+`	Addition	Numerisch, DateTime, TimeSpan	`2 + 2`	4
`-`	Subtraktion	Numerisch, DateTime, TimeSpan	`2 - 2`	0
`^`	Potenz	Numerisch	`2 ^ 3`	8
`%`	Modulo	Numerisch	`3 % 2`	1

Boolsche Operatoren

Folgende “verbindende” Operatoren stehen zur Verfügung:

Operator	XML	Beschreibung	Beispiel	Resultat
`&&`	`&&`	und	`true && false`	Falsch
`\|\|`		oder	`true \|\| false`	Wahr
`!`		nicht	`!true`	Falsch

Regular Expressions

Operator	Synonym	Beschreibung	Beispiel	Resultat
`=@`	`Matches()`	matches regular expression	`'bla' =@ 'b*'`	true
`~@`	`MatchesCI()`	matches regular expression CI	`'bla' ~@ 'B*'`	true

See Expression Reguläre Ausdrücke for more information.

Null-handling

Use the following operators to test for and handle null values.

Operator	Synonym	Beschreibung	Typen	Beispiel	Resultat
`?`	`IsNull()`	unary IS NULL	Any	?null	true
`!?`	`IsNotNull()`	unary IS NOT NULL	Any	!?null	false
`??`	`Coalesce()`	Null-coalescing	Any	null ?? 2	2

Type-casting

The type-cast operator allows an application to transform the type directly. Any number with a decimal point is automatically a floating-point number. Use the m suffix to make it the money type instead. For some other common types, there are standard functions that are more flexible than type-casting (see custom dates and time functions and custom Guid functions).

Operator	Beschreibung	Typen	Beispiel	Resultat
`()`	Type-cast	Typename, Any	(int)value	value (w/type 'int')

A product can create expressions that return specific types using the MetaType, as shown in the examples below.

Example	.NET Type of result
`(Boolean)'true'`	`bool`
`(Date)"2020-01-01"`	`DateTime`
`(DateTime)"2020-01-01 12:00:00"`	`DateTime`
`(Time)"15:14:13"`	`DateTime`
`(TimeSpan)"15:14:13"`	`TimeSpan`
`(TinyInteger)12`	`byte`
`(SmallInteger)12`	`short`
`(Integer)12`	`int`
`(LargeInteger)12`	`long`
`(Currency)12`	`decimal`
`(Double)12`	`double`
`(Guid)'D0A64D79-C2ED-470C-B8AF-4285C96AD415'`	`Guid`
`(Text)12`	`string`

A product can also use any available, fully-qualified .NET type name, as shown in the examples below.

Example	Result
(System.DayOfWeek)5	`DayOfWeek.Friday`
(System.DateTime)"2020-01-01 12:00:00"	`DateTime` object representing "2020-01-01 12:00:00"
(System.TimeSpan)"15:14:13"	`TimeSpan` object representing "15:14:13"

Lists

Use the following operators with lists.

Operator	Beschreibung	Typen	Beispiel	Resultat
`in`	Containment	Any	Array	1 in [1,2,3]

Several of the operators above can be applied to all elements of a list using a list operator. For example, the expression [+::1,1,2,3] evaluates to 1 + 1 + 2 + 3.

The following operators work with lists:

&&
||
#
+
-
*
^

Operator Precedence

Operator precedence is enforced with staggered productions in the grammar and consists of five precedence levels (from most-binding to least):

Level	Operators
1	`^`, `#`, `=>`
2	`*`, `/`, `%`, `&&`
3	`+`, `-`, `
4	`==`, `!=`, `~~`, `!~`, `<`, `>`, `<=`, `>=`, `in`, `%=`, `=%`, `%=%`, `%~`, `~%`, `%~%`, `~@`, `=@`
5	`??`

The following examples show how precedence affects expressions and how to use parentheses to change the precedence.

Example	Result
`1 + 1 * 2`	`3`
`(1 + 1) * 2`	`4`
`6 / 2 * 3`	`9`
`6 / (2 * 3)`	`1`

Funktionen

The function-call and indexing syntax is also relatively standard.

Type	Example
Function calls	`A(2, "B")` or `A()`
Indexed calls	`A[2, "B"]`

The namespace is always required, except for functions defined in the Global namespace.

For example, Global.EndOfTime() and EndOfTime() are equivalent.

Genaue Auflistung der Funktionen unter: