@Override public void substituteVar(LogicalVariable v1, LogicalVariable v2) { if (variable.equals(v1)) { variable = v2; } }
private boolean varEquivalent(LogicalVariable left, LogicalVariable right) { if (variableMapping.get(right) == null) { return false; } return variableMapping.get(right).equals(left); }
private boolean isIdentical(List<LogicalVariable> finalSchema, List<LogicalVariable> inputSchema) throws AlgebricksException { int finalSchemaSize = finalSchema.size(); int inputSchemaSize = inputSchema.size(); if (finalSchemaSize != inputSchemaSize) { return false; } for (int i = 0; i < finalSchemaSize; i++) { LogicalVariable var1 = finalSchema.get(i); LogicalVariable var2 = inputSchema.get(i); if (!var1.equals(var2)) { return false; } } return true; }
@Override public Object getVarType(LogicalVariable var, List<LogicalVariable> nonNullVariables, List<List<LogicalVariable>> correlatedNullableVariableLists) throws AlgebricksException { if (var.equals(optFuncExpr.getSourceVar(exprAndVarIdx.second))) { return keyType; } throw new IllegalArgumentException(); }
@Override public Object getVarType(LogicalVariable var) throws AlgebricksException { if (var.equals(optFuncExpr.getSourceVar(exprAndVarIdx.second))) { return keyType; } throw new IllegalArgumentException(); }
@Override public boolean equals(Object obj) { if (obj instanceof VariableReferenceExpression) { final VariableReferenceExpression varRefExpr = (VariableReferenceExpression) obj; return tupleRef == varRefExpr.tupleRef && variable.equals(varRefExpr.getVariableReference()); } return false; }
@Override public Void visitUnionOperator(UnionAllOperator op, Pair<LogicalVariable, LogicalVariable> pair) throws AlgebricksException { List<Triple<LogicalVariable, LogicalVariable, LogicalVariable>> varMap = op.getVariableMappings(); for (Triple<LogicalVariable, LogicalVariable, LogicalVariable> t : varMap) { if (t.first.equals(pair.first)) { t.first = pair.second; } if (t.second.equals(pair.first)) { t.second = pair.second; } if (t.third.equals(pair.first)) { t.third = pair.second; } } substVarTypes(op, pair); return null; }
private void substAssignVariables(List<LogicalVariable> variables, List<Mutable<ILogicalExpression>> expressions, Pair<LogicalVariable, LogicalVariable> pair) { int n = variables.size(); for (int i = 0; i < n; i++) { if (variables.get(i).equals(pair.first)) { variables.set(i, pair.second); } else { expressions.get(i).getValue().substituteVar(pair.first, pair.second); } } }
@Override public Void visitProjectOperator(ProjectOperator op, Pair<LogicalVariable, LogicalVariable> pair) throws AlgebricksException { List<LogicalVariable> usedVariables = op.getVariables(); int n = usedVariables.size(); for (int i = 0; i < n; i++) { LogicalVariable v = usedVariables.get(i); if (v.equals(pair.first)) { usedVariables.set(i, pair.second); } } substVarTypes(op, pair); return null; }
private void subst(LogicalVariable v1, LogicalVariable v2, List<Pair<LogicalVariable, Mutable<ILogicalExpression>>> varExprPairList) { for (Pair<LogicalVariable, Mutable<ILogicalExpression>> ve : varExprPairList) { if (ve.first != null && ve.first.equals(v1)) { ve.first = v2; return; } ve.second.getValue().substituteVar(v1, v2); } }
/** * @param recordInAssign the variable reference expression in assign op * @param recordInScan the record (payload) variable in scan op * @return true if the expression in the assign op is a variable and that variable = record variable in scan op */ private boolean sameRecords(ILogicalExpression recordInAssign, LogicalVariable recordInScan) { return recordInAssign != null && recordInAssign.getExpressionTag() == LogicalExpressionTag.VARIABLE && ((VariableReferenceExpression) recordInAssign).getVariableReference().equals(recordInScan); }
@Override public boolean equals(Object obj) { if (!(obj instanceof OrderColumn)) { return false; } else { OrderColumn oc = (OrderColumn) obj; return column.equals(oc.getColumn()) && order == oc.getOrder(); } }
@Override public void recomputeSchema() { schema = new ArrayList<LogicalVariable>(); for (LogicalVariable v1 : inputs.get(0).getValue().getSchema()) { for (Triple<LogicalVariable, LogicalVariable, LogicalVariable> t : varMap) { if (t.first.equals(v1)) { schema.add(t.third); } else { schema.add(v1); } } } for (LogicalVariable v2 : inputs.get(1).getValue().getSchema()) { for (Triple<LogicalVariable, LogicalVariable, LogicalVariable> t : varMap) { if (t.second.equals(v2)) { schema.add(t.third); } else { schema.add(v2); } } } }
@Override public Void visitIntersectOperator(IntersectOperator op, Pair<LogicalVariable, LogicalVariable> pair) throws AlgebricksException { for (int i = 0; i < op.getOutputVars().size(); i++) { if (op.getOutputVars().get(i).equals(pair.first)) { op.getOutputVars().set(i, pair.second); } } for (int i = 0; i < op.getNumInput(); i++) { for (int j = 0; j < op.getInputVariables(i).size(); j++) { if (op.getInputVariables(i).get(j).equals(pair.first)) { op.getInputVariables(i).set(j, pair.second); } } } return null; }
private static boolean impliedByPrefix(List<OrderColumn> vars, int i, FunctionalDependency fdep) { if (!fdep.getTail().contains(vars.get(i).getColumn())) { return false; } boolean fdSat = true; for (LogicalVariable pv : fdep.getHead()) { boolean isInPrefix = false; for (int j = 0; j < i; j++) { if (vars.get(j).getColumn().equals(pv)) { isInPrefix = true; break; } } if (!isInPrefix) { fdSat = false; break; } } return fdSat; }
private static LogicalVariable getLhsGbyVar(GroupByOperator gby, LogicalVariable var) { for (Pair<LogicalVariable, Mutable<ILogicalExpression>> ve : gby.getGroupByList()) { ILogicalExpression e = ve.second.getValue(); if (e.getExpressionTag() != LogicalExpressionTag.VARIABLE) { throw new IllegalStateException( "Right hand side of group by assignment should have been normalized to a variable reference."); } LogicalVariable v = ((VariableReferenceExpression) e).getVariableReference(); if (v.equals(var)) { return ve.first; } } return null; }
@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())); } } } }
private void getParentFunctionExpression(LogicalVariable usedVar, ILogicalExpression expr, List<Pair<AbstractFunctionCallExpression, Integer>> parentAndIndexList) { AbstractFunctionCallExpression funcExpr = (AbstractFunctionCallExpression) expr; List<Mutable<ILogicalExpression>> args = funcExpr.getArguments(); for (int i = 0; i < args.size(); i++) { ILogicalExpression argExpr = args.get(i).getValue(); if (argExpr.getExpressionTag() == LogicalExpressionTag.VARIABLE) { VariableReferenceExpression varExpr = (VariableReferenceExpression) argExpr; if (varExpr.getVariableReference().equals(usedVar)) { parentAndIndexList.add(new Pair<AbstractFunctionCallExpression, Integer>(funcExpr, i)); } } if (argExpr.getExpressionTag() == LogicalExpressionTag.FUNCTION_CALL) { getParentFunctionExpression(usedVar, argExpr, parentAndIndexList); } } }
private LogicalVariable findListifiedVariable(AggregateOperator nspAgg, LogicalVariable varFromNestedAgg) { int n = nspAgg.getVariables().size(); for (int i = 0; i < n; i++) { if (nspAgg.getVariables().get(i).equals(varFromNestedAgg)) { AbstractFunctionCallExpression fce = (AbstractFunctionCallExpression) nspAgg.getExpressions().get(i).getValue(); if (fce.getFunctionIdentifier().equals(BuiltinFunctions.LISTIFY)) { ILogicalExpression argExpr = fce.getArguments().get(0).getValue(); if (argExpr.getExpressionTag() == LogicalExpressionTag.VARIABLE) { return ((VariableReferenceExpression) argExpr).getVariableReference(); } } } } return null; }
@Override public Void visitAssignOperator(AssignOperator op, Pair<LogicalVariable, LogicalVariable> pair) throws AlgebricksException { substAssignVariables(op.getVariables(), op.getExpressions(), pair); // Substitute variables stored in ordering property if (op.getExplicitOrderingProperty() != null) { List<OrderColumn> orderColumns = op.getExplicitOrderingProperty().getOrderColumns(); for (int i = 0; i < orderColumns.size(); i++) { OrderColumn oc = orderColumns.get(i); if (oc.getColumn().equals(pair.first)) { orderColumns.set(i, new OrderColumn(pair.second, oc.getOrder())); } } } substVarTypes(op, pair); return null; }