@Override public String getPlanDescription(IndexPlan plan, NodeState root) { if (baseIndex == null) { return "aggregate no-index"; } StringBuilder buff = new StringBuilder("aggregate "); if (getNodeAggregator() == null) { // path-though buff.append(baseIndex.getPlanDescription(plan, root)); return buff.toString(); } else if (!(plan instanceof AggregateIndexPlan)) { buff.append(baseIndex.getPlanDescription(plan, root)); return buff.toString(); } AggregateIndexPlan aggPlan = (AggregateIndexPlan) plan; for (IndexPlan p : aggPlan.getPlans()) { if (p != null) { buff.append(baseIndex.getPlanDescription(p, root)); buff.append(" "); } } return buff.toString(); }
@Override public List<IndexPlan> getPlans(Filter filter, List<OrderEntry> sortOrder, NodeState rootState) { if (baseIndex == null) { return Collections.emptyList(); } FullTextExpression e = filter.getFullTextConstraint(); if (getNodeAggregator() == null || e == null) { // no aggregation: path-though return baseIndex.getPlans(filter, sortOrder, rootState); } if (!hasCompositeExpression(e)) { // path-though, but without node type restriction return baseIndex.getPlans(newAggregationFilter(filter, null), sortOrder, rootState); } AggregateIndexPlan plan = new AggregateIndexPlan(filter); collectCombinedPlan(e, filter, sortOrder, rootState, plan, ""); if (plan.containsPathWithoutPlan()) { // the full-text index didn't return a plan LOG.debug("Full-text index without plan: " + e); return Collections.emptyList(); } return Collections.singletonList((IndexPlan) plan); }
@Override public List<IndexPlan> getPlans(Filter filter, List<OrderEntry> sortOrder, NodeState rootState) { if (baseIndex == null) { return Collections.emptyList(); } FullTextExpression e = filter.getFullTextConstraint(); if (getNodeAggregator() == null || e == null) { // no aggregation: path-though return baseIndex.getPlans(filter, sortOrder, rootState); } if (!hasCompositeExpression(e)) { // path-though, but without node type restriction return baseIndex.getPlans(newAggregationFilter(filter, null), sortOrder, rootState); } AggregateIndexPlan plan = new AggregateIndexPlan(filter); collectCombinedPlan(e, filter, sortOrder, rootState, plan, ""); if (plan.containsPathWithoutPlan()) { // the full-text index didn't return a plan LOG.debug("Full-text index without plan: " + e); return Collections.emptyList(); } return Collections.singletonList((IndexPlan) plan); }
@Override public String getPlanDescription(IndexPlan plan, NodeState root) { if (baseIndex == null) { return "aggregate no-index"; } StringBuilder buff = new StringBuilder("aggregate "); if (getNodeAggregator() == null) { // path-though buff.append(baseIndex.getPlanDescription(plan, root)); return buff.toString(); } else if (!(plan instanceof AggregateIndexPlan)) { buff.append(baseIndex.getPlanDescription(plan, root)); return buff.toString(); } AggregateIndexPlan aggPlan = (AggregateIndexPlan) plan; for (IndexPlan p : aggPlan.getPlans()) { if (p != null) { buff.append(baseIndex.getPlanDescription(p, root)); buff.append(" "); } } return buff.toString(); }
@Override public List<IndexPlan> getPlans(Filter filter, List<OrderEntry> sortOrder, NodeState rootState) { if (baseIndex == null) { return Collections.emptyList(); } FullTextExpression e = filter.getFullTextConstraint(); if (getNodeAggregator() == null || e == null) { // no aggregation: path-though return baseIndex.getPlans(filter, sortOrder, rootState); } if (!hasCompositeExpression(e)) { // path-though, but without node type restriction return baseIndex.getPlans(newAggregationFilter(filter, null), sortOrder, rootState); } AggregateIndexPlan plan = new AggregateIndexPlan(filter); collectCombinedPlan(e, filter, sortOrder, rootState, plan, ""); if (plan.containsPathWithoutPlan()) { // the full-text index didn't return a plan LOG.debug("Full-text index without plan: " + e); return Collections.emptyList(); } return Collections.singletonList((IndexPlan) plan); }
@Override public String getPlanDescription(IndexPlan plan, NodeState root) { if (baseIndex == null) { return "aggregate no-index"; } StringBuilder buff = new StringBuilder("aggregate "); if (getNodeAggregator() == null) { // path-though buff.append(baseIndex.getPlanDescription(plan, root)); return buff.toString(); } else if (!(plan instanceof AggregateIndexPlan)) { buff.append(baseIndex.getPlanDescription(plan, root)); return buff.toString(); } AggregateIndexPlan aggPlan = (AggregateIndexPlan) plan; for (IndexPlan p : aggPlan.getPlans()) { if (p != null) { buff.append(baseIndex.getPlanDescription(p, root)); buff.append(" "); } } return buff.toString(); }
@Override public Cursor query(IndexPlan plan, NodeState rootState) { if (getNodeAggregator() == null) { // path-though return baseIndex.query(plan, rootState); } else if (!(plan instanceof AggregateIndexPlan)) { // remove the node type restriction plan.setFilter(newAggregationFilter(plan.getFilter(), null)); return newAggregationCursor(plan, rootState); } Filter filter = plan.getFilter(); AggregateIndexPlan aggPlan = (AggregateIndexPlan) plan; FullTextExpression constraint = filter.getFullTextConstraint(); return flatten(constraint, aggPlan, filter, rootState, ""); }
@Override public Cursor query(IndexPlan plan, NodeState rootState) { if (getNodeAggregator() == null) { // path-though return baseIndex.query(plan, rootState); } else if (!(plan instanceof AggregateIndexPlan)) { // remove the node type restriction plan.setFilter(newAggregationFilter(plan.getFilter(), null)); return newAggregationCursor(plan, rootState); } Filter filter = plan.getFilter(); AggregateIndexPlan aggPlan = (AggregateIndexPlan) plan; FullTextExpression constraint = filter.getFullTextConstraint(); return flatten(constraint, aggPlan, filter, rootState, ""); }
@Override public Cursor query(IndexPlan plan, NodeState rootState) { if (getNodeAggregator() == null) { // path-though return baseIndex.query(plan, rootState); } else if (!(plan instanceof AggregateIndexPlan)) { // remove the node type restriction plan.setFilter(newAggregationFilter(plan.getFilter(), null)); return newAggregationCursor(plan, rootState); } Filter filter = plan.getFilter(); AggregateIndexPlan aggPlan = (AggregateIndexPlan) plan; FullTextExpression constraint = filter.getFullTextConstraint(); return flatten(constraint, aggPlan, filter, rootState, ""); }
@Override public List<IndexPlan> getPlans(Filter filter, List<OrderEntry> sortOrder, NodeState rootState) { return delegate.getPlans(filter, sortOrder, rootState); }
@Override public String getPlan(Filter filter, NodeState rootState) { return delegate.getPlan(filter, rootState); }
@Override public double getMinimumCost() { return delegate.getMinimumCost(); }
private Cursor newAggregationCursor(IndexPlan plan, NodeState rootState) { Cursor c = baseIndex.query(plan, rootState); // we possibly get results from a child, // so we need to wrap the cursor to do aggregation return new AggregationCursor(c, getNodeAggregator(), rootState); }
@Override public String getIndexName() { if (baseIndex == null) { return "aggregate no-index"; } return "aggregate " + baseIndex.getIndexName(); }
private Cursor newAggregationCursor(IndexPlan plan, NodeState rootState) { Cursor c = baseIndex.query(plan, rootState); // we possibly get results from a child, // so we need to wrap the cursor to do aggregation return new AggregationCursor(c, getNodeAggregator(), rootState); }
@Override public double getMinimumCost() { return baseIndex.getMinimumCost(); }
@Override public NodeAggregator getNodeAggregator() { return baseIndex.getNodeAggregator(); }
@Override public NodeAggregator getNodeAggregator() { return baseIndex.getNodeAggregator(); }
@Override public String getIndexName() { return delegate.getIndexName(); }
@Override public double getCost(Filter filter, NodeState rootState) { return delegate.getCost(filter, rootState); }