Fork of https://github.com/oxigraph/oxigraph.git for the purpose of NextGraph project
You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
1069 lines
39 KiB
1069 lines
39 KiB
//See https://www.w3.org/TR/turtle/#sec-grammar
|
|
|
|
use std::char;
|
|
use model::vocab::rdf;
|
|
use model::vocab::xsd;
|
|
use std::iter;
|
|
use std::str::FromStr;
|
|
|
|
#![arguments(state: &mut ParserState)]
|
|
|
|
|
|
//[1]
|
|
pub QueryUnit -> Query = Query
|
|
|
|
//[2]
|
|
Query -> Query = _ Prologue _ q:(SelectQuery / ConstructQuery / DescribeQuery / AskQuery) _ { //TODO: ValuesClause
|
|
q
|
|
}
|
|
|
|
//[4]
|
|
Prologue -> () = (BaseDecl _ / PrefixDecl _)*
|
|
|
|
//[5]
|
|
BaseDecl -> () = "BASE"i _ i:IRIREF {?
|
|
match state.url_parser().parse(&i) {
|
|
Ok(url) => {
|
|
state.base_uri = Some(url);
|
|
Ok(())
|
|
},
|
|
Err(error) => Err("IRI parsing failed")
|
|
}
|
|
}
|
|
|
|
//[6]
|
|
PrefixDecl -> () = "PREFIX"i _ ns:PNAME_NS _ i:IRIREF {
|
|
state.namespaces.insert(ns.into(), i);
|
|
}
|
|
|
|
//[7]
|
|
SelectQuery -> Query = s:SelectClause _ d:DatasetClauses _ w:WhereClause _ g:GroupClause? _ h:HavingClause? _ o:OrderClause? _ l:LimitOffsetClauses? _ v:ValuesClause { //TODO: Modifier
|
|
Query::SelectQuery {
|
|
dataset: d,
|
|
algebra: build_select(s, w, g, h, o, l, v, state)
|
|
}
|
|
}
|
|
|
|
//[8]
|
|
SubSelect -> GraphPattern = s:SelectClause _ w:WhereClause _ g:GroupClause? _ h:HavingClause? _ o:OrderClause? _ l:LimitOffsetClauses? _ v:ValuesClause { //TODO: Modifiers
|
|
build_select(s, w, g, h, o, l, v, state)
|
|
}
|
|
|
|
//[9]
|
|
SelectClause -> Selection = "SELECT"i _ o:SelectClause_option _ v:SelectClause_variables {
|
|
Selection {
|
|
option: o,
|
|
variables: v
|
|
}
|
|
}
|
|
SelectClause_option -> SelectionOption =
|
|
"DISTINCT"i { SelectionOption::Distinct } /
|
|
"REDUCED"i { SelectionOption::Reduced } /
|
|
{ SelectionOption::Default }
|
|
SelectClause_variables -> Option<Vec<SelectionMember>> =
|
|
'*' { None } /
|
|
p:SelectClause_member+ { Some(p) }
|
|
SelectClause_member -> SelectionMember =
|
|
v:Var _ { SelectionMember::Variable(v) } /
|
|
'(' _ e:Expression _ "AS"i _ v:Var _ ')' _ { SelectionMember::Expression(e, v) }
|
|
|
|
//[10]
|
|
ConstructQuery -> Query =
|
|
"CONSTRUCT"i _ c:ConstructTemplate _ d:DatasetClauses _ w:WhereClause _ g:GroupClause? _ h:HavingClause? _ o:OrderClause? _ l:LimitOffsetClauses? _ v:ValuesClause {
|
|
Query::ConstructQuery {
|
|
construct: c,
|
|
dataset: d,
|
|
algebra: build_select(Selection::default(), w, g, h, o, l, v, state)
|
|
}
|
|
} /
|
|
"CONSTRUCT"i _ d:DatasetClauses _ "WHERE"i _ '{' _ c:ConstructQuery_optional_triple_template _ '}' _ g:GroupClause? _ h:HavingClause? _ o:OrderClause? _ l:LimitOffsetClauses? _ v:ValuesClause {
|
|
Query::ConstructQuery {
|
|
construct: c.clone(),
|
|
dataset: d,
|
|
algebra: build_select(
|
|
Selection::default(),
|
|
GraphPattern::BGP(c.into_iter().map(TripleOrPathPattern::from).collect()),
|
|
g, h, o, l, v, state
|
|
)
|
|
}
|
|
}
|
|
|
|
ConstructQuery_optional_triple_template -> Vec<TriplePattern> = TriplesTemplate / { Vec::default() }
|
|
|
|
//[11]
|
|
DescribeQuery -> Query =
|
|
"DESCRIBE"i _ '*' _ d:DatasetClauses w:WhereClause? _ g:GroupClause? _ h:HavingClause? _ o:OrderClause? _ l:LimitOffsetClauses? _ v:ValuesClause {
|
|
Query::DescribeQuery {
|
|
dataset: d,
|
|
algebra: build_select(Selection::default(), w.unwrap_or_else(GraphPattern::default), g, h, o, l, v, state)
|
|
}
|
|
} /
|
|
"DESCRIBE"i _ p:DescribeQuery_item+ _ d:DatasetClauses w:WhereClause? _ g:GroupClause? _ h:HavingClause? _ o:OrderClause? _ l:LimitOffsetClauses? _ v:ValuesClause {
|
|
Query::DescribeQuery {
|
|
dataset: d,
|
|
algebra: build_select(Selection {
|
|
option: SelectionOption::Default,
|
|
variables: Some(p.into_iter().map(|var_or_iri| match var_or_iri {
|
|
NamedNodeOrVariable::NamedNode(n) => SelectionMember::Expression(n.into(), Variable::default()),
|
|
NamedNodeOrVariable::Variable(v) => SelectionMember::Variable(v)
|
|
}).collect())
|
|
}, w.unwrap_or_else(GraphPattern::default), g, h, o, l, v, state)
|
|
}
|
|
}
|
|
DescribeQuery_item -> NamedNodeOrVariable = i:VarOrIri _ { i }
|
|
|
|
//[12]
|
|
AskQuery -> Query = "ASK"i _ d:DatasetClauses w:WhereClause _ g:GroupClause? _ h:HavingClause? _ o:OrderClause? _ l:LimitOffsetClauses? _ v:ValuesClause {
|
|
Query::AskQuery {
|
|
dataset: d,
|
|
algebra: build_select(Selection::default(), w, g, h, o, l, v, state)
|
|
}
|
|
}
|
|
|
|
//[13]
|
|
DatasetClause -> DatasetSpec = "FROM"i _ d:(DefaultGraphClause / NamedGraphClause) { d }
|
|
DatasetClauses -> DatasetSpec = d:DatasetClauses_item* {
|
|
d.into_iter().fold(DatasetSpec::default(), |mut a, b| a + b)
|
|
}
|
|
DatasetClauses_item -> DatasetSpec = d:DatasetClause _ { d }
|
|
//[14]
|
|
DefaultGraphClause -> DatasetSpec = s:SourceSelector {
|
|
DatasetSpec::new_with_default(s)
|
|
}
|
|
|
|
//[15]
|
|
NamedGraphClause -> DatasetSpec = "NAMED"i _ s:SourceSelector {
|
|
DatasetSpec::new_with_named(s)
|
|
}
|
|
|
|
//[16]
|
|
SourceSelector -> NamedNode = iri
|
|
|
|
//[17]
|
|
WhereClause -> GraphPattern = "WHERE"i? _ p:GroupGraphPattern {
|
|
p
|
|
}
|
|
|
|
//[19]
|
|
GroupClause -> (Vec<Expression>, Vec<(Expression,Variable)>) = "GROUP"i _ "BY"i _ c:GroupCondition_item+ {
|
|
let mut projections: Vec<(Expression,Variable)> = Vec::default();
|
|
let clauses = c.into_iter().map(|(e, vo)| {
|
|
match vo {
|
|
Some(v) => {
|
|
projections.push((e, v.clone()));
|
|
v.into()
|
|
},
|
|
None => e
|
|
}
|
|
}).collect();
|
|
(clauses, projections)
|
|
}
|
|
GroupCondition_item -> (Expression, Option<Variable>) = c:GroupCondition _ { c }
|
|
|
|
//[20]
|
|
GroupCondition -> (Expression, Option<Variable>) =
|
|
e:BuiltInCall { (e, None) } /
|
|
e:FunctionCall { (e, None) } /
|
|
'(' _ e:Expression _ v:GroupCondition_as? ')' { (e, v) } /
|
|
e:Var { (e.into(), None) }
|
|
GroupCondition_as -> Variable = "AS"i _ v:Var _ { v }
|
|
|
|
//[21]
|
|
HavingClause -> Expression = "HAVING"i _ e:HavingCondition+ {?
|
|
not_empty_fold(e.into_iter(), |a, b| Expression::AndExpression(Box::new(a), Box::new(b)))
|
|
}
|
|
|
|
//[22]
|
|
HavingCondition -> Expression = Constraint
|
|
|
|
//[23]
|
|
OrderClause -> Vec<OrderComparator> = "ORDER"i _ "BY"i _ c:OrderClause_item+ { c }
|
|
OrderClause_item -> OrderComparator = c:OrderCondition _ { c }
|
|
|
|
//[24]
|
|
OrderCondition -> OrderComparator =
|
|
"ASC"i _ e: BrackettedExpression { OrderComparator::Asc(e) } /
|
|
"DESC"i _ e: BrackettedExpression { OrderComparator::Desc(e) } /
|
|
e: Constraint { e.into() } /
|
|
v: Var { Expression::from(v).into() }
|
|
|
|
//[25]
|
|
LimitOffsetClauses -> (usize, Option<usize>) =
|
|
l:LimitClause _ o:OffsetClause? { (o.unwrap_or(0), Some(l)) } /
|
|
o:OffsetClause _ l:LimitClause? { (o, l) }
|
|
|
|
//[26]
|
|
LimitClause -> usize = "LIMIT"i _ l:$(INTEGER) {?
|
|
usize::from_str(l).map_err(|_| "The query limit should be a non negative integer")
|
|
}
|
|
|
|
//[27]
|
|
OffsetClause -> usize = "OFFSET"i _ o:$(INTEGER) {?
|
|
usize::from_str(o).map_err(|_| "The query offset should be a non negative integer")
|
|
}
|
|
|
|
//[28]
|
|
ValuesClause -> Option<GraphPattern> =
|
|
"VALUES"i _ p:DataBlock { Some(p) } /
|
|
{ None }
|
|
|
|
//[52]
|
|
TriplesTemplate -> Vec<TriplePattern> = h:TriplesSameSubject _ t:TriplesTemplate_tail? {
|
|
let mut triples = h;
|
|
if let Some(l) = t {
|
|
triples.extend_from_slice(&l)
|
|
}
|
|
triples
|
|
}
|
|
TriplesTemplate_tail -> Vec<TriplePattern> = '.' _ t:TriplesTemplate? _ {
|
|
t.unwrap_or_else(Vec::default)
|
|
}
|
|
|
|
//[53]
|
|
GroupGraphPattern -> GraphPattern =
|
|
'{' _ p:GroupGraphPatternSub _ '}' { p } /
|
|
'{' _ p:SubSelect _ '}' { p }
|
|
|
|
//[54]
|
|
GroupGraphPatternSub -> GraphPattern = a:TriplesBlock? _ b:GroupGraphPatternSub_item* {
|
|
let mut p = a.map(|v| vec![PartialGraphPattern::Other(GraphPattern::BGP(v))]).unwrap_or_else(|| vec![]);
|
|
for v in b {
|
|
p.extend_from_slice(&v)
|
|
}
|
|
let mut filter: Option<Expression> = None;
|
|
let mut g = GraphPattern::default();
|
|
for e in p {
|
|
match e {
|
|
PartialGraphPattern::Optional(p) => match p {
|
|
GraphPattern::Filter(f, a2) => {
|
|
g = GraphPattern::LeftJoin(Box::new(g), a2, f)
|
|
}
|
|
a => {
|
|
g = GraphPattern::LeftJoin(Box::new(g), Box::new(a), Literal::from(true).into())
|
|
}
|
|
}
|
|
PartialGraphPattern::Minus(p) => {
|
|
g = GraphPattern::Minus(Box::new(g), Box::new(p))
|
|
}
|
|
PartialGraphPattern::Bind(expr, var) => {
|
|
g = GraphPattern::Extend(Box::new(g), var, expr)
|
|
}
|
|
PartialGraphPattern::Filter(expr) => match filter {
|
|
Some(f) => { filter = Some(Expression::AndExpression(Box::new(f), Box::new(expr))) },
|
|
None => { filter = Some(expr) }
|
|
},
|
|
PartialGraphPattern::Other(e) => g = new_join(g, e),
|
|
}
|
|
}
|
|
match filter {
|
|
Some(filter) => GraphPattern::Filter(filter, Box::new(g)),
|
|
None => g
|
|
}
|
|
}
|
|
GroupGraphPatternSub_item -> Vec<PartialGraphPattern> = a:GraphPatternNotTriples _ ('.' _)? b:TriplesBlock? _ {
|
|
let mut result = vec![a];
|
|
if let Some(v) = b {
|
|
result.push(PartialGraphPattern::Other(GraphPattern::BGP(v)));
|
|
}
|
|
result
|
|
}
|
|
|
|
//[55]
|
|
TriplesBlock -> Vec<TripleOrPathPattern> = h:TriplesSameSubjectPath _ t:TriplesBlock_tail? {
|
|
let mut triples = h;
|
|
if let Some(l) = t {
|
|
triples.extend_from_slice(&l)
|
|
}
|
|
triples
|
|
}
|
|
TriplesBlock_tail -> Vec<TripleOrPathPattern> = '.' _ t:TriplesBlock? _ {
|
|
t.unwrap_or_else(Vec::default)
|
|
}
|
|
|
|
//[56]
|
|
GraphPatternNotTriples -> PartialGraphPattern = GroupOrUnionGraphPattern / OptionalGraphPattern / MinusGraphPattern / GraphGraphPattern / ServiceGraphPattern / Filter / Bind / InlineData
|
|
|
|
//[57]
|
|
OptionalGraphPattern -> PartialGraphPattern = "OPTIONAL"i _ p:GroupGraphPattern {
|
|
PartialGraphPattern::Optional(p)
|
|
}
|
|
|
|
//[58]
|
|
GraphGraphPattern -> PartialGraphPattern = "GRAPH"i _ g:VarOrIri _ p:GroupGraphPattern {
|
|
PartialGraphPattern::Other(GraphPattern::Graph(g, Box::new(p)))
|
|
}
|
|
|
|
//[59]
|
|
ServiceGraphPattern -> PartialGraphPattern =
|
|
"SERVICE"i _ "SILENT"i _ s:VarOrIri _ p:GroupGraphPattern { PartialGraphPattern::Other(GraphPattern::Service(s, Box::new(p), true)) } /
|
|
"SERVICE"i _ s:VarOrIri _ p:GroupGraphPattern { PartialGraphPattern::Other(GraphPattern::Service(s, Box::new(p), false)) }
|
|
|
|
//[60]
|
|
Bind -> PartialGraphPattern = "BIND"i _ '(' _ e:Expression _ "AS"i _ v:Var _ ')' {
|
|
PartialGraphPattern::Bind(e, v)
|
|
}
|
|
|
|
//[61]
|
|
InlineData -> PartialGraphPattern = "VALUES"i _ p:DataBlock { PartialGraphPattern::Other(p) }
|
|
|
|
//[62]
|
|
DataBlock -> GraphPattern = l:(InlineDataOneVar / InlineDataFull) {
|
|
GraphPattern::Data(l)
|
|
}
|
|
|
|
//[63]
|
|
InlineDataOneVar -> StaticBindings = var:Var _ '{' _ d:InlineDataOneVar_value* '}' {
|
|
StaticBindings::new(vec![var], d)
|
|
}
|
|
InlineDataOneVar_value -> Vec<Option<Term>> = t:DataBlockValue { vec![t] }
|
|
|
|
//[64]
|
|
InlineDataFull -> StaticBindings = '(' _ vars:InlineDataFull_var* _ ')' _ '{' _ val:InlineDataFull_values* '}' {
|
|
StaticBindings::new(vars, val)
|
|
}
|
|
InlineDataFull_var -> Variable = v:Var _ { v }
|
|
InlineDataFull_values -> Vec<Option<Term>> = '(' _ v:InlineDataFull_value* _ ')' _ { v }
|
|
InlineDataFull_value -> Option<Term> = v:DataBlockValue _ { v }
|
|
|
|
//[65]
|
|
DataBlockValue -> Option<Term> =
|
|
i:iri { Some(i.into()) } /
|
|
l:RDFLiteral { Some(l.into()) } /
|
|
l:NumericLiteral { Some(l.into()) } /
|
|
l:BooleanLiteral { Some(l.into()) } /
|
|
"UNDEF"i { None }
|
|
|
|
//[66]
|
|
MinusGraphPattern -> PartialGraphPattern = "MINUS"i _ p: GroupGraphPattern {
|
|
PartialGraphPattern::Minus(p)
|
|
}
|
|
|
|
//[67]
|
|
GroupOrUnionGraphPattern -> PartialGraphPattern = p:GroupOrUnionGraphPattern_item **<1,> ("UNION"i _) {?
|
|
not_empty_fold(p.into_iter(), |a, b| {
|
|
GraphPattern::Union(Box::new(a), Box::new(b))
|
|
}).map(PartialGraphPattern::Other)
|
|
}
|
|
GroupOrUnionGraphPattern_item -> GraphPattern = p:GroupGraphPattern _ { p }
|
|
|
|
//[68]
|
|
Filter -> PartialGraphPattern = "FILTER"i _ c:Constraint {
|
|
PartialGraphPattern::Filter(c)
|
|
}
|
|
|
|
//[69]
|
|
Constraint -> Expression = BrackettedExpression / BuiltInCall / FunctionCall
|
|
|
|
//[70]
|
|
FunctionCall -> Expression = f: iri _ a: ArgList {
|
|
Expression::CustomFunctionCall(f, a)
|
|
}
|
|
|
|
//[71]
|
|
ArgList -> Vec<Expression> = //TODO: support DISTINCT
|
|
'(' _ 'DISTINCT'? _ e:ArgList_item **<1,> (',' _) _ ')' { e } /
|
|
NIL { Vec::new() }
|
|
ArgList_item -> Expression = e:Expression _ { e }
|
|
|
|
//[72]
|
|
ExpressionList -> Vec<Expression> =
|
|
'(' _ e:ExpressionList_item **<1,> (',' _) ')' { e } /
|
|
NIL { Vec::default() }
|
|
ExpressionList_item -> Expression = e:Expression _ { e }
|
|
|
|
//[73]
|
|
ConstructTemplate -> Vec<TriplePattern> = '{' _ t:ConstructTriples _ '}' { t }
|
|
|
|
//[74]
|
|
ConstructTriples -> Vec<TriplePattern> = p:ConstructTriples_item ** ('.' _) {
|
|
p.into_iter().flat_map(|c| c.into_iter()).collect()
|
|
}
|
|
ConstructTriples_item -> Vec<TriplePattern> = t:TriplesSameSubject _ { t }
|
|
|
|
//[75]
|
|
TriplesSameSubject -> Vec<TriplePattern> =
|
|
s:VarOrTerm _ po:PropertyListNotEmpty {
|
|
let mut patterns = po.patterns;
|
|
for (p, os) in po.focus {
|
|
for o in os {
|
|
patterns.push(TriplePattern::new(s.clone(), p.clone(), o))
|
|
}
|
|
}
|
|
patterns
|
|
} /
|
|
s:TriplesNode _ po:PropertyList {
|
|
let mut patterns = s.patterns;
|
|
patterns.extend_from_slice(&po.patterns);
|
|
for (p, os) in po.focus {
|
|
for o in os {
|
|
patterns.push(TriplePattern::new(s.focus.clone(), p.clone(), o))
|
|
}
|
|
}
|
|
patterns
|
|
}
|
|
|
|
//[76]
|
|
PropertyList -> FocusedTriplePattern<Vec<(NamedNodeOrVariable,Vec<TermOrVariable>)>> =
|
|
PropertyListNotEmpty /
|
|
{ FocusedTriplePattern::default() }
|
|
|
|
//[77]
|
|
PropertyListNotEmpty -> FocusedTriplePattern<Vec<(NamedNodeOrVariable,Vec<TermOrVariable>)>> = l:PropertyListNotEmpty_item **<1,> (';' _) {
|
|
l.into_iter().fold(FocusedTriplePattern::<Vec<(NamedNodeOrVariable,Vec<TermOrVariable>)>>::default(), |mut a, b| {
|
|
a.focus.push(b.focus);
|
|
a.patterns.extend_from_slice(&b.patterns);
|
|
a
|
|
})
|
|
}
|
|
PropertyListNotEmpty_item -> FocusedTriplePattern<(NamedNodeOrVariable,Vec<TermOrVariable>)> = p:Verb _ o:ObjectList _ {
|
|
FocusedTriplePattern {
|
|
focus: (p, o.focus),
|
|
patterns: o.patterns
|
|
}
|
|
}
|
|
|
|
//[78]
|
|
Verb -> NamedNodeOrVariable = 'a' { rdf::TYPE.clone().into() } / VarOrIri
|
|
|
|
//[79]
|
|
ObjectList -> FocusedTriplePattern<Vec<TermOrVariable>> = o:ObjectList_item **<1,> (',' _) {
|
|
o.into_iter().fold(FocusedTriplePattern::<Vec<TermOrVariable>>::default(), |mut a, b| {
|
|
a.focus.push(b.focus);
|
|
a.patterns.extend_from_slice(&b.patterns);
|
|
a
|
|
})
|
|
}
|
|
ObjectList_item -> FocusedTriplePattern<TermOrVariable> = o:Object _ { o }
|
|
|
|
//[80]
|
|
Object -> FocusedTriplePattern<TermOrVariable> = GraphNode
|
|
|
|
//[81]
|
|
TriplesSameSubjectPath -> Vec<TripleOrPathPattern> =
|
|
s:VarOrTerm _ po:PropertyListPathNotEmpty {
|
|
let mut patterns = po.patterns;
|
|
for (p, os) in po.focus {
|
|
for o in os {
|
|
add_to_triple_or_path_patterns(s.clone(), p.clone(), o, &mut patterns);
|
|
}
|
|
}
|
|
patterns
|
|
} /
|
|
s:TriplesNodePath _ po:PropertyListPath {
|
|
let mut patterns = s.patterns;
|
|
patterns.extend_from_slice(&po.patterns);
|
|
for (p, os) in po.focus {
|
|
for o in os {
|
|
add_to_triple_or_path_patterns(s.focus.clone(), p.clone(), o, &mut patterns);
|
|
}
|
|
}
|
|
patterns
|
|
}
|
|
|
|
//[82]
|
|
PropertyListPath -> FocusedTripleOrPathPattern<Vec<(VariableOrPropertyPath,Vec<TermOrVariable>)>> =
|
|
PropertyListPathNotEmpty /
|
|
{ FocusedTripleOrPathPattern::default() }
|
|
|
|
//[83]
|
|
PropertyListPathNotEmpty -> FocusedTripleOrPathPattern<Vec<(VariableOrPropertyPath,Vec<TermOrVariable>)>> = hp:(VerbPath / VerbSimple) _ ho:ObjectListPath _ t:PropertyListPathNotEmpty_item* {
|
|
t.into_iter().flat_map(|e| e.into_iter()).fold(FocusedTripleOrPathPattern {
|
|
focus: vec![(hp, ho.focus)],
|
|
patterns: ho.patterns
|
|
}, |mut a, b| {
|
|
a.focus.push(b.focus);
|
|
a.patterns.extend(b.patterns.into_iter().map(|v| v.into()));
|
|
a
|
|
})
|
|
}
|
|
PropertyListPathNotEmpty_item -> Option<FocusedTriplePattern<(VariableOrPropertyPath,Vec<TermOrVariable>)>> = ';' _ c:PropertyListPathNotEmpty_item_content? {
|
|
c
|
|
}
|
|
PropertyListPathNotEmpty_item_content -> FocusedTriplePattern<(VariableOrPropertyPath,Vec<TermOrVariable>)> = p:(VerbPath / VerbSimple) _ o:ObjectList _ {
|
|
FocusedTriplePattern {
|
|
focus: (p, o.focus),
|
|
patterns: o.patterns
|
|
}
|
|
}
|
|
|
|
//[84]
|
|
VerbPath -> VariableOrPropertyPath = p:Path {
|
|
p.into()
|
|
}
|
|
|
|
//[85]
|
|
VerbSimple -> VariableOrPropertyPath = v:Var {
|
|
v.into()
|
|
}
|
|
|
|
//[86]
|
|
ObjectListPath -> FocusedTripleOrPathPattern<Vec<TermOrVariable>> = o:ObjectPath_item **<1,> (',' _) {
|
|
o.into_iter().fold(FocusedTripleOrPathPattern::<Vec<TermOrVariable>>::default(), |mut a, b| {
|
|
a.focus.push(b.focus);
|
|
a.patterns.extend_from_slice(&b.patterns);
|
|
a
|
|
})
|
|
}
|
|
ObjectPath_item -> FocusedTripleOrPathPattern<TermOrVariable> = o:ObjectPath _ { o }
|
|
|
|
//[87]
|
|
ObjectPath -> FocusedTripleOrPathPattern<TermOrVariable> = GraphNodePath
|
|
|
|
//[88]
|
|
Path -> PropertyPath = PathAlternative
|
|
|
|
//[89]
|
|
PathAlternative -> PropertyPath = p:PathAlternative_item **<1,> ('|' _) {?
|
|
not_empty_fold(p.into_iter(), |a, b| {
|
|
PropertyPath::AlternativePath(Box::new(a), Box::new(b))
|
|
})
|
|
}
|
|
PathAlternative_item -> PropertyPath = p:PathSequence _ { p }
|
|
|
|
//[90]
|
|
PathSequence -> PropertyPath = p:PathSequence_item **<1,> ('/' _) {?
|
|
not_empty_fold(p.into_iter(), |a, b| {
|
|
PropertyPath::SequencePath(Box::new(a), Box::new(b))
|
|
})
|
|
}
|
|
PathSequence_item -> PropertyPath = p:PathEltOrInverse _ { p }
|
|
|
|
//[91]
|
|
PathElt -> PropertyPath =
|
|
p:PathPrimary '?' { PropertyPath::ZeroOrOnePath(Box::new(p)) } / //TODO: allow space before "?"
|
|
p:PathPrimary _ '*' { PropertyPath::ZeroOrMorePath(Box::new(p)) } /
|
|
p:PathPrimary _ '+' { PropertyPath::OneOrMorePath(Box::new(p)) } /
|
|
PathPrimary
|
|
|
|
//[92]
|
|
PathEltOrInverse -> PropertyPath =
|
|
'^' _ p:PathElt { PropertyPath::InversePath(Box::new(p)) } /
|
|
PathElt
|
|
|
|
//[94]
|
|
PathPrimary -> PropertyPath =
|
|
'a' { rdf::TYPE.clone().into() } /
|
|
v:iri { v.into() } /
|
|
'!' _ p:PathNegatedPropertySet { p } /
|
|
'(' _ p:Path _ ')' { p }
|
|
|
|
//[95]
|
|
PathNegatedPropertySet -> PropertyPath =
|
|
'(' _ p:PathNegatedPropertySet_item **<1,> ('|' _) ')' {
|
|
let mut direct = Vec::default();
|
|
let mut inverse = Vec::default();
|
|
for e in p {
|
|
match e {
|
|
Either::Left(a) => direct.push(a),
|
|
Either::Right(b) => inverse.push(b)
|
|
}
|
|
}
|
|
if inverse.is_empty() {
|
|
PropertyPath::NegatedPropertySet(direct)
|
|
} else if direct.is_empty() {
|
|
PropertyPath::InversePath(Box::new(PropertyPath::NegatedPropertySet(inverse)))
|
|
} else {
|
|
PropertyPath::AlternativePath(
|
|
Box::new(PropertyPath::NegatedPropertySet(direct)),
|
|
Box::new(PropertyPath::InversePath(Box::new(PropertyPath::NegatedPropertySet(inverse))))
|
|
)
|
|
}
|
|
} /
|
|
p:PathOneInPropertySet {
|
|
match p {
|
|
Either::Left(a) => PropertyPath::NegatedPropertySet(vec![a]),
|
|
Either::Right(b) => PropertyPath::InversePath(Box::new(PropertyPath::NegatedPropertySet(vec![b]))),
|
|
}
|
|
}
|
|
PathNegatedPropertySet_item -> Either<NamedNode,NamedNode> = p:PathOneInPropertySet _ { p }
|
|
|
|
//[96]
|
|
PathOneInPropertySet -> Either<NamedNode,NamedNode> =
|
|
'^' _ 'a' { Either::Right(rdf::TYPE.clone()) } /
|
|
'^' _ v:iri { Either::Right(v) } /
|
|
'a' { Either::Left(rdf::TYPE.clone()) } /
|
|
v:iri { Either::Left(v) }
|
|
|
|
//[98]
|
|
TriplesNode -> FocusedTriplePattern<TermOrVariable> = Collection / BlankNodePropertyList
|
|
|
|
//[99]
|
|
BlankNodePropertyList -> FocusedTriplePattern<TermOrVariable> = '[' _ po:PropertyListNotEmpty _ ']' {
|
|
let mut patterns: Vec<TriplePattern> = Vec::default();
|
|
let mut bnode = TermOrVariable::from(BlankNode::default());
|
|
for (p, os) in po.focus {
|
|
for o in os {
|
|
patterns.push(TriplePattern::new(bnode.clone(), p.clone(), o));
|
|
}
|
|
}
|
|
FocusedTriplePattern {
|
|
focus: bnode,
|
|
patterns
|
|
}
|
|
}
|
|
|
|
//[100]
|
|
TriplesNodePath -> FocusedTripleOrPathPattern<TermOrVariable> = CollectionPath / BlankNodePropertyListPath
|
|
|
|
//[101]
|
|
BlankNodePropertyListPath -> FocusedTripleOrPathPattern<TermOrVariable> = '[' _ po:PropertyListPathNotEmpty _ ']' {
|
|
let mut patterns: Vec<TripleOrPathPattern> = Vec::default();
|
|
let mut bnode = TermOrVariable::from(BlankNode::default());
|
|
for (p, os) in po.focus {
|
|
for o in os {
|
|
add_to_triple_or_path_patterns(bnode.clone(), p.clone(), o, &mut patterns);
|
|
}
|
|
}
|
|
FocusedTripleOrPathPattern {
|
|
focus: bnode,
|
|
patterns
|
|
}
|
|
}
|
|
|
|
//[102]
|
|
Collection -> FocusedTriplePattern<TermOrVariable> = '(' _ o:Collection_item+ ')' {
|
|
let mut patterns: Vec<TriplePattern> = Vec::default();
|
|
let mut current_list_node = TermOrVariable::from(rdf::NIL.clone());
|
|
for objWithPatterns in o.into_iter().rev() {
|
|
let new_blank_node = TermOrVariable::from(BlankNode::default());
|
|
patterns.push(TriplePattern::new(new_blank_node.clone(), rdf::FIRST.clone(), objWithPatterns.focus.clone()));
|
|
patterns.push(TriplePattern::new(new_blank_node.clone(), rdf::REST.clone(), current_list_node));
|
|
current_list_node = new_blank_node;
|
|
patterns.extend_from_slice(&objWithPatterns.patterns);
|
|
}
|
|
FocusedTriplePattern {
|
|
focus: current_list_node,
|
|
patterns
|
|
}
|
|
}
|
|
Collection_item -> FocusedTriplePattern<TermOrVariable> = o:GraphNode _ { o }
|
|
|
|
//[103]
|
|
CollectionPath -> FocusedTripleOrPathPattern<TermOrVariable> = '(' _ o:CollectionPath_item+ _ ')' {
|
|
let mut patterns: Vec<TripleOrPathPattern> = Vec::default();
|
|
let mut current_list_node = TermOrVariable::from(rdf::NIL.clone());
|
|
for objWithPatterns in o.into_iter().rev() {
|
|
let new_blank_node = TermOrVariable::from(BlankNode::default());
|
|
patterns.push(TriplePattern::new(new_blank_node.clone(), rdf::FIRST.clone(), objWithPatterns.focus.clone()).into());
|
|
patterns.push(TriplePattern::new(new_blank_node.clone(), rdf::REST.clone(), current_list_node).into());
|
|
current_list_node = new_blank_node;
|
|
patterns.extend_from_slice(&objWithPatterns.patterns);
|
|
}
|
|
FocusedTripleOrPathPattern {
|
|
focus: current_list_node,
|
|
patterns
|
|
}
|
|
}
|
|
CollectionPath_item -> FocusedTripleOrPathPattern<TermOrVariable> = p:GraphNodePath _ { p }
|
|
|
|
//[104]
|
|
GraphNode -> FocusedTriplePattern<TermOrVariable> =
|
|
t:VarOrTerm { FocusedTriplePattern::new(t) } /
|
|
TriplesNode
|
|
|
|
//[105]
|
|
GraphNodePath -> FocusedTripleOrPathPattern<TermOrVariable> =
|
|
t:VarOrTerm { FocusedTripleOrPathPattern::new(t) } /
|
|
TriplesNodePath
|
|
|
|
//[106]
|
|
VarOrTerm -> TermOrVariable =
|
|
v:Var { v.into() } /
|
|
t:GraphTerm { t.into() }
|
|
|
|
//[107]
|
|
VarOrIri -> NamedNodeOrVariable =
|
|
v:Var { v.into() } /
|
|
i:iri { i.into() }
|
|
|
|
//[108]
|
|
Var -> Variable = v:(VAR1 / VAR2) { Variable::new(v) }
|
|
|
|
//[109]
|
|
GraphTerm -> Term =
|
|
i:iri { i.into() } /
|
|
l:RDFLiteral { l.into() } /
|
|
l:NumericLiteral { l.into() } /
|
|
l:BooleanLiteral { l.into() } /
|
|
b:BlankNode { b.into() } /
|
|
NIL { rdf::NIL.clone().into() }
|
|
|
|
//[110]
|
|
Expression -> Expression = e:ConditionalOrExpression {e}
|
|
|
|
//[111]
|
|
ConditionalOrExpression -> Expression = e:ConditionalOrExpression_item **<1,> ("||" _) {?
|
|
not_empty_fold(e.into_iter(), |a, b| Expression::OrExpression(Box::new(a), Box::new(b)))
|
|
}
|
|
ConditionalOrExpression_item -> Expression = e:ConditionalAndExpression _ { e }
|
|
|
|
//[112]
|
|
ConditionalAndExpression -> Expression = e:ConditionalAndExpression_item **<1,> ("&&" _) {?
|
|
not_empty_fold(e.into_iter(), |a, b| Expression::AndExpression(Box::new(a), Box::new(b)))
|
|
}
|
|
ConditionalAndExpression_item -> Expression = e:ValueLogical _ { e }
|
|
|
|
//[113]
|
|
ValueLogical -> Expression = RelationalExpression
|
|
|
|
//[114]
|
|
RelationalExpression -> Expression =
|
|
a:NumericExpression _ "=" _ b:NumericExpression { Expression::EqualExpression(Box::new(a), Box::new(b)) } /
|
|
a:NumericExpression _ "!=" _ b:NumericExpression { Expression::NotEqualExpression(Box::new(a), Box::new(b)) } /
|
|
a:NumericExpression _ ">" _ b:NumericExpression { Expression::GreaterExpression(Box::new(a), Box::new(b)) } /
|
|
a:NumericExpression _ ">=" _ b:NumericExpression { Expression::GreaterOrEqExpression(Box::new(a), Box::new(b)) } /
|
|
a:NumericExpression _ "<" _ b:NumericExpression { Expression::LowerExpression(Box::new(a), Box::new(b)) } /
|
|
a:NumericExpression _ "<=" _ b:NumericExpression { Expression::LowerOrEqExpression(Box::new(a), Box::new(b)) } /
|
|
a:NumericExpression _ "IN"i _ b:ExpressionList { Expression::InExpression(Box::new(a), b) } /
|
|
a:NumericExpression _ "NOT"i _ "IN"i _ b:ExpressionList { Expression::NotInExpression(Box::new(a), b) } /
|
|
NumericExpression
|
|
|
|
//[115]
|
|
NumericExpression -> Expression = AdditiveExpression
|
|
|
|
//[116]
|
|
AdditiveExpression -> Expression =
|
|
a:MultiplicativeExpression _ '+' _ b:AdditiveExpression { Expression::AddExpression(Box::new(a), Box::new(b)) } /
|
|
a:MultiplicativeExpression _ '-' _ b:AdditiveExpression { Expression::SubExpression(Box::new(a), Box::new(b)) } /
|
|
MultiplicativeExpression
|
|
|
|
//[117]
|
|
MultiplicativeExpression -> Expression =
|
|
a:UnaryExpression _ '*' _ b:MultiplicativeExpression { Expression::MulExpression(Box::new(a), Box::new(b)) } /
|
|
a:UnaryExpression _ '/' _ b:MultiplicativeExpression { Expression::DivExpression(Box::new(a), Box::new(b)) } /
|
|
UnaryExpression
|
|
|
|
//[118]
|
|
UnaryExpression -> Expression =
|
|
'!' _ e:PrimaryExpression { Expression::UnaryNotExpression(Box::new(e)) } /
|
|
'+' _ e:PrimaryExpression { Expression::UnaryPlusExpression(Box::new(e)) } /
|
|
'-' _ e:PrimaryExpression { Expression::UnaryMinusExpression(Box::new(e)) } /
|
|
PrimaryExpression
|
|
|
|
//[119]
|
|
PrimaryExpression -> Expression =
|
|
BrackettedExpression /
|
|
BuiltInCall /
|
|
iriOrFunction /
|
|
l:RDFLiteral { Expression::ConstantExpression(l.into()) } /
|
|
l:NumericLiteral { Expression::ConstantExpression(l.into()) } /
|
|
l:BooleanLiteral { Expression::ConstantExpression(l.into()) } /
|
|
v:Var { Expression::ConstantExpression(v.into()) }
|
|
|
|
//[120]
|
|
BrackettedExpression -> Expression = '(' _ e:Expression _ ')' { e }
|
|
|
|
//[121]
|
|
BuiltInCall -> Expression =
|
|
a:Aggregate { state.new_aggregation(a).into() } /
|
|
"STR"i _ '(' _ e:Expression _ ')' { Expression::StrFunctionCall(Box::new(e)) } /
|
|
"LANG"i _ '(' _ e:Expression _ ')' { Expression::LangFunctionCall(Box::new(e)) } /
|
|
"LANGMATCHES"i _ '(' _ a:Expression _ ',' _ b:Expression _ ')' { Expression::LangMatchesFunctionCall(Box::new(a), Box::new(b)) } /
|
|
"DATATYPE"i _ '(' _ e:Expression _ ')' { Expression::DatatypeFunctionCall(Box::new(e)) } /
|
|
"BOUND"i _ '(' _ v:Var _ ')' { Expression::BoundFunctionCall(v) } /
|
|
("IRI"i / "URI"i) _ '(' _ e:Expression _ ')' { Expression::IRIFunctionCall(Box::new(e)) } /
|
|
"BNODE"i '(' _ e:Expression _ ')' { Expression::BNodeFunctionCall(Some(Box::new(e))) } /
|
|
"BNODE"i NIL { Expression::BNodeFunctionCall(None) } /
|
|
"RAND"i _ NIL { Expression::RandFunctionCall() } /
|
|
"ABS"i _ '(' _ e:Expression _ ')' { Expression::AbsFunctionCall(Box::new(e)) } /
|
|
"CEIL"i _ '(' _ e:Expression _ ')' { Expression::CeilFunctionCall(Box::new(e)) } /
|
|
"FLOOR"i _ '(' _ e:Expression _ ')' { Expression::FloorFunctionCall(Box::new(e)) } /
|
|
"ROUND"i _ '(' _ e:Expression _ ')' { Expression::RoundFunctionCall(Box::new(e)) } /
|
|
"CONCAT"i e:ExpressionList { Expression::ConcatFunctionCall(e) } /
|
|
SubstringExpression /
|
|
"STRLEN"i _ '(' _ e: Expression _ ')' { Expression::StrLenFunctionCall(Box::new(e)) } /
|
|
StrReplaceExpression /
|
|
"UCASE"i _ '(' _ e:Expression _ ')' { Expression::UCaseFunctionCall(Box::new(e)) } /
|
|
"LCASE"i _ '(' _ e:Expression _ ')' { Expression::LCaseFunctionCall(Box::new(e)) } /
|
|
'ENCODE_FOR_URI' '(' _ e: Expression _ ')' { Expression::EncodeForURIFunctionCall(Box::new(e)) } /
|
|
"CONTAINS"i _ '(' _ a:Expression _ ',' _ b:Expression _ ')' { Expression::ContainsFunctionCall(Box::new(a), Box::new(b)) } /
|
|
"STRSTARTS"i _ '(' _ a:Expression _ ',' _ b:Expression _ ')' { Expression::StrStartsFunctionCall(Box::new(a), Box::new(b)) } /
|
|
"STRENDS"i _ '(' _ a:Expression _ ',' _ b:Expression _ ')' { Expression::StrEndsFunctionCall(Box::new(a), Box::new(b)) } /
|
|
"STRBEFORE"i _ '(' _ a:Expression _ ',' _ b:Expression _ ')' { Expression::StrBeforeFunctionCall(Box::new(a), Box::new(b)) } /
|
|
"STRAFTER"i _ '(' _ a:Expression _ ',' _ b:Expression _ ')' { Expression::StrAfterFunctionCall(Box::new(a), Box::new(b)) } /
|
|
"YEAR"i _ '(' _ e:Expression _ ')' { Expression::YearFunctionCall(Box::new(e)) } /
|
|
"MONTH"i _ '(' _ e:Expression _ ')' { Expression::MonthFunctionCall(Box::new(e)) } /
|
|
"DAY"i _ '(' _ e:Expression _ ')' { Expression::DayFunctionCall(Box::new(e)) } /
|
|
"HOURS"i _ '(' _ e:Expression _ ')' { Expression::HoursFunctionCall(Box::new(e)) } /
|
|
"MINUTES"i _ '(' _ e:Expression _ ')' { Expression::MinutesFunctionCall(Box::new(e)) } /
|
|
"SECONDS"i _ '(' _ e:Expression _ ')' { Expression::SecondsFunctionCall(Box::new(e)) } /
|
|
("TIMEZONE"i / "TZ"i) _ '(' _ e:Expression _ ')' { Expression::TimezoneFunctionCall(Box::new(e)) } /
|
|
"NOW"i _ NIL { Expression::NowFunctionCall() } /
|
|
"UUID"i _ NIL { Expression::UUIDFunctionCall() }/
|
|
"STRUUID"i _ NIL { Expression::StrUUIDFunctionCall() } /
|
|
"MD5"i '(' _ e:Expression _ ')' { Expression::MD5FunctionCall(Box::new(e)) } /
|
|
"SHA1"i '(' _ e:Expression _ ')' { Expression::SHA1FunctionCall(Box::new(e)) } /
|
|
"SHA256"i '(' _ e:Expression _ ')' { Expression::SHA256FunctionCall(Box::new(e)) } /
|
|
"SHA384"i '(' _ e:Expression _ ')' { Expression::SHA384FunctionCall(Box::new(e)) } /
|
|
"SHA512"i '(' _ e:Expression _ ')' { Expression::SHA512FunctionCall(Box::new(e)) } /
|
|
"COALESCE"i e:ExpressionList { Expression::CoalesceFunctionCall(e) } /
|
|
"IF"i _ '(' _ a:Expression _ ',' _ b:Expression _ ',' _ c:Expression _ ')' { Expression::IfFunctionCall(Box::new(a), Box::new(b), Box::new(c)) } /
|
|
"STRLANG"i _ '(' _ a:Expression _ ',' _ b:Expression _ ')' { Expression::StrLangFunctionCall(Box::new(a), Box::new(b)) } /
|
|
"STRDT"i _ '(' _ a:Expression _ ',' _ b:Expression _ ')' { Expression::StrDTFunctionCall(Box::new(a), Box::new(b)) } /
|
|
"sameTerm"i '(' _ a:Expression _ ',' _ b:Expression _ ')' { Expression::SameTermFunctionCall(Box::new(a), Box::new(b)) } /
|
|
("isIRI"i / "isURI"i) _ '(' _ e:Expression _ ')' { Expression::IsIRIFunctionCall(Box::new(e)) } /
|
|
"isBLANK"i '(' _ e:Expression _ ')' { Expression::IsBlankFunctionCall(Box::new(e)) } /
|
|
"isLITERAL"i '(' _ e:Expression _ ')' { Expression::IsLiteralFunctionCall(Box::new(e)) } /
|
|
"isNUMERIC"i '(' _ e:Expression _ ')' { Expression::IsNumericFunctionCall(Box::new(e)) } /
|
|
RegexExpression /
|
|
ExistsFunc /
|
|
NotExistsFunc
|
|
|
|
//[122]
|
|
RegexExpression -> Expression =
|
|
"REGEX"i _ '(' _ a:Expression _ ',' _ b:Expression _ ',' _ c:Expression _ ')' { Expression::RegexFunctionCall(Box::new(a), Box::new(b), Some(Box::new(c))) } /
|
|
"REGEX"i _ '(' _ a:Expression _ ',' _ b:Expression _ ')' { Expression::RegexFunctionCall(Box::new(a), Box::new(b), None) }
|
|
|
|
|
|
SubstringExpression -> Expression =
|
|
"SUBSTR"i _ '(' _ a:Expression _ ',' _ b:Expression _ ',' _ c:Expression _ ')' { Expression::SubStrFunctionCall(Box::new(a), Box::new(b), Some(Box::new(c))) } /
|
|
"SUBSTR"i _ '(' _ a:Expression _ ',' _ b:Expression _ ')' { Expression::SubStrFunctionCall(Box::new(a), Box::new(b), None) }
|
|
|
|
|
|
//[124]
|
|
StrReplaceExpression -> Expression =
|
|
"REPLACE"i _ '(' _ a:Expression _ ',' _ b:Expression _ ',' _ c:Expression _ ',' _ d:Expression _ ')' { Expression::ReplaceFunctionCall(Box::new(a), Box::new(b), Box::new(c), Some(Box::new(d))) } /
|
|
"REPLACE"i _ '(' _ a:Expression _ ',' _ b:Expression _ ',' _ c:Expression _ ')' { Expression::ReplaceFunctionCall(Box::new(a), Box::new(b), Box::new(c), None) }
|
|
|
|
//[125]
|
|
ExistsFunc -> Expression = "EXISTS"i _ p:GroupGraphPattern { Expression::ExistsFunctionCall(Box::new(p)) }
|
|
|
|
//[126]
|
|
NotExistsFunc -> Expression = "NOT"i _ "EXISTS"i _ p:GroupGraphPattern { Expression::UnaryNotExpression(Box::new(Expression::ExistsFunctionCall(Box::new(p)))) }
|
|
|
|
//[127]
|
|
Aggregate -> Aggregation =
|
|
"COUNT"i _ '(' _ "DISTINCT"i _ '*' _ ')' { Aggregation::Count(None, true) } /
|
|
"COUNT"i _ '(' _ "DISTINCT"i _ e:Expression _ ')' { Aggregation::Count(Some(Box::new(e)), true) } /
|
|
"COUNT"i _ '(' _ '*' _ ')' { Aggregation::Count(None, false) } /
|
|
"COUNT"i _ '(' _ e:Expression _ ')' { Aggregation::Count(Some(Box::new(e)), false) } /
|
|
"SUM"i _ '(' _ "DISTINCT"i _ e:Expression _ ')' { Aggregation::Sum(Box::new(e), true) } /
|
|
"SUM"i _ '(' _ e:Expression _ ')' { Aggregation::Sum(Box::new(e), false) } /
|
|
"MIN"i _ '(' _ "DISTINCT"i _ e:Expression _ ')' { Aggregation::Min(Box::new(e), true) } /
|
|
"MIN"i _ '(' _ e:Expression _ ')' { Aggregation::Min(Box::new(e), false) } /
|
|
"MAX"i _ '(' _ "DISTINCT"i _ e:Expression _ ')' { Aggregation::Max(Box::new(e), true) } /
|
|
"MAX"i _ '(' _ e:Expression _ ')' { Aggregation::Max(Box::new(e), false) } /
|
|
"AVG"i _ '(' _ "DISTINCT"i _ e:Expression _ ')' { Aggregation::Avg(Box::new(e), true) } /
|
|
"AVG"i _ '(' _ e:Expression _ ')' { Aggregation::Avg(Box::new(e), false) } /
|
|
"SAMPLE"i _ '(' _ "DISTINCT"i _ e:Expression _ ')' { Aggregation::Sample(Box::new(e), true) } /
|
|
"SAMPLE"i _ '(' _ e:Expression _ ')' { Aggregation::Sample(Box::new(e), false) } /
|
|
"GROUP_CONCAT"i _ '(' _ "DISTINCT"i _ e:Expression _ ';' _ 'SEPARATOR'i _ '=' _ s:String _ ')' { Aggregation::GroupConcat(Box::new(e), true, Some(s)) } /
|
|
"GROUP_CONCAT"i _ '(' _ "DISTINCT"i _ e:Expression _ ')' { Aggregation::GroupConcat(Box::new(e), true, None) } /
|
|
"GROUP_CONCAT"i _ '(' _ e:Expression _ ';' _ 'SEPARATOR'i _ '=' _ s:String _ ')' { Aggregation::GroupConcat(Box::new(e), true, Some(s)) } /
|
|
"GROUP_CONCAT"i _ '(' _ e:Expression _ ')' { Aggregation::GroupConcat(Box::new(e), false, None) }
|
|
|
|
//[128]
|
|
iriOrFunction -> Expression = i: iri _ a: ArgList? {
|
|
match a {
|
|
Some(a) => Expression::CustomFunctionCall(i, a),
|
|
None => Expression::ConstantExpression(i.into())
|
|
}
|
|
}
|
|
|
|
//[129]
|
|
RDFLiteral -> Literal =
|
|
v:String _ "^^" _ t:iri { Literal::new_typed_literal(v, t) } /
|
|
v:String _ l:LANGTAG { Literal::new_language_tagged_literal(v, l) } /
|
|
v:String { Literal::new_simple_literal(v) }
|
|
|
|
//[130]
|
|
NumericLiteral -> Literal = NumericLiteralUnsigned / NumericLiteralPositive / NumericLiteralNegative
|
|
|
|
//[131]
|
|
NumericLiteralUnsigned -> Literal =
|
|
d:$(DOUBLE) {? match f64::from_str(d) {
|
|
Ok(value) => Ok(value.into()),
|
|
Err(_) => Err("Invalid xsd:double")
|
|
} } /
|
|
d:$(DECIMAL) { Literal::new_typed_literal(d, xsd::DECIMAL.clone()) } /
|
|
i:$(INTEGER) { Literal::new_typed_literal(i, xsd::INTEGER.clone()) }
|
|
|
|
//[132]
|
|
NumericLiteralPositive -> Literal =
|
|
d:$(DOUBLE_POSITIVE) {? match f64::from_str(d) {
|
|
Ok(value) => Ok(value.into()),
|
|
Err(_) => Err("Invalid xsd:double")
|
|
} } /
|
|
d:$(DECIMAL_POSITIVE) { Literal::new_typed_literal(d, xsd::DECIMAL.clone()) } /
|
|
i:$(INTEGER_POSITIVE) { Literal::new_typed_literal(i, xsd::INTEGER.clone()) }
|
|
|
|
|
|
//[133]
|
|
NumericLiteralNegative -> Literal =
|
|
d:$(DOUBLE_NEGATIVE) {? match f64::from_str(d) {
|
|
Ok(value) => Ok(value.into()),
|
|
Err(_) => Err("Invalid xsd:double")
|
|
} } /
|
|
d:$(DECIMAL_NEGATIVE) { Literal::new_typed_literal(d, xsd::DECIMAL.clone()) } /
|
|
i:$(INTEGER_NEGATIVE) { Literal::new_typed_literal(i, xsd::INTEGER.clone()) }
|
|
|
|
//[134]
|
|
BooleanLiteral -> Literal =
|
|
"true" { true.into() } /
|
|
"false" { false.into() }
|
|
|
|
//[135]
|
|
String -> String = STRING_LITERAL_LONG1 / STRING_LITERAL_LONG2 / STRING_LITERAL1 / STRING_LITERAL2
|
|
|
|
//[136]
|
|
iri -> NamedNode = i:(IRIREF / PrefixedName) {?
|
|
match state.url_parser().parse(&i) {
|
|
Ok(url) => Ok(NamedNode::new(url)),
|
|
Err(error) => Err("IRI parsing failed")
|
|
}
|
|
}
|
|
|
|
//[137]
|
|
PrefixedName -> String = PNAME_LN /
|
|
ns:PNAME_NS {? state.namespaces.get(ns).cloned().ok_or("Prefix not found") }
|
|
|
|
//[138]
|
|
BlankNode -> BlankNode =
|
|
b:BLANK_NODE_LABEL { state.bnodes_map.entry(b.to_string()).or_insert_with(BlankNode::default).clone() } /
|
|
ANON { BlankNode::default() }
|
|
|
|
//[139]
|
|
IRIREF -> String = "<" i:$(([^\u{00}-\u{20}<>"{}|^\u{60}\u{5c}])*) ">" {
|
|
i.to_owned()
|
|
}
|
|
|
|
//[140]
|
|
PNAME_NS -> &'input str = ns:$(PN_PREFIX? ":") {
|
|
ns
|
|
}
|
|
|
|
//[141]
|
|
PNAME_LN -> String = ns:$(PNAME_NS) local:PN_LOCAL {?
|
|
state.namespaces.get(ns).map(|v| v.clone() + &local).ok_or("Prefix not found")
|
|
}
|
|
|
|
//[142]
|
|
BLANK_NODE_LABEL -> &'input str = "_:" b:$(([0-9] / PN_CHARS_U) PN_CHARS* ("."+ PN_CHARS+)*) {
|
|
b
|
|
}
|
|
|
|
//[143]
|
|
VAR1 -> &'input str = '?' v:$(VARNAME) { v }
|
|
|
|
//[144]
|
|
VAR2 -> &'input str = '$' v:$(VARNAME) { v }
|
|
|
|
//[145]
|
|
LANGTAG -> &'input str = "@" l:$([a-zA-Z]+ ("-" [a-zA-Z0-9]+)*) {
|
|
l
|
|
}
|
|
|
|
//[146]
|
|
INTEGER -> () = [0-9]+
|
|
|
|
//[147]
|
|
DECIMAL -> () = ([0-9]+ "." [0-9]* / [0-9]* "." [0-9]+)
|
|
|
|
//[148]
|
|
DOUBLE -> () = ([0-9]+ "." [0-9]* / "." [0-9]+ / [0-9]+) EXPONENT
|
|
|
|
//[149]
|
|
INTEGER_POSITIVE -> () = "+" _ INTEGER
|
|
|
|
//[150]
|
|
DECIMAL_POSITIVE -> () = "+" _ DECIMAL
|
|
|
|
//[151]
|
|
DOUBLE_POSITIVE -> () = "+" _ DOUBLE
|
|
|
|
//[152]
|
|
INTEGER_NEGATIVE -> () = "-" _ INTEGER
|
|
|
|
//[153]
|
|
DECIMAL_NEGATIVE -> () = "-" _ DECIMAL
|
|
|
|
//[154]
|
|
DOUBLE_NEGATIVE -> () = "-" _ DOUBLE
|
|
|
|
//[155]
|
|
EXPONENT -> () = [eE] [+-]? [0-9]+
|
|
|
|
//[156]
|
|
STRING_LITERAL1 -> String = "'" l:$((STRING_LITERAL1_simple_char / ECHAR)*) "'" {
|
|
unescape_echars(l).to_string()
|
|
}
|
|
STRING_LITERAL1_simple_char -> () = [^'\u{005c}\u{000a}\u{000d}]
|
|
|
|
|
|
//[157]
|
|
STRING_LITERAL2 -> String = "\"" l:$((STRING_LITERAL2_simple_char / ECHAR)*) "\"" {
|
|
unescape_echars(l).to_string()
|
|
}
|
|
STRING_LITERAL2_simple_char -> () = [^"\u{005c}\u{000a}\u{000d}]
|
|
|
|
//[158]
|
|
STRING_LITERAL_LONG1 -> String = "'''" l:$(STRING_LITERAL_LONG1_inner*) "'''" {
|
|
unescape_echars(l).to_string()
|
|
}
|
|
STRING_LITERAL_LONG1_inner -> () = ("''" / "'")? (STRING_LITERAL_LONG1_simple_char / ECHAR)
|
|
STRING_LITERAL_LONG1_simple_char -> () = [^'\u{005c}]
|
|
|
|
//[159]
|
|
STRING_LITERAL_LONG2 -> String = "\"\"\"" l:$(STRING_LITERAL_LONG2_inner*) "\"\"\"" {
|
|
unescape_echars(l).to_string()
|
|
}
|
|
STRING_LITERAL_LONG2_inner -> () = ("\"\"" / "\"")? (STRING_LITERAL_LONG2_simple_char / ECHAR)
|
|
STRING_LITERAL_LONG2_simple_char -> () = [^"\u{005c}]
|
|
|
|
//[160]
|
|
ECHAR -> () = "\\" [tbnrf"'\\]
|
|
|
|
//[161]
|
|
NIL -> () = "(" WS* ")"
|
|
|
|
//[162]
|
|
WS -> () = #quiet<[\u{20}\u{9}\u{D}\u{A}]>
|
|
|
|
//[163]
|
|
ANON -> () = '[' WS* ']'
|
|
|
|
//[164]
|
|
PN_CHARS_BASE -> () = [A-Za-z\u{00C0}-\u{00D6}\u{00D8}-\u{00F6}\u{00F8}-\u{02FF}\u{0370}-\u{037D}\u{037F}-\u{1FFF}\u{200C}-\u{200D}\u{2070}-\u{218F}\u{2C00}-\u{2FEF}\u{3001}-\u{D7FF}\u{F900}-\u{FDCF}\u{FDF0}-\u{FFFD}]
|
|
|
|
//[165]
|
|
PN_CHARS_U -> () = '_' / PN_CHARS_BASE
|
|
|
|
//[166]
|
|
VARNAME -> () = ([0-9] / PN_CHARS_U) ([0-9\u{00B7}\u{0300}-\u{036F}\u{203F}-\u{2040}] / PN_CHARS_U)*
|
|
|
|
//[167]
|
|
PN_CHARS -> () = [\-0-9\u{00B7}\u{0300}-\u{036F}\u{203F}-\u{2040}] / PN_CHARS_U
|
|
|
|
//[168]
|
|
PN_PREFIX -> () = PN_CHARS_BASE PN_CHARS* ("."+ PN_CHARS+)*
|
|
|
|
//[169]
|
|
PN_LOCAL -> String = f:PN_LOCAL_first c:(PN_LOCAL_next*) e:(PN_LOCAL_next_dot*) {
|
|
f.to_string() + &c.concat() + &e.concat()
|
|
}
|
|
PN_LOCAL_first -> String =
|
|
c:$(":" / [0-9] / PN_CHARS_U) { c.into() } /
|
|
PLX
|
|
PN_LOCAL_next -> String =
|
|
c:$(":" / PN_CHARS) { c.into() } /
|
|
PLX
|
|
PN_LOCAL_next_dot -> String = d:$('.'+) f:PN_LOCAL_next* { d.to_string() + &f.concat()}
|
|
|
|
//[170]
|
|
PLX -> String =
|
|
p:$(PERCENT) { p.into() } /
|
|
e:PN_LOCAL_ESC { iter::once(e).collect() }
|
|
|
|
//[171]
|
|
PERCENT -> () = "%" HEX HEX
|
|
|
|
//[172]
|
|
HEX -> () = ([0-9A-Fa-f])
|
|
|
|
//[173]
|
|
PN_LOCAL_ESC -> char = "\\" c:$([_~\.\-!$&'()*+,;=/?#@%]) { c.chars().next().unwrap() } //TODO: added '/' to make tests pass but is it valid?
|
|
|
|
//space
|
|
_ = #quiet<([ \t\n\r] / comment)*>
|
|
//comment
|
|
comment = #quiet<"#" [^\r\n]*>
|
|
|