com.redhat.lightblue.query.Projection Maven / Gradle / Ivy
/*
Copyright 2013 Red Hat, Inc. and/or its affiliates.
This file is part of lightblue.
This program is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program. If not, see
* - explicit_exclusion: the projection excludes this field explicitly
* - implicit_exzclusion: the projection excludes this field because an ancestor
* of the field is excluded
* - explicit_inclusion: the projection includes the field explicitly
* - explicit_exclusion: the projection excludes the field explicitly
* - undecided: the projection does not decide if the field should be
* included/excluded, and does not reference it
*
*/
public static enum Inclusion {
explicit_exclusion, implicit_exclusion, explicit_inclusion, implicit_inclusion, undecided
};
public static Projection fromJson(JsonNode node) {
if (node instanceof ArrayNode) {
return ProjectionList.fromJson((ArrayNode) node);
} else {
return BasicProjection.fromJson((ObjectNode) node);
}
}
/**
* Adds two projections and returns a new projection containing both. Any
* projection can be null. If the resulting projection is empty, returns
* null.
*/
public static Projection add(Projection p1, Projection p2) {
List list = new ArrayList<>();
if (p1 instanceof ProjectionList) {
list.addAll(((ProjectionList) p1).getItems());
} else if (p1 != null) {
list.add(p1);
}
if (p2 instanceof ProjectionList) {
list.addAll(((ProjectionList) p2).getItems());
} else if (p2 != null) {
list.add(p2);
}
return list.isEmpty() ? null : new ProjectionList(list);
}
/**
* Returns whether to include/exclude the field based on whether the field
* matches the pattern
*
* @param field The field name
* @param pattern The projection pattern
* @param inclusion flag to return if the field matches the given pattern
* @return value of inclusion if field matches the pattern,
* else null
*
*
* field pattern result
* a * true
* a a true
* a b false
* a.b * false
* a.b *.b true
* a.b a.* true
* a.b *.* true
* a.b a.b true
*
*
* The return value is inclusion if result is true,
* null if result is false, meaning that whether the field
* should be included or not cannot be decided.
*/
public static Boolean fieldMatchesPattern(Path field, Path pattern, boolean inclusion) {
if (field.matches(pattern)) {
return inclusion;
} else {
return null;
}
}
/**
* If the field is an ancestor of the pattern, and if inclusion
* is true, returns true. Otherwise, returns null, meaning that whether the
* field is included or not cannot be decided.
*
* @param field The field name
* @param pattern The projection pattern
* @param inclusion flag to return if the field matches the given pattern
* @return TRUE if field is ancestor of the pattern and
* inclusion is true, else null
*/
public static Boolean fieldAncestorOfPattern(Path field, Path pattern, boolean inclusion) {
if (field.matchingPrefix(pattern)) {
if (inclusion) {
return Boolean.TRUE;
} else {
return null;
}
} else {
return null;
}
}
/**
* Returns if the field should be included based on the recursive pattern.
*
* @param field The field name
* @param pattern The projection pattern
* @param inclusion flag to return if the field matches the given pattern
* @return Boolean value of inclusion if field is in subtree of
* pattern else null
*/
public static Boolean impliedInclusion(Path field, Path pattern, boolean inclusion) {
if (field.numSegments() > pattern.numSegments() && // If we're checking a field deeper than the pattern
// And if we're checking a field under the subtree of the pattern
field.prefix(pattern.numSegments()).matches(pattern)) {
return inclusion ? Boolean.TRUE : Boolean.FALSE;
} else {
return null;
}
}
/**
* Returns if the field should be included based on the pattern given.
*
* @param field The field whose inclusion is to be decided
* @param pattern The field pattern of projection
* @param inclusion If the projection expression includes the field. If
* false, the projection is for exclusion
* @param recursive If the projection is recursive
*
* @return implicit or explicit inclusion/exclusion, or undecided if
* projection does not decide if the field should be included/excluded
*/
public static Inclusion isFieldIncluded(Path field,
Path pattern,
boolean inclusion,
boolean recursive) {
// field match first, most specific type of check
Boolean v = fieldMatchesPattern(field, pattern, inclusion);
if (v != null) {
// if the last segment is ANY then inclusion/exclusion is implicit. else, inclusion/exclusion is explicit
if (pattern.tail(0).equals(Path.ANY)) {
return v ? Inclusion.implicit_inclusion : Inclusion.implicit_exclusion;
} else {
return v ? Inclusion.explicit_inclusion : Inclusion.explicit_exclusion;
}
}
// check field ancestor
v = fieldAncestorOfPattern(field, pattern, inclusion);
if (v != null) {
// is always explicit
return v ? Inclusion.explicit_inclusion : Inclusion.explicit_exclusion;
}
// if recursive, check for implied inclusion/exclusion
if (recursive) {
v = impliedInclusion(field, pattern, inclusion);
if (v != null) {
// recursive is always implicit
return v ? Inclusion.implicit_inclusion : Inclusion.implicit_exclusion;
}
}
return Inclusion.undecided;
}
/**
* Determines if the field is included in this projection
*
* @param field The absolute name of the field
*
* If the field name contains array indexes, they are converted to '*'
* before evaluation.
*/
public Inclusion getFieldInclusion(Path field) {
LOGGER.debug("Checking if {} is projected", field);
return getFieldInclusion(field, Path.EMPTY);
}
/**
* Determine if the field is explicitly included/excluded, implicitly included, or
* the projection does not decide on the field.
*/
public Inclusion getFieldInclusion(Path field,Path ctx) {
Path mfield = toMask(field);
ctx = toMask(ctx);
if (this instanceof FieldProjection) {
return getFieldInclusion(mfield, (FieldProjection) this, ctx);
} else if (this instanceof ArrayProjection) {
return getFieldInclusion(mfield, (ArrayProjection) this, ctx);
} else if (this instanceof ProjectionList) {
return getFieldInclusion(mfield, (ProjectionList) this, ctx);
}
return Inclusion.undecided;
}
/**
* Returns true if the field is needed to evaluate the projection
*/
public boolean isFieldRequiredToEvaluateProjection(Path field) {
LOGGER.debug("Checking if {} is referenced in projection", field);
return isFieldRequiredToEvaluateProjection(field, Path.EMPTY);
}
/**
* Returns true if the field is needed to evaluate the projection
*/
public boolean isFieldRequiredToEvaluateProjection(Path field,Path ctx) {
Path mfield = toMask(field);
ctx = toMask(ctx);
if (this instanceof FieldProjection) {
switch(getFieldInclusion(mfield, (FieldProjection) this, ctx)) {
case implicit_inclusion:
case explicit_inclusion: return true;
default: return false;
}
} else if (this instanceof ArrayQueryMatchProjection) {
if(getFieldInclusion(mfield, (ArrayProjection) this, ctx)==Inclusion.undecided) {
LOGGER.debug("whether to include {} is Undecided, checking projection query",mfield);
Path absField = new Path(ctx, toMask(((ArrayQueryMatchProjection)this).getField()));
Path nestedCtx=new Path(absField,Path.ANYPATH);
boolean ret= ((ArrayQueryMatchProjection)this).getMatch().isRequired(field,nestedCtx);
LOGGER.debug("isRequired({},{}.*={}",field,absField,ret);
if(ret)
return true;
LOGGER.debug("Query does not require {}, checking nested projection",mfield);
if( ((ArrayProjection)this).getProject()!=null)
ret=((ArrayProjection)this).getProject().isFieldRequiredToEvaluateProjection(field,nestedCtx);
LOGGER.debug("result:{}",ret);
return ret;
} else {
return true;
}
} else if (this instanceof ArrayRangeProjection) {
return getFieldInclusion(mfield, (ArrayProjection) this, ctx)!=Inclusion.undecided;
} else if (this instanceof ProjectionList) {
for(Projection x:((ProjectionList)this).getItems()) {
if(x.isFieldRequiredToEvaluateProjection(field,ctx))
return true;
}
}
return false;
}
private Inclusion getFieldInclusion(Path field, ArrayProjection p, Path context) {
Path absField = new Path(context, toMask(p.getField()));
LOGGER.debug("Checking if array projection on {} projects {}", absField, field);
Inclusion inc = isFieldIncluded(field, absField, p.isInclude(), false);
Inclusion inc2 = p.getProject().getFieldInclusion(field,new Path(absField,Path.ANYPATH));
Inclusion ret;
if(inc==Inclusion.explicit_inclusion||inc2==Inclusion.explicit_inclusion)
ret=Inclusion.explicit_inclusion;
else if(inc==Inclusion.implicit_inclusion||inc2==Inclusion.implicit_inclusion)
ret=Inclusion.implicit_inclusion;
else if(inc==Inclusion.explicit_exclusion||inc2==Inclusion.explicit_exclusion)
ret=Inclusion.explicit_exclusion;
else if(inc==Inclusion.implicit_exclusion||inc2==Inclusion.implicit_exclusion)
ret=Inclusion.implicit_exclusion;
else
ret=Inclusion.undecided;
LOGGER.debug("array projection on {} projects {}: {}", absField, field, ret);
return ret;
}
private Inclusion getFieldInclusion(Path field, ProjectionList p, Path context) {
LOGGER.debug("Checking if a projection list projects {}", field);
Inclusion lastResult = Inclusion.undecided;
List items=p.getItems();
ListIterator itemsItr = items.listIterator(items.size());
while (itemsItr.hasPrevious()) {
Inclusion ret = itemsItr.previous().getFieldInclusion(field, context);
if (ret != Inclusion.undecided) {
lastResult=ret;
break;
}
}
LOGGER.debug("Projection list projects {}: {}", field, lastResult);
return lastResult;
}
private Inclusion getFieldInclusion(Path field, FieldProjection p, Path context) {
Path projectionField = new Path(context, toMask(p.getField()));
LOGGER.debug("Checking if field projection on {} projects {}", projectionField, field);
Inclusion inc = isFieldIncluded(field, projectionField, p.isInclude(), p.isRecursive());
LOGGER.debug("Field projection on {} projects {}: {}", projectionField, field, inc);
return inc;
}
/**
* If a path includes array indexes, change the indexes into ANY
*/
private static Path toMask(Path p) {
int n = p.numSegments();
MutablePath mp = null;
for (int i = 0; i < n; i++) {
if (p.isIndex(i)) {
if (mp == null) {
mp = p.mutableCopy();
}
mp.set(i, Path.ANY);
}
}
return mp == null ? p : mp.immutableCopy();
}
protected static Path getNonRelativePath(Path p) {
List segments = new ArrayList<>();
int numberOfParentsOnPath = 0;
for (int i = p.numSegments() - 1; i >= 0; i--) {
if (Path.THIS.equals(p.head(i))) {
continue;
} else if (Path.PARENT.equals(p.head(i))) {
numberOfParentsOnPath++;
} else {
if (numberOfParentsOnPath > 0) {
numberOfParentsOnPath--;
continue;
}
segments.add(p.head(i));
}
}
Collections.reverse(segments);
return new Path(Joiner.on(".").join(segments));
}
}