@Override
protected double getCardinality(StatementPattern sp) {
logger.info("get cardinality");
try {
Value subj = getConstantValue(sp.getSubjectVar());
if (!(subj instanceof Resource)) {
// can happen when a previous optimizer has inlined a
// comparison operator.
// this can cause, for example, the subject variable to be
// equated to a literal value.
// See SES-970
subj = null;
}
Value pred = getConstantValue(sp.getPredicateVar());
if (!(pred instanceof URI)) {
// can happen when a previous optimizer has inlined a
// comparison operator. See SES-970
pred = null;
}
Value obj = getConstantValue(sp.getObjectVar());
Value context = getConstantValue(sp.getContextVar());
if (!(context instanceof Resource)) {
// can happen when a previous optimizer has inlined a
// comparison operator. See SES-970
context = null;
}
// System.out.println("begin to do kvStore.cardinalitty");
return kvStore.cardinality((Resource) subj, (URI) pred, obj, (Resource) context);
} catch (Exception e) {
logger.error(
"Failed to estimate statement pattern cardinality, falling back to generic implementation",
e);
return super.getCardinality(sp);
}
}
public void meet(StatementPattern node) {
if (!Scope.DEFAULT_CONTEXTS.equals(node.getScope())) {
basicPattern = false;
} else if (node.getContextVar() != null) {
basicPattern = false;
} else {
super.meet(node);
}
}
private RDFRectangle toRectangle(StatementPattern pattern, BindingSet bindings) {
Value sVal = pattern.getSubjectVar().getValue();
Value pVal = pattern.getPredicateVar().getValue();
Value oVal = pattern.getObjectVar().getValue();
RDFURIRange subjectRange;
List<String> list = new ArrayList<String>();
if (sVal == null) {
if (bindings.hasBinding(pattern.getSubjectVar().getName()))
list.add(bindings.getValue(pattern.getSubjectVar().getName()).stringValue());
} else list.add(sVal.stringValue());
if (!list.isEmpty()) subjectRange = new RDFURIRange(list);
else subjectRange = new RDFURIRange();
ExplicitSetRange<URI> predicateRange;
Set<URI> set = new HashSet<URI>();
if (pVal == null) {
if (bindings.hasBinding(pattern.getPredicateVar().getName()))
set.add((URI) bindings.getValue(pattern.getPredicateVar().getName()));
} else set.add((URI) pVal);
if (!set.isEmpty()) predicateRange = new ExplicitSetRange<URI>(set);
else predicateRange = new ExplicitSetRange<>();
RDFValueRange objectRange = new RDFValueRange();
if (oVal == null) {
if (bindings.hasBinding(pattern.getObjectVar().getName()))
objectRange = fillObjectRange(bindings.getValue(pattern.getObjectVar().getName()));
} else objectRange = fillObjectRange(oVal);
return new RDFRectangle(subjectRange, predicateRange, objectRange);
}
/**
* Gets the set of variables that are relevant for the constructor. This method accumulates all
* subject, predicate and object variables from the supplied statement patterns, but ignores any
* context variables.
*/
private Set<Var> getConstructVars(Collection<StatementPattern> statementPatterns) {
Set<Var> vars = new LinkedHashSet<Var>(statementPatterns.size() * 2);
for (StatementPattern sp : statementPatterns) {
vars.add(sp.getSubjectVar());
vars.add(sp.getPredicateVar());
vars.add(sp.getObjectVar());
}
return vars;
}
@Override
public void meet(StatementPattern node) throws RepositoryException {
Resource subj = (Resource) node.getSubjectVar().getValue();
IRI pred = (IRI) node.getPredicateVar().getValue();
Value obj = node.getObjectVar().getValue();
Resource[] ctx = getContexts(node.getContextVar());
for (RepositoryConnection member : members) {
if (member.hasStatement(subj, pred, obj, true, ctx)) {
return;
}
}
node.replaceWith(new EmptySet());
}
/**
* Provides a string representation of an SP which contains info about whether each component
* (subj, pred, obj) is constant and its data and data type if it is constant.
*
* @param sp - The statement pattern to convert. (not null)
* @return A String representation of the statement pattern that may be used to do triple
* matching.
*/
public static String toStatementPatternString(final StatementPattern sp) {
checkNotNull(sp);
final Var subjVar = sp.getSubjectVar();
String subj = subjVar.getName();
if (subjVar.isConstant()) {
subj = subj + TYPE_DELIM + URI_TYPE;
}
final Var predVar = sp.getPredicateVar();
String pred = predVar.getName();
if (predVar.isConstant()) {
pred = pred + TYPE_DELIM + URI_TYPE;
}
final Var objVar = sp.getObjectVar();
String obj = objVar.getName();
if (objVar.isConstant()) {
final RyaType rt = RdfToRyaConversions.convertValue(objVar.getValue());
obj = obj + TYPE_DELIM + rt.getDataType().stringValue();
}
return subj + DELIM + pred + DELIM + obj;
}
@Override
protected void meetSP(StatementPattern node) throws Exception {
StatementPattern sp = node.clone();
final Var predVar = sp.getPredicateVar();
URI pred = (URI) predVar.getValue();
String predNamespace = pred.getNamespace();
final Var objVar = sp.getObjectVar();
final Var cntxtVar = sp.getContextVar();
if (objVar != null
&& !RDF.NAMESPACE.equals(predNamespace)
&& !SESAME.NAMESPACE.equals(predNamespace)
&& !RDFS.NAMESPACE.equals(predNamespace)
&& !EXPANDED.equals(cntxtVar)) {
URI transPropUri = (URI) predVar.getValue();
if (inferenceEngine.isTransitiveProperty(transPropUri)) {
node.replaceWith(
new TransitivePropertySP(
sp.getSubjectVar(), sp.getPredicateVar(), sp.getObjectVar(), sp.getContextVar()));
}
}
}
private TupleExpr buildConstructor(
TupleExpr bodyExpr,
TupleExpr constructExpr,
boolean explicitConstructor,
boolean distinct,
boolean reduced) {
TupleExpr result = bodyExpr;
// Retrieve all StatementPattern's from the construct expression
List<StatementPattern> statementPatterns = StatementPatternCollector.process(constructExpr);
Set<Var> constructVars = getConstructVars(statementPatterns);
// Note: duplicate elimination is a two-step process. The first step
// removes duplicates from the set of constructor variables. After this
// step, any bnodes that need to be generated are added to each solution
// and these solutions are projected to subject-predicate-object
// bindings.
// Finally, the spo-bindings are again filtered for duplicates.
if (distinct || reduced) {
// Create projection that removes all bindings that are not used in
// the
// constructor
ProjectionElemList projElemList = new ProjectionElemList();
for (Var var : constructVars) {
// Ignore anonymous and constant vars, these will be handled
// after
// the distinct
if (!var.isAnonymous() && !var.hasValue()) {
projElemList.addElement(new ProjectionElem(var.getName()));
}
}
result = new Projection(result, projElemList);
// Filter the duplicates from these projected bindings
if (distinct) {
result = new Distinct(result);
} else {
result = new Reduced(result);
}
}
// Create BNodeGenerator's for all anonymous variables
Map<Var, ExtensionElem> extElemMap = new HashMap<Var, ExtensionElem>();
for (Var var : constructVars) {
if (var.isAnonymous() && !extElemMap.containsKey(var)) {
ValueExpr valueExpr = null;
if (var.hasValue()) {
valueExpr = new ValueConstant(var.getValue());
} else if (explicitConstructor) {
// only generate bnodes in case of an explicit constructor
valueExpr = new BNodeGenerator();
}
if (valueExpr != null) {
extElemMap.put(var, new ExtensionElem(valueExpr, var.getName()));
}
}
}
if (!extElemMap.isEmpty()) {
result = new Extension(result, extElemMap.values());
}
// Create a Projection for each StatementPattern in the constructor
List<ProjectionElemList> projections = new ArrayList<ProjectionElemList>();
for (StatementPattern sp : statementPatterns) {
ProjectionElemList projElemList = new ProjectionElemList();
projElemList.addElement(new ProjectionElem(sp.getSubjectVar().getName(), "subject"));
projElemList.addElement(new ProjectionElem(sp.getPredicateVar().getName(), "predicate"));
projElemList.addElement(new ProjectionElem(sp.getObjectVar().getName(), "object"));
projections.add(projElemList);
}
if (projections.size() == 1) {
result = new Projection(result, projections.get(0));
// Note: no need to apply the second duplicate elimination step if
// there's just one projection
} else if (projections.size() > 1) {
result = new MultiProjection(result, projections);
if (distinct) {
// Add another distinct to filter duplicate statements
result = new Distinct(result);
} else if (reduced) {
result = new Reduced(result);
}
} else {
// Empty constructor
result = new EmptySet();
}
return result;
}