Namespaces
One important feature of IQL is the integration of Java types. The DSL can refer to Java types from Java standard libraries, Odysseus Bundles or other external libraries. Namespaces are useful in this context to refer Java types by a simple name and not by a fully qualified name. The static-keyword allows the static methods of a java class to be referenced without qualifying the class name.
ID ::= ("a".."z"|"A".."Z"|"_")("a".."z"|"A".."Z"|"_"|"0".."9")*.
QName ::= ID ("::" ID)*
Namespace ::= "use" ("static")? QualifiedNameWithWildcard ";".
QualifiedNameWildcard ::= QualifiedName ("::*")?
use java::util::*; use de::uniol::inf::is::odysseus::core::ISubscription; use com::google::common::collect::ImmutableMap; use static java::lang::System;
Class, Interface
Besides the integration of Java types it is also possible to create your own classes and interfaces.
Class ::= "class" ID ("extends" QName)? ("implements" QName ("," QName)*)? "{" (Attribute | Method)* "}".
Interface ::= "interface" ID ("extends" QName ("," QName)*)? "{" (MethodDeclaration)* "}".
Attribute ::= VariableDeclaration (VariableInit)? ";".
VariableDeclaration ::= Type ID.
Type ::= (PrimitiveType | QName) ("[" "]")*.
PrimitiveType ::= "boolean" | "byte" | "char" | "short" | "int" | "float" | "long" | "double".
Method ::= ("override")? MethodDeclaration StatementBlock.
MethodDeclaration ::= ID (MethodParameters)? (":" Type)?.
MethodParameters ::= "(" (VariableDeclaration ("," VariableDeclaration)*)? ")".
class Point implements IPoint{
int x;
int y;
Point(int x, int y) {
this.x = x;
this.y = y;
}
override getX() : int{
return this.x;
}
override getY() : int{
return this.y;
}
}
interface IPoint {
getX() : int;
getY() : int;
}
Statements
Methods, constructors and other blocks are sequences of statements. They can be divided into atomic and compound statements. Atomic statements are not made up of other statements and end with a semicolon (e.g. VariableStatement). Compound statements (also called control structures) contain other statements (e.g. WhileStatement).
Statement ::= ( StatementBlock | IfStatement | SwitchStatement | WhileStatement | DoWhileStatement | ForStatement | ForEachStatement
| VariableStatement | ConstructorStatement | ExpressionStatement | BreakStatement | ContinueStatement | ReturnStatement ).
StatementBlock ::= "{" (Statement)* "}".
IfStatement ::= "if" "(" Expression ")" Statement ("else" Statement)?.
SwitchStatement ::= "switch" "(" Expression ")" "{" ("case" Expression ":" (Statement)*)* ("default" ":" (Statement)*)? "}"
WhileStatement ::= "while" "(" Expression ")" Statement.
DoWhileStatement ::= "do" Statement "while" "(" Expression ")" ";".
ForStatement ::= "for" "(" VariableDeclaration ";" Expression ";" Expression ")" Statement.
ForEachStatement ::= "for" "(" VariableDeclaration ":" Expression ")" Statement.
VariableStatement ::= VariableDeclaration VariableInit ";".
ConstructorStatement ::= ("super" | "this") "(" (ArgsList)? ")" ";".
ExpressionStatement ::= Expression ";".
BreakStatement ::= "break" ";".
ContinueStatement ::= "continue" ";".
ReturnStatement ::= "return" (Expression)? ";".
int i = 2;
if (i>2) {
}
int i = 2;
switch(i) {
case 2 :
return true;
case 4 :
return true;
default :
return false;
}
int i = 2;
while (i>2) {
}
do {
} while (i>2);
for (int j = 0; j<10; j++) {
}
List list = [1,2,3];
for (Object element : list) {
}
A new object can be created by calling a constructor. It is also possible to assign values to attributes in this context. This makes it easier to configure operators when building a query with QDL because it is not necessary to create a new statement for each parameter.
// Constructor Call
Point p1 = new Point(2, 5);
Point p2(2,5);
// Assigning values to attributes
Point p3 = new Point{x = 2, y = 5};
Point p4{x = 2, y = 5};
Select sel{predicate="bid.price <=200"};
Project proj(sel){attributes=[bid.PRICE]};
Expressions
An expression is used as part of other expressions or statements and produces a value as result.
Expression ::= ( AssignmentExpression | LogicalExpression | EqualityExpression | ArithmeticExpression | UnaryExpression | CastExpression
| PrefixExpression | PostfixExpression | InstanceOfExpression | CreateExpression | AttributeExpression | MethodExpression
| ArrayExpression | "this" | "super" | ID | LiteralExpression | ("(" Expression ")").
AssignmentExpression ::= Expression ("=" | "+=" | "-=" | "*=" | "/=" | "%=") Expression.
LogicalExpression ::= Expression ("&&" | "||") Expression.
EqualityExpression ::= Expression ("==" | "!=" | ">" | ">=" | "<" | "<=") Expression.
ArithmeticExpression ::= Expression ("+" | "-" | "*" | "/"| "%") Expression.
UnaryExpression ::= ("+" | "-" | "!") Expression.
CastExpression ::= "(" Type ")" Expression.
PrefixExpression ::= ("++" | "--") Expression.
PostfixExpression ::= Expression ("++" | "--").
InstanceOfExpression ::= Expression "instanceof" Type.
NewExpression ::= "new" QName (("[" "]") | (("(" (ArgsList)? ")")? ("{" ArgsMap "}")?)).
MemberCallExpression ::= (Expression ".")? ID ("(" (ArgsList)? ")")?.
ArrayExpression ::= Expression ("[" ArgsList "]")+.
LiteralExpression ::= Integer | Double | Boolean | Char | String | Range | List | Map | Null
VariableInit ::= ((("(" (ArgsList)? ")")? ("{" ArgsMap "}")?) | ("=" Expression)).
ArgsList ::= Expression ("," Expression)*.
ArgsMap ::= ArgsMapKeyValue ("," ArgsMapKeyValue)*.
ArgsMapKeyValue ::= ID "=" Expression
If a data type has a getter- or setter-method there will always be a corresponding attribute to access. So it is often possible to use assignment expressions instead of method calls.
Tuple tuple = createTuple(); ITimeInterval time = tuple.metadata; tuple.metadata = time; //is equivalent to ITimeInterval time1 = tuple.getMetadata(); tuple.setMetadata(time1);
Metadata
Metadata ::= ID "=" MetadataValue.
MetadataValue ::= MetadataValueSingle | MetadataValueList | MetadataValueMap.
MetadataValueSingle ::= INTEGER | Double | CHAR | STRING | BOOLEAN | QName.
MetadataValueList ::= "[" (MetadataValue ("," MetadataValue)*)? "]".
MetadataValueMap ::= "[" (MetadataValueMapEntry ("," MetadataValueMapEntry)*)? "]".
MetadataValueMapEntry ::= MetadataValue ":" MetadataValue.
See operators in ODL or queries in QDL for examples.
Literals
Literals are sequence of characters that represent constant values to be stored in variables.
Integer ::= (0..9)+.
Double ::= (0..9)* "." (0..9)+.
Boolean ::= ("true" | "false").
Char ::= "'" Unicode-Character "'".
String ::= '"' (Unicode-Character)* '"'.
Range ::= (0..9)+ ".." (0..9)+.
List ::= "[" (Expression ("," Expression)*)? "]".
Map ::= "[" (MapKeyValue ("," MapKeyValue)*)? "]".
MapKeyValue ::= Expression ":" Expression.
Null ::= "null".
Range r = 1..10; List l = [1, 2, 3]; Map m = ["key1":1, "key2":2]; Tuple t = [5, true, 3.4]; IPunctuation p = 100;
Java-Code
IQL-code is always translated into Java-code. Sometimes it might be useful to write Java-code directly instead of IQL-code.
GPLCode ::= "$*" GPL Code "*$"
$*
public static void main(String[] args) {
}
*$
Comments
IQL supports single- and multi-line comments.
Comment ::= SingeLineComment | MultiLineComment.
SingeLineComment ::= "//" Text (("\r")? "\n")?.
MultiLineComment ::= "/*" Text "*/".
// This is a single line comment /* * This is a multi line comment */