class user {}
query q2() = (user,user) @ { } ;

class user {}
query q2() = (user) @ { } ;

grammar org.blockchain.rell.Rell with org.eclipse.xtext.common.Terminals

generate rell "http://www.blockchain.org/rell/Rell"

Model:
	entities+=ClassDefinition*
	operations+=Query*;

ClassDefinition:
	'class' name=ID LEFT_BRACE
	attributeListField+=AttributeListField*
	RIGHT_BRACE;

AttributeListField:
	mutable=Mutable? key=Key? index=Index? attributeList+=RelAttrubutesList ';';

Query:
	"query" name=ID LEFT_BRACKET parameters=RelAttrubutesList? RIGHT_BRACKET
	(DOUBLE_QUOTE type=TypeReference)?
	((ASSIGNMENT returnExr=Expression ';') |
	(LEFT_BRACE
	statements+=Statement*
	(('return' returnExr=Expression ';')?)
	RIGHT_BRACE));

Statement:
	(relation=Relational | methodCall=DotValue) ';';

Variable:
	name=VariableDeclaration ((ASSIGNMENT expression=Expression)?);

Relational:
	AtOperator;

AtOperator:
	(tableNameWithAlias+=TableNameWithAlias |
	(LEFT_BRACKET
	tableNameWithAlias+=TableNameWithAlias (',' tableNameWithAlias+=TableNameWithAlias)*
	RIGHT_BRACKET))
	Ampersand
	(ampersandModificator=AmpersandModificator?)
	LEFT_BRACE
	(ASSIGNMENT? conditions+=Expression (',' ASSIGNMENT? conditions+=Expression)*)?
	RIGHT_BRACE
	(tupleValue=TupleValue?);

TupleValue:
	LEFT_BRACKET members+=TupleValueMember (',' tuplePart+=TupleValueMember)* RIGHT_BRACKET;

TupleValueMember:
	(name=ValuableID ASSIGNMENT)? value=Expression;

TableNameWithAlias:
	classRefDecl=ClassRefDecl |
	justNameDecl=JustNameDecl;

ClassRefDecl:
	name=ID DOUBLE_QUOTE classDef=[ClassDefinition];

JustNameDecl:
	name=[ClassDefinition];

VariableDeclarationRef:
	name=[VariableDeclaration|ValuableID];

AccessToList:
	LEFT_SQUARE_BRACE expr=Expression RIGHT_SQUARE_BRACE;

Expression:
	or=Or;

Or returns Expression:
	And ({Or.left=current} "or" right=And)*;

And returns Expression:
	Equality ({And.left=current} "and" right=Equality)*;

Equality returns Expression:
	Comparison ({Equality.left=current} op=EQUALS
	right=Comparison)*;

Comparison returns Expression:
	PlusOrMinus ({Comparison.left=current} op=IN
	right=PlusOrMinus)*;

PlusOrMinus returns Expression:
	MulOrDiv (({Plus.left=current} PlusChar | {Minus.left=current} MinusChar)
	right=MulOrDiv)*;

MulOrDiv returns Expression:
	Primary ({MulOrDiv.left=current} op=(MulChar)
	right=Primary)*;

Primary returns Expression:
	prefixChar=MinusChar expression=Primary |
	DotValue;

DotValue:
	(LEFT_BRACKET DotValue RIGHT_BRACKET) | ((atom=Atomic (accesToList=AccessToList?) (DOT dotPart=DotValue)?));

Atomic returns Expression:
	{SelectOp} value=AtOperator
	| {TupleRes} value=TupleValue
	| {VariableDeclarationRef} value=VariableDeclarationRef;

RelAttrubutesList:
	value+=Variable (',' value+=Variable)*;

VariableDeclaration:
	name=ValuableID ((DOUBLE_QUOTE type=TypeReference)?);

TypeReference:
	type=PrimitiveType;

PrimitiveType:
	Text;

ValuableID:
	PrimitiveType | ID;

AmpersandModificator:
	PlusChar | MulChar | QuestionChar;

Text:
	'text';

Key:
	'key';

Index:
	'index';

Mutable:
	'mutable';

Ampersand:
	'@';

QuestionChar:
	'?';

PlusChar:
	'+';

MinusChar:
	'-';

MulChar:
	'*';

terminal IN:
	'in';

terminal RIGHT_SQUARE_BRACE:
	']';

terminal LEFT_SQUARE_BRACE:
	'[';

terminal RIGHT_BRACE:
	'}';

terminal LEFT_BRACE:
	'{';

terminal RIGHT_BRACKET:
	')';

terminal LEFT_BRACKET:
	'(';

terminal ASSIGNMENT:
	'=';

terminal EQUALS:
	'==';

terminal DOUBLE_QUOTE:
	':';

terminal DOT:
	'.';

options = {
					backtrack = true
				}