SparqlParser.g4

/*
 *    Copyright 2007-2013 The sparkle-g Team
 *
 *    Licensed under the Apache License, Version 2.0 (the "License");
 *    you may not use this file except in compliance with the License.
 *    You may obtain a copy of the License at
 *
 *       http://www.apache.org/licenses/LICENSE-2.0
 *
 *    Unless required by applicable law or agreed to in writing, software
 *    distributed under the License is distributed on an "AS IS" BASIS,
 *    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 *    See the License for the specific language governing permissions and
 *    limitations under the License.
 */

/**
 * @author Simone Tripodi   (simone.tripodi)
 * @author Michele Mostarda (michele.mostarda)
 * @author Juergen Pfundt   (Juergen.Pfundt)
 * @version $Id: Sparql.g 523 2012-02-17 23:10:57Z Juergen.Pfundt@gmail.com $
 */
parser grammar SparqlParser;

options{
tokenVocab=SparqlLexer;
language=Cpp;
}

// $<Parser

query
    : prologue (selectQuery | constructQuery | describeQuery | askQuery)? valuesClause EOF
    | updateCommand EOF
    ;

prologue
    : (baseDecl | prefixDecl)*
    ;

baseDecl
    : BASE IRIREF
    ; 

prefixDecl
    : PREFIX PNAME_NS IRIREF
    ;

selectQuery
    : selectClause datasetClause* whereClause solutionModifier
    ;

subSelect
    : selectClause whereClause solutionModifier valuesClause
    ;
    	
selectClause
    : hintsClause SELECT selectModifier? (selectVariables+ | '*')
    ;

selectModifier
    : DISTINCT | REDUCED
    ;

selectVariables
    : var
    | '(' expression AS var ')'
    ;

constructQuery
    : hintsClause CONSTRUCT (constructTemplate datasetClause* whereClause solutionModifier | datasetClause* WHERE '{' triplesTemplate? '}' solutionModifier)
    ;

describeQuery
    : DESCRIBE describeAlgorithm? (varOrIRI+ | '*') datasetClause* whereClause? solutionModifier
    ;

askQuery
    : hintsClause ASK datasetClause* whereClause solutionModifier
    ;

// NOT PART OF THE OFFICIAL GRAMMAR (tentris specific)
// NOTE: The order matters (if there is a variableOrdering hint, it must be provided before the cardinalityEstimation hint)
hintsClause
    : variableOrdering? cardinalityEstimation?
    ;

// NOT PART OF THE OFFICIAL GRAMMAR (tentris specific)
variableOrdering
    : Q_HINT_VAR_ORD varOrBlankNode+
    ;

// NOT PART OF THE OFFICIAL GRAMMAR (tentris specific)
cardinalityEstimation
    : Q_HINT_CARD_EST (CARD_EST_REDUCTION_FACTOR|CARD_EST_MIN_CARDINALITY)
    ;

// NOT PART OF THE OFFICIAL GRAMMAR (tentris specific)
describeAlgorithm
    :  (CONCISE_BOUNDED_DESCRIPTION|DESCRIBE_DIRECT)
    ;

varOrBlankNode
    : var | blankNode
    ;

datasetClause
    : FROM NAMED? iri
    ;

whereClause
    : WHERE? groupGraphPattern
    ;

solutionModifier
    : groupClause? havingClause? orderClause? limitOffsetClauses?
    ;

groupClause
    : GROUP BY groupCondition+
    ;
    		 
groupCondition
    : builtInCall | functionCall | '(' expression (AS var)? ')' | var
    ;
    
havingClause
    : HAVING havingCondition+
    ;
    
havingCondition
    : constraint
    ;
    
orderClause
    : ORDER BY orderCondition+
    ;

orderCondition
    : (ASC|DESC) '(' expression ')' 
    | constraint 
    | var
    ;
	    
limitOffsetClauses
    : limitClause offsetClause? | offsetClause limitClause?
    ;

limitClause
    : LIMIT INTEGER
    ;

offsetClause
    : OFFSET INTEGER
    ;

valuesClause
    : (VALUES dataBlock)?
    ;
    
