use of org.eclipse.rdf4j.query.parser.sparql.ast.VisitorException in project rdf4j by eclipse.
the class SPARQLParser method parseUpdate.
@Override
public ParsedUpdate parseUpdate(String updateStr, String baseURI) throws MalformedQueryException {
try {
ParsedUpdate update = new ParsedUpdate(updateStr);
ASTUpdateSequence updateSequence = SyntaxTreeBuilder.parseUpdateSequence(updateStr);
List<ASTUpdateContainer> updateOperations = updateSequence.getUpdateContainers();
List<ASTPrefixDecl> sharedPrefixDeclarations = null;
Node node = updateSequence.jjtGetChild(0);
Set<String> globalUsedBNodeIds = new HashSet<String>();
for (int i = 0; i < updateOperations.size(); i++) {
ASTUpdateContainer uc = updateOperations.get(i);
if (uc.jjtGetNumChildren() == 0 && i > 0 && i < updateOperations.size() - 1) {
// empty update in the middle of the sequence
throw new MalformedQueryException("empty update in sequence not allowed");
}
StringEscapesProcessor.process(uc);
BaseDeclProcessor.process(uc, baseURI);
WildcardProjectionProcessor.process(uc);
if (uc.getBaseDecl() != null) {
baseURI = uc.getBaseDecl().getIRI();
}
// do a special dance to handle prefix declarations in sequences: if
// the current
// operation has its own prefix declarations, use those. Otherwise,
// try and use
// prefix declarations from a previous operation in this sequence.
List<ASTPrefixDecl> prefixDeclList = uc.getPrefixDeclList();
if (prefixDeclList == null || prefixDeclList.size() == 0) {
if (sharedPrefixDeclarations != null) {
for (ASTPrefixDecl prefixDecl : sharedPrefixDeclarations) {
uc.jjtAppendChild(prefixDecl);
}
}
} else {
sharedPrefixDeclarations = prefixDeclList;
}
PrefixDeclProcessor.process(uc);
Set<String> usedBNodeIds = BlankNodeVarProcessor.process(uc);
if (uc.getUpdate() instanceof ASTInsertData || uc.getUpdate() instanceof ASTInsertData) {
if (Collections.disjoint(usedBNodeIds, globalUsedBNodeIds)) {
globalUsedBNodeIds.addAll(usedBNodeIds);
} else {
throw new MalformedQueryException("blank node identifier may not be shared across INSERT/DELETE DATA operations");
}
}
UpdateExprBuilder updateExprBuilder = new UpdateExprBuilder(SimpleValueFactory.getInstance());
ASTUpdate updateNode = uc.getUpdate();
if (updateNode != null) {
UpdateExpr updateExpr = (UpdateExpr) updateNode.jjtAccept(updateExprBuilder, null);
// add individual update expression to ParsedUpdate sequence
// container
update.addUpdateExpr(updateExpr);
// associate updateExpr with the correct dataset (if any)
Dataset dataset = DatasetDeclProcessor.process(uc);
update.map(updateExpr, dataset);
}
}
return update;
} catch (ParseException e) {
throw new MalformedQueryException(e.getMessage(), e);
} catch (TokenMgrError e) {
throw new MalformedQueryException(e.getMessage(), e);
} catch (VisitorException e) {
throw new MalformedQueryException(e.getMessage(), e);
}
}
use of org.eclipse.rdf4j.query.parser.sparql.ast.VisitorException in project rdf4j by eclipse.
the class UpdateExprBuilder method visit.
@Override
public TupleExpr visit(ASTDeleteClause node, Object data) throws VisitorException {
TupleExpr result = (TupleExpr) data;
// Collect construct triples
GraphPattern parentGP = graphPattern;
graphPattern = new GraphPattern();
// inherit scope & context
graphPattern.setStatementPatternScope(parentGP.getStatementPatternScope());
graphPattern.setContextVar(parentGP.getContextVar());
for (int i = 0; i < node.jjtGetNumChildren(); i++) {
node.jjtGetChild(i).jjtAccept(this, data);
}
TupleExpr deleteExpr = graphPattern.buildTupleExpr();
// FIXME we should adapt the grammar so we can avoid doing this in
// post-processing.
VarCollector collector = new VarCollector();
deleteExpr.visit(collector);
for (Var var : collector.getCollectedVars()) {
if (var.isAnonymous() && !var.hasValue()) {
// blank node in delete pattern, not allowed by SPARQL spec.
throw new VisitorException("DELETE clause may not contain blank nodes");
}
}
graphPattern = parentGP;
return deleteExpr;
}
use of org.eclipse.rdf4j.query.parser.sparql.ast.VisitorException in project rdf4j by eclipse.
the class WildcardProjectionProcessor method process.
public static void process(ASTOperationContainer container) throws MalformedQueryException {
ASTOperation operation = container.getOperation();
// scan for nested SELECT clauses in the operation's WHERE clause
if (operation != null) {
ASTWhereClause whereClause = operation.getWhereClause();
// DESCRIBE queries and certain update operations can be without a WHERE clause
if (whereClause != null) {
SelectClauseCollector collector = new SelectClauseCollector();
try {
whereClause.jjtAccept(collector, null);
Set<ASTSelect> selectClauses = collector.getSelectClauses();
for (ASTSelect selectClause : selectClauses) {
if (selectClause.isWildcard()) {
ASTSelectQuery q = (ASTSelectQuery) selectClause.jjtGetParent();
addQueryVars(q.getWhereClause(), selectClause);
selectClause.setWildcard(false);
}
}
} catch (VisitorException e) {
throw new MalformedQueryException(e);
}
}
}
if (operation instanceof ASTSelectQuery) {
// check for wildcard in upper SELECT query
ASTSelectQuery selectQuery = (ASTSelectQuery) operation;
ASTSelect selectClause = selectQuery.getSelect();
if (selectClause.isWildcard()) {
addQueryVars(selectQuery.getWhereClause(), selectClause);
selectClause.setWildcard(false);
}
} else if (operation instanceof ASTDescribeQuery) {
// check for possible wildcard in DESCRIBE query
ASTDescribeQuery describeQuery = (ASTDescribeQuery) operation;
ASTDescribe describeClause = describeQuery.getDescribe();
if (describeClause.isWildcard()) {
addQueryVars(describeQuery.getWhereClause(), describeClause);
describeClause.setWildcard(false);
}
}
}
Aggregations