private final static void getFDsAndEquivClassesForEqWithConstant(ConstantExpression c, VariableReferenceExpression v, Collection<FunctionalDependency> fds, Map<LogicalVariable, EquivalenceClass> equivClasses) { LogicalVariable var = v.getVariableReference(); LinkedList<LogicalVariable> head = new LinkedList<LogicalVariable>(); // empty set in the head LinkedList<LogicalVariable> tail = new LinkedList<LogicalVariable>(); tail.add(var); FunctionalDependency fd = new FunctionalDependency(head, tail); fds.add(fd); EquivalenceClass ec = equivClasses.get(var); if (ec == null) { LinkedList<LogicalVariable> members = new LinkedList<LogicalVariable>(); members.add(var); EquivalenceClass eclass = new EquivalenceClass(members, c); equivClasses.put(var, eclass); } else { if (ec.representativeIsConst()) { ILogicalExpression c1 = ec.getConstRepresentative(); if (!c1.equals(c)) { // here I could also rewrite to FALSE return; } } ec.setConstRepresentative(c); } }
public void merge(EquivalenceClass ec2) { members.addAll(ec2.getMembers()); if (!representativeIsConst && ec2.representativeIsConst()) { representativeIsConst = true; constRepresentative = ec2.getConstRepresentative(); } expressionMembers.addAll(ec2.getExpressionMembers()); }
private Set<LogicalVariable> getNormalizedColumnsAccordingToEqClasses(Set<LogicalVariable> columns, Map<LogicalVariable, EquivalenceClass> equivalenceClasses) { Set<LogicalVariable> normalizedColumns = new ListSet<>(); if (equivalenceClasses == null || equivalenceClasses.isEmpty()) { normalizedColumns.addAll(columns); return normalizedColumns; } for (LogicalVariable v : columns) { EquivalenceClass ec = equivalenceClasses.get(v); if (ec == null) { normalizedColumns.add(v); } else { if (ec.representativeIsConst()) { // trivially satisfied, so the var. can be removed } else { normalizedColumns.add(ec.getVariableRepresentative()); } } } return normalizedColumns; }
public EquivalenceClass cloneEquivalenceClass() { List<LogicalVariable> membersClone = new LinkedList<LogicalVariable>(); membersClone.addAll(members); EquivalenceClass ec; if (representativeIsConst()) { ec = new EquivalenceClass(membersClone, constRepresentative); } else { ec = new EquivalenceClass(membersClone, variableRepresentative); } return ec; }
for (LogicalVariable v2 : oc.getMembers()) { if (usedVariables.contains(v2)) { m.add(v2); if (oc.representativeIsConst()) { nc = new EquivalenceClass(m, oc.getConstRepresentative()); } else if (m.contains(oc.getVariableRepresentative())) { nc = new EquivalenceClass(m, oc.getVariableRepresentative()); } else { nc = new EquivalenceClass(m, v); for (ILogicalExpression expr : ec.getExpressionMembers()) { Set<LogicalVariable> exprUsedVars = new HashSet<>(); expr.getUsedVariables(exprUsedVars); ec.getMembers().forEach(v -> { eqClasses.put(v, ec); if (usedVarSet.contains(v)) { ec.setVariableRepresentative(v);
members.add(var1); members.add(var2); EquivalenceClass ec = new EquivalenceClass(members, var1); equivClasses.put(var1, ec); equivClasses.put(var2, ec); } else if (ec1 == null && ec2 != null) { ec2.addMember(var1); equivClasses.put(var1, ec2); } else if (ec2 == null && ec1 != null) { ec1.addMember(var2); equivClasses.put(var2, ec1); } else { ec1.merge(ec2); for (LogicalVariable w : equivClasses.keySet()) { if (ec2.getMembers().contains(w)) { equivClasses.put(w, ec1);
expr.setSourceLocation(operator.getSourceLocation()); EquivalenceClass equivClass = new EquivalenceClass(Collections.singletonList(var), var, Collections.singletonList(expr)); Map<LogicalVariable, EquivalenceClass> equivalenceMap = context.getEquivalenceClassMap(operator); if (equivalenceMap == null) {
new ConstantExpression(new AsterixConstantValue(new AInt32(parameterIndex / 2))))); // Every two parameters corresponds to a field. expr.setSourceLocation(funcExpr.getSourceLocation()); EquivalenceClass equivClass = new EquivalenceClass(Collections.singletonList(fieldVar), fieldVar, Collections.singletonList(expr)); ecs.put(fieldVar, equivClass);
@Override public boolean equals(Object obj) { if (!(obj instanceof EquivalenceClass)) { return false; } else { EquivalenceClass ec = (EquivalenceClass) obj; if (!members.equals(ec.getMembers())) { return false; } if (!expressionMembers.equals(ec.getExpressionMembers())) { return false; } if (representativeIsConst) { return ec.representativeIsConst() && (constRepresentative.equals(ec.getConstRepresentative())); } else { return !ec.representativeIsConst() && (variableRepresentative.equals(ec.getVariableRepresentative())); } } } }
/** * Normalizes or reduces the order columns argument based on the equivalenceClasses argument. The caller is * responsible for taking caution as to how to handle the returned object since this method either returns the same * object that is passed or returns a new object. * @param orderColumns the order columns that are to be normalized * @param equivalenceClasses {@link EquivalenceClass} * @return a new normalized object if normalization is applied. Otherwise, the same argument object is returned. */ public static List<OrderColumn> replaceOrderColumnsByEqClasses(List<OrderColumn> orderColumns, Map<LogicalVariable, EquivalenceClass> equivalenceClasses) { if (equivalenceClasses == null || equivalenceClasses.isEmpty()) { return orderColumns; } List<OrderColumn> norm = new ArrayList<>(); for (OrderColumn orderColumn : orderColumns) { EquivalenceClass columnEQClass = equivalenceClasses.get(orderColumn.getColumn()); if (columnEQClass == null) { norm.add(orderColumn); } else if (!columnEQClass.representativeIsConst()) { norm.add(new OrderColumn(columnEQClass.getVariableRepresentative(), orderColumn.getOrder())); } // else columnEQClass rep. is constant, i.e. trivially satisfied, so the var. can be removed } return norm; }
private List<OrderColumn> normalizeOrderingColumns(List<OrderColumn> inputOrderColumns, Map<LogicalVariable, EquivalenceClass> equivalenceClasses) { List<OrderColumn> newOrderColumns = new ArrayList<>(); if (equivalenceClasses == null || equivalenceClasses.isEmpty()) { newOrderColumns.addAll(inputOrderColumns); return newOrderColumns; } for (OrderColumn oc : inputOrderColumns) { LogicalVariable v = oc.getColumn(); EquivalenceClass ec = equivalenceClasses.get(v); if (ec == null) { newOrderColumns.add(new OrderColumn(v, oc.getOrder())); } else { if (ec.representativeIsConst()) { // trivially satisfied, so the var. can be removed } else { newOrderColumns.add(new OrderColumn(ec.getVariableRepresentative(), oc.getOrder())); } } } return newOrderColumns; }
EquivalenceClass ec2 = inheritedEcs.get(v2); LogicalVariable v3; if (ec2 != null && !ec2.representativeIsConst()) { v3 = ec2.getVariableRepresentative(); } else { v3 = v2;