updateCommand
    : prologue (update (';' prologue update)* (';' prologue)?)?
    ;

update
    : load | clear | drop | add | move | copy | create | insertData | deleteData | deleteWhere | modify
    ;   
    
load 	  
    : LOAD SILENT? iri (INTO graphRef)?
    ;
    
clear
    : CLEAR  SILENT? graphRefAll
    ;
    
drop
    : DROP SILENT? graphRefAll
    ; 

create
    : CREATE SILENT? graphRef
    ;
    
add
    : ADD SILENT? graphOrDefault TO graphOrDefault
    ;
    
move
    : MOVE SILENT? graphOrDefault TO graphOrDefault
    ;
    
copy
    : COPY SILENT? graphOrDefault TO graphOrDefault
    ;

insertData
    : INSERT DATA quadData
    ;

deleteData
    : DELETE DATA quadData
    ;

deleteWhere
    : DELETE WHERE quadPattern
    ;
    
modify
    : (WITH iri)? (deleteClause insertClause? | insertClause) usingClause* WHERE groupGraphPattern
    ;
  
deleteClause
    : DELETE quadPattern
    ;
      
insertClause
    : INSERT quadPattern
    ;

usingClause
    : USING NAMED? iri
    ;

graphOrDefault	  
    : DEFAULT | GRAPH? iri
    ;
    	    	
graphRef
    : GRAPH iri
    ;

graphRefAll
    : graphRef | DEFAULT | NAMED | ALL
    ;

quadPattern
    : '{' quads '}'
    ;
    
quadData
    : '{' quads '}'
    ;
    
quads
    : triplesTemplate? quadsDetails* 
    ;

quadsDetails
    : quadsNotTriples '.'? triplesTemplate?
    ;

quadsNotTriples
    : GRAPH varOrIRI '{' triplesTemplate? '}'
    ;
    
triplesTemplate
    : triplesSameSubject ('.' triplesSameSubject?)*
    ;
    	
groupGraphPattern
    : '{' (subSelect | groupGraphPatternSub) '}'
    ;
    
groupGraphPatternSub
    : triplesBlock?  groupGraphPatternSubList*
    ;
    
groupGraphPatternSubList
    : graphPatternNotTriples '.'? triplesBlock?
    ;
    
triplesBlock
    :  triplesSameSubjectPath ('.' triplesSameSubjectPath?)*
    ;

graphPatternNotTriples
    : groupOrUnionGraphPattern | optionalGraphPattern | minusGraphPattern | graphGraphPattern | serviceGraphPattern | filter | bind | inlineData
    ;

optionalGraphPattern
    : OPTIONAL groupGraphPattern
    ;

graphGraphPattern
    : GRAPH varOrIRI groupGraphPattern
    ;

serviceGraphPattern
    : SERVICE SILENT? varOrIRI groupGraphPattern
    ;
    
bind
    : BIND '(' expression AS var ')'
    ;
    	
inlineData
    : VALUES dataBlock
    ;

dataBlock
    : inlineDataOneVar | inlineDataFull
    ;

inlineDataOneVar
    : var '{' dataBlockValue* '}'
    ;

inlineDataFull
    : '(' var* ')' '{' dataBlockValues* '}'
    ;

dataBlockValues
    : '(' dataBlockValue* ')'
    ;

dataBlockValue
    : iri | rdfLiteral | numericLiteral | booleanLiteral | UNDEF
    ;

minusGraphPattern
    : MINUS groupGraphPattern
    ;

groupOrUnionGraphPattern
    : groupGraphPattern (UNION groupGraphPattern)*
    ;

filter
    : FILTER constraint
    ;

constraint
    : '(' expression ')' | builtInCall | functionCall
    ;

functionCall
    : iri argList
    ;

argList
    : '(' (DISTINCT? expressionList| /* argList is allowed to be empty */) ')'
    ;

expressionList
    : expression (',' expression)*
    ;

constructTemplate
    : '{' constructTriples? '}'
    ;

constructTriples
    : triplesSameSubject ('.' constructTriples?)*
    ;

