JPA-SQL Language Specification

Script:
	ImportStatement*
	QueryMethod*
;

ImportStatement:
	'import' QualifiedName;

QueryMethod:
	DocComment?
	ID '(' (Parameter (',' Parameter)*)? ')'
	'{'
		SelectStatement
	'}'
;

Parameter:
	Type ID;

Type:
	PrimitiveType | 
	QualifiedName
;
	
SelectStatement:
	(
	SelectClause? &
	FromClause
	)
	JoinClause*
	(
	WhereClause? &
	GroupByClause? &
	OrderByClause? &
	OffsetClause? &
	LimitClause? &
	ResultClause? &
	LockModeClause? &
	FetchClause? &
	IntoClause?
	)
;

SelectClause:
	'select' 'distinct'? Selection;

Selection:
	'*' |
	SelectionElement (',' SelectionElement)*
;
	
SelectionElement:
	Expression Alias?;

FromClause:
	'from' FromElement (',' FromElement)*;
	
FromElement:
	QualifiedName Alias?;
	
JoinClause:
	JoinType? 'join' JoinElement Alias? OnClause?;

JoinElement:
	AttributeRef;
	
OnClause:
	'on' Condition;	

WhereClause:
	'where' Condition;

GroupByClause:
	'group' 'by' GroupByElement (',' GroupByElement)* HavingClause?;

GroupByElement:
	Expression;

HavingClause
	'having' Condition;

OrderByClause:
	'order' 'by' OrderByElement (',' OrderByElement)*;

OrderByElement:
	Expression Order?;
	
OffsetClause:
	'offset' PaginationValue;

LimitClause:
	'limit' PaginationValue;

PaginationValue:
	IntegerLiteral | 
	ParameterRef
;

ResultClause:
	'result' ResultCount;
	
LockModeClause:
	'lockmode' LockModeType;
	
FetchClause:
	'fetch' FetchElement (',' FetchElement)*;
	
FetchElement:
	AttributeRef;	
	
IntoClause:
	'into' Type | 'tuple';
	
Alias:
	'as' ID;	

Condition:
	ConditionalOR;

ConditionalOR:
	ConditionalAND ('or' ConditionalAND)*;

ConditionalAND:
	ConditionalNOT ('and' ConditionalNOT)*;

ConditionalNOT:
	ConditionalPrimary | ('not' ConditionalPrimary);

ConditionalPrimary:
	('(' ConditionalOR ')') |
	BooleanExpression
;
	
BooleanExpression:
	Expression
	(
		(ComparisonOperator ComparisonExpressionRight) |
		('between' Expression 'and' Expression) |
		('like' Expression ('escape' Expression)?) |
		('in' '(' CollectionExpression ')')
	) |
	('exists' '(' SubQuery ')')
;

ComparisonExpressionRight:
	Expression | 
	CollectionComparisonExpression
;

CollectionComparisonExpression:
	CollectionComparisonFunction '(' SubQuery ')';

CollectionExpression:
	(Expression (',' Expression)*) | 
	SubQuery
;

Expression:
	ArithmeticLine;

ArithmeticLine:
	ArithmeticTerm (AddSubOperator ArithmeticTerm)*;

ArithmeticTerm:
	ArithmeticFactor (MultDivOperator ArithmeticFactor)*;

ArithmeticFactor:
	ArithmeticPrimary | (AddSubOperator ArithmeticPrimary);

ArithmeticPrimary:
	('(' (ArithmeticLine | SubQuery) ')') | 
	AttributeRef |
	Literal |
	Function |
	AggregateExpression
;

Function:
	LengthFunction |
	LocateFunction |
	ModFunction |
	AbsFunction |
	SizeFunction |
	SqrtFunction |
	UpperFunction |
	LowerFunction |
	ConcatFunction |
	SubstringFunction |
	TrimFunction |
	CurrentDateFunction |
	CurrentTimeFunction |
	CurrentTimestampFunction |
	CustomFunction
;

LengthFunction:
	'length' '(' Expression ')';
	
LocateFunction:
	'locate' '(' Expression ',' Expression (',' Expression)? ')';
	
ModFunction:
	'mod' '(' Expression ',' Expression ')';
	
AbsFunction:
	'abs' '(' Expression ')';
	
SizeFunction:
	'size' '(' Expression ')';
	
SqrtFunction:
	'sqrt' '(' Expression ')';

UpperFunction:
	'upper' '(' Expression ')';

LowerFunction:
	'lower' '(' Expression ')';
	
ConcatFunction:
	'concat' '(' Expression ',' Expression ')';
	
SubstringFunction:
	'substring' '(' Expression ',' Expression (',' Expression)? ')';

TrimFunction:
	'trim' '(' TrimSpecifiction? Expression? 'from' Expression ')';

// since 3.1.1
CustomFuction:
	'function' '(' StringLiteral ',' Type (',' Expression)* ')'

CurrentDateFunction:
	'current_date' ('(' ')')?;

CurrentTimeFunction:
	'current_time' ('(' ')')?;

CurrentTimestampFunction:
	'current_timestamp' ('(' ')')?;

SubQuery:
	(
	SelectClause? &
	FromClause
	)
	(
	WhereClause? &
	GroupByClause? &
	OrderByClause? &
	OffsetClause? &
	LimitClause?
	)
;	
	
AggregateExpression:
	AggregateFunction '(' Expression ')';

AttributeRef:
	AttributeRefStart ('.' AttributeRefPart)*;

AttributeRefStart:
	SimpleName |
	ParameterRef
;

AttributeRefPart:
	SimpleName;
	
SimpleName:
	ID;
	
QualifiedName:
	ID ('.' ID)*;

ParameterRef:
	':' Parameter;

Literal:
	NumericLiteral | StringLiteral | CharacterLiteral | BooleanLiteral | NullLiteral;

NumericLiteral:
	IntegerLiteral | DoubleLiteral;

IntegerLiteral:
	INT;

DoubleLiteral:
	DOUBLE;

StringLiteral:
	STRING;

CharacterLiteral:
	CHAR;

BooleanLiteral:
	'true'|'false';

NullLiteral:
	'null';

enum PrimitiveType:
	byte | short | int | long | float | double | boolean | char;
	
enum JoinType:
	inner | left | right;	
	
enum Order:
	asc | desc;
	
enum AggregateFunction:
	avg | min | max | sum | sumAsLong | sumAsDouble | count | countDistinct;

enum CollectionComparisonFunction:
	all | any | some;

enum TrimSpecifiction:
	both | // default
	leading | 
	trailing;
	
enum AddSubOperator
	plus='+' | minus='-';
	
enum MultDivOperator:
	mult='*' | div='/';		

enum ComparisonOperator:
	lessThan='<' |
	greaterThan='>' |
	lessEqual='<=' |
	greaterEqual='>=' |
	equal='=' |
	notEqual='!=' |
	notEqual2='<>'
;
	
enum ResultCount:
	list | // default 
	single;
	
enum LockModeType:
	NONE='none' |
	READ='read' |
	WRITE='write' |
	OPTIMISTIC='optimistic' |
	OPTIMISTIC_FORCE_INCREMENT='optimisticForceIncrement' |
	PESSIMISTIC_READ='pessimisticRead' |
	PESSIMISTIC_WRITE='pessimisticWrite' |
	PESSIMISTIC_FORCE_INCREMENT='pessimisticForceIncrement'
;