triplesSameSubject
    : varOrTerm propertyListNotEmpty | triplesNode propertyList 
    ;
 
propertyList
    : propertyListNotEmpty?
    ;

propertyListNotEmpty
    : verb objectList (';' (verb objectList)?)* 
    ;

verb
    : varOrIRI | A
    ;    

objectList
    : object (',' object)*
    ;

object
    : graphNode
    ;

triplesSameSubjectPath
    : varOrTerm propertyListPathNotEmpty | triplesNodePath propertyListPath
    ;
  
propertyListPath
    : propertyListPathNotEmpty?
    ;  

propertyListPathNotEmpty
    : (verbPath|verbSimple) objectListPath (';' propertyListPathNotEmptyList?)*
    ;

propertyListPathNotEmptyList
    : (verbPath|verbSimple) objectList
    ;

verbPath
    : path
    ;
    
verbSimple
    : var
    ;
    	
objectListPath
    : objectPath (',' objectPath)*
    ;

objectPath
    : graphNodePath
    ;

path
    : pathAlternative
    ; 

pathAlternative
    : pathSequence ('|' pathSequence)*
    ;
    
pathSequence
    : pathEltOrInverse ('/' pathEltOrInverse)*
    ;
       	  	
pathElt
    : pathPrimary pathMod?
    ;

pathEltOrInverse
    : INVERSE? pathElt
    ;

pathMod
    : op=('?'| '*' | '+') 
    ;

pathPrimary
    : iri | A | '!' pathNegatedPropertySet | '(' path ')'
    ;

pathNegatedPropertySet
    : pathOneInPropertySet | '(' (pathOneInPropertySet ('|' pathOneInPropertySet)*)? ')'
    ;  	

pathOneInPropertySet
    : INVERSE? (iri | A)
    ;
	
integer
    : INTEGER
    ;
    
triplesNode
    : collection | blankNodePropertyList
    ;

blankNodePropertyList
    : '[' propertyListNotEmpty ']'
    ;

triplesNodePath
    : collectionPath | blankNodePropertyListPath
    ;

blankNodePropertyListPath
    : '[' propertyListPathNotEmpty ']'
    ;

collection
    : '(' graphNode+ ')'
    ;

collectionPath
    : '(' graphNodePath+ ')'
    ;
    
graphNode
    : varOrTerm | triplesNode
    ;

graphNodePath
    : varOrTerm | triplesNodePath
    ;

varOrTerm
    : var | graphTerm
    ;

varOrIRI
    : var | iri
    ;

var
    : VAR1 | VAR2
    ;

graphTerm
    : iri | rdfLiteral | numericLiteral | booleanLiteral | blankNode | nil
    ;
    
nil
    : '(' ')'
    ;

/* ANTLR V4 branded expressions */
expression
    : primaryExpression                                     # baseExpression
    | op=('*'|'/') expression                               # unaryMultiplicativeExpression
    | op=('+'|'-') expression                               # unaryAdditiveExpression
    | '!' expression                                        # unaryNegationExpression
    | expression op=('*'|'/') expression                    # multiplicativeExpression
    | expression op=('+'|'-') expression                    # additiveExpression
    | expression unaryLiteralExpression                     # unarySignedLiteralExpression   
    | expression NOT? IN '(' expressionList? ')'            # relationalSetExpression
    | expression op=('='|'!='|'<'|'>'|'<='|'>=') expression # relationalExpression
    | expression ('&&' expression)                          # conditionalAndExpression
    | expression ('||' expression)                          # conditionalOrExpression
    ;

unaryLiteralExpression
    : (numericLiteralPositive|numericLiteralNegative) (op=('*'|'/') unaryExpression)? 
    ;

unaryExpression
    : op=('!'|'+'|'-')? primaryExpression
    ;

primaryExpression
    : '(' expression ')' | builtInCall | iriRefOrFunction | rdfLiteral | numericLiteral | booleanLiteral | var
    ;

builtInCall
    : aggregate
    | STR '(' expression ')'
    | LANG '(' expression ')'
    | LANGMATCHES '(' expression ',' expression ')'
    | DATATYPE '(' expression ')'
    | BOUND '(' var ')'
    | IRI '(' expression ')'
    | URI '(' expression ')'
    | BNODE '(' expression? ')'
    | RAND '(' ')'
    | ABS '(' expression ')'
    | CEIL '(' expression ')'
    | FLOOR '(' expression ')'
    | ROUND '(' expression ')'
    | CONCAT '(' expressionList? ')'
    | subStringExpression
    | STRLEN '(' expression ')'
    | strReplaceExpression
    | UCASE '(' expression ')'
    | LCASE '(' expression ')'
    | ENCODE_FOR_URI '(' expression ')'
    | CONTAINS '(' expression ',' expression ')'
    | STRSTARTS '(' expression ',' expression ')'
    | STRENDS '(' expression ',' expression ')'
    | STRBEFORE '(' expression ',' expression ')'
    | STRAFTER '(' expression ',' expression ')'
    | YEAR '(' expression ')'
    | MONTH '(' expression ')'
    | DAY '(' expression ')'
    | HOURS '(' expression ')'
    | MINUTES '(' expression ')'
    | SECONDS '(' expression ')'
    | TIMEZONE '(' expression ')'
    | TZ '(' expression ')'
    | NOW '(' ')'
    | UUID '(' ')'
    | STRUUID '(' ')'
    | MD5 '(' expression ')'
    | SHA1 '(' expression ')'
    | SHA256 '(' expression ')'
    | SHA384 '(' expression ')'
    | SHA512 '(' expression ')'
    | COALESCE '(' expressionList? ')'
    | IF '(' expression ',' expression ',' expression ')'
    | STRLANG '(' expression ',' expression ')'
    | STRDT '(' expression ',' expression ')'
    | SAMETERM '(' expression ',' expression ')'
    | ISIRI '(' expression ')'
    | ISURI '(' expression ')'
    | ISBLANK '(' expression ')'
    | ISLITERAL '(' expression ')'
    | ISNUMERIC '(' expression ')'
    | regexExpression
    | existsFunction
    | notExistsFunction
    ;

regexExpression
    : REGEX '(' expression ',' expression (',' expression)? ')'
    ;
    
subStringExpression
    : SUBSTR '(' expression ',' expression (',' expression)? ')'
    ;
    
strReplaceExpression
    : REPLACE '(' expression ',' expression ',' expression (',' expression)? ')'
    ;
    
existsFunction
    : EXISTS groupGraphPattern
    ;

notExistsFunction
    : NOT EXISTS groupGraphPattern
    ;

aggregate
    : COUNT '(' DISTINCT? (ASTERISK | expression) ')'
    | SUM '(' DISTINCT? expression ')'
    | MIN '(' DISTINCT? expression ')'
    | MAX '(' DISTINCT? expression ')'
    | AVG '(' DISTINCT? expression ')'
    | SAMPLE '(' DISTINCT? expression ')'
    | GROUP_CONCAT '(' DISTINCT? expression (';' SEPARATOR '=' string)? ')'
    ;
    
iriRefOrFunction
    : iri argList?
    ;

rdfLiteral
    : string (LANGTAG | ('^^' iri))?
    ;

numericLiteral
    : numericLiteralUnsigned | numericLiteralPositive | numericLiteralNegative
    ;

numericLiteralUnsigned
    : INTEGER | DECIMAL | DOUBLE
    ;

numericLiteralPositive
    : INTEGER_POSITIVE | DECIMAL_POSITIVE | DOUBLE_POSITIVE
    ;

numericLiteralNegative
    : INTEGER_NEGATIVE | DECIMAL_NEGATIVE | DOUBLE_NEGATIVE
    ;

booleanLiteral
    : TRUE | FALSE
    ;

string
    : STRING_LITERAL1 | STRING_LITERAL2 | STRING_LITERAL_LONG1 | STRING_LITERAL_LONG2
    ;

iri
    : IRIREF | prefixedName
    ;

prefixedName
    : PNAME_LN | PNAME_NS
    ;

blankNode
    : BLANK_NODE_LABEL | anon
    ;

anon
    : '[' ']'
    ;
// $>