args) {
+ /** Creates a TuplePat.
+ *
+ * Type is {@link PrimitiveType#UNIT} if {@code args} is empty,
+ * otherwise a {@link TupleType}. */
+ TuplePat(RecordLikeType type, ImmutableList args) {
super(Op.TUPLE_PAT, type);
this.args = requireNonNull(args);
+ checkArgument(args.size() == type.argNameTypes().size());
+ checkArgument(args.isEmpty()
+ ? type == PrimitiveType.UNIT
+ : type instanceof TupleType);
+ }
+
+ @Override public RecordLikeType type() {
+ return (RecordLikeType) type;
}
@Override AstWriter unparse(AstWriter w, int left, int right) {
@@ -407,6 +417,17 @@ public TuplePat copy(TypeSystem typeSystem, List args) {
return args.equals(this.args) ? this
: core.tuplePat(typeSystem, args);
}
+
+ /** Returns the names of all components that are named. */
+ public List fieldNames() {
+ final ImmutableList.Builder names = ImmutableList.builder();
+ for (Pat arg : args) {
+ if (arg instanceof NamedPat) {
+ names.add(((NamedPat) arg).name);
+ }
+ }
+ return names.build();
+ }
}
/** List pattern.
@@ -1127,7 +1148,11 @@ public static class From extends Exp {
}
}
- public Exp copy(TypeSystem typeSystem, Environment env,
+ /** Copies this {@code From} with a new set of steps.
+ *
+ * Returns this {@code From} if the steps are the same.
+ * If {@code env} is not null, performs additional checking. */
+ public Exp copy(TypeSystem typeSystem, @Nullable Environment env,
List steps) {
return steps.equals(this.steps)
? this
@@ -1165,17 +1190,28 @@ public static class Scan extends FromStep {
Scan(Op op, ImmutableList bindings, Pat pat, Exp exp,
Exp condition) {
super(op, bindings);
- switch (op) {
- case INNER_JOIN:
- case SUCH_THAT:
- break;
- default:
+ if (op != Op.INNER_JOIN) {
// SCAN and CROSS_JOIN are valid in ast, not core.
- throw new AssertionError("not a join type " + op);
+ throw new IllegalArgumentException("not a join type " + op);
}
this.pat = requireNonNull(pat, "pat");
this.exp = requireNonNull(exp, "exp");
this.condition = requireNonNull(condition, "condition");
+ if (!(exp.type instanceof ListType)) {
+ throw new IllegalArgumentException("scan expression must be list: "
+ + exp.type);
+ }
+ final ListType listType = (ListType) exp.type;
+ if (!canAssign(listType.elementType, pat.type)) {
+ throw new IllegalArgumentException(exp.type + " + " + pat.type);
+ }
+ }
+
+ /** Returns whether you can assign a value of {@code fromType} to a variable
+ * of type {@code toType}. */
+ private static boolean canAssign(Type fromType, Type toType) {
+ return fromType.equals(toType)
+ || toType.isProgressive();
}
@Override public Scan accept(Shuttle shuttle) {
@@ -1188,16 +1224,17 @@ public static class Scan extends FromStep {
@Override protected AstWriter unparse(AstWriter w, From from, int ordinal,
int left, int right) {
- final String prefix = ordinal == 0 ? " "
- : op == Op.SUCH_THAT ? " join "
- : op.padded;
- final String infix = op == Op.SUCH_THAT ? " suchthat "
- : " in ";
- w.append(prefix)
- // for these purposes 'in' and 'suchthat' have same precedence as '='
- .append(pat, 0, Op.EQ.left)
- .append(infix)
- .append(exp, Op.EQ.right, 0);
+ w.append(ordinal == 0 ? " " : op.padded)
+ // for these purposes 'in' has same precedence as '='
+ .append(pat, 0, Op.EQ.left);
+ if (Extents.isInfinite(exp)) {
+ // Print "from x : int" rather "from x in extent 'int'"
+ w.append(" : ")
+ .append(((ListType) exp.type).elementType.moniker());
+ } else {
+ w.append(" in ")
+ .append(exp, Op.EQ.right, 0);
+ }
if (!isLiteralTrue()) {
w.append("on").append(condition, 0, 0);
}
diff --git a/src/main/java/net/hydromatic/morel/ast/CoreBuilder.java b/src/main/java/net/hydromatic/morel/ast/CoreBuilder.java
index 5e473b55f..fa335046e 100644
--- a/src/main/java/net/hydromatic/morel/ast/CoreBuilder.java
+++ b/src/main/java/net/hydromatic/morel/ast/CoreBuilder.java
@@ -20,6 +20,7 @@
import net.hydromatic.morel.compile.BuiltIn;
import net.hydromatic.morel.compile.Environment;
+import net.hydromatic.morel.compile.Extents;
import net.hydromatic.morel.compile.NameGenerator;
import net.hydromatic.morel.eval.Unit;
import net.hydromatic.morel.type.Binding;
@@ -39,6 +40,7 @@
import net.hydromatic.morel.util.PairList;
import com.google.common.collect.ImmutableList;
+import com.google.common.collect.ImmutableMap;
import com.google.common.collect.ImmutableRangeSet;
import com.google.common.collect.ImmutableSortedMap;
import com.google.common.collect.Iterables;
@@ -56,9 +58,11 @@
import java.util.SortedMap;
import java.util.TreeMap;
import java.util.function.BiFunction;
+import java.util.function.Consumer;
import static net.hydromatic.morel.type.RecordType.ORDERING;
import static net.hydromatic.morel.util.Pair.forEach;
+import static net.hydromatic.morel.util.Pair.forEachIndexed;
import static net.hydromatic.morel.util.Static.transform;
import static com.google.common.collect.Iterables.getOnlyElement;
@@ -253,11 +257,12 @@ public Core.Con0Pat con0Pat(DataType type, String tyCon) {
return new Core.Con0Pat(type, tyCon);
}
- public Core.TuplePat tuplePat(Type type, Iterable args) {
+ public Core.TuplePat tuplePat(RecordLikeType type,
+ Iterable args) {
return new Core.TuplePat(type, ImmutableList.copyOf(args));
}
- public Core.TuplePat tuplePat(Type type, Core.Pat... args) {
+ public Core.TuplePat tuplePat(RecordLikeType type, Core.Pat... args) {
return new Core.TuplePat(type, ImmutableList.copyOf(args));
}
@@ -540,12 +545,32 @@ public Core.Yield yield_(TypeSystem typeSystem, Core.Exp exp) {
switch (exp.type.op()) {
case RECORD_TYPE:
case TUPLE_TYPE:
- ((RecordLikeType) exp.type).argNameTypes().forEach((name, type) ->
- bindings.add(
- Binding.of(idPat(type, name, typeSystem.nameGenerator))));
+ forEachIndexed(((RecordLikeType) exp.type).argNameTypes(),
+ (i, name, type) -> {
+ final Core.NamedPat idPat;
+ if (exp.op == Op.TUPLE
+ && exp.arg(i) instanceof Core.Id
+ && ((Core.Id) exp.arg(i)).idPat.name.equals(name)) {
+ // Use an existing IdPat if we can, rather than generating a new
+ // IdPat with a different sequence number. (The underlying problem
+ // is that the fields of record types have only names, no sequence
+ // numbers.)
+ idPat = ((Core.Id) exp.arg(i)).idPat;
+ } else {
+ idPat = idPat(type, name, typeSystem.nameGenerator);
+ }
+ bindings.add(Binding.of(idPat));
+ });
break;
+
default:
- bindings.add(Binding.of(idPat(exp.type, typeSystem.nameGenerator)));
+ switch (exp.op) {
+ case ID:
+ bindings.add(Binding.of(((Core.Id) exp).idPat));
+ break;
+ default:
+ bindings.add(Binding.of(idPat(exp.type, typeSystem.nameGenerator)));
+ }
}
return yield_(bindings, exp);
}
@@ -578,20 +603,32 @@ public Core.Exp list(TypeSystem typeSystem, Core.Exp arg0, Core.Exp... args) {
* fall into a given range-set. The range-set might consist of just
* {@link Range#all()}, in which case, the list returns all values of the
* type. */
- @SuppressWarnings({"UnstableApiUsage", "rawtypes"})
+ @SuppressWarnings({"rawtypes", "unchecked"})
public Core.Exp extent(TypeSystem typeSystem, Type type,
- RangeSet rangeSet) {
+ RangeSet rangeSet) {
+ final Map map;
+ if (rangeSet.complement().isEmpty()) {
+ map = ImmutableMap.of();
+ } else {
+ map = ImmutableMap.of("/", ImmutableRangeSet.copyOf(rangeSet));
+ }
+ return extent(typeSystem, type, map);
+ }
+
+ @SuppressWarnings("rawtypes")
+ public Core.Exp extent(TypeSystem typeSystem, Type type,
+ Map rangeSetMap) {
final ListType listType = typeSystem.listType(type);
// Store an ImmutableRangeSet value inside a literal of type 'unit'.
// The value of such literals is usually Unit.INSTANCE, but we cheat.
return core.apply(Pos.ZERO, listType,
core.functionLiteral(typeSystem, BuiltIn.Z_EXTENT),
- core.internalLiteral(new RangeExtent(rangeSet, type)));
+ core.internalLiteral(new RangeExtent(typeSystem, type, rangeSetMap)));
}
- @SuppressWarnings({"UnstableApiUsage", "rawtypes", "unchecked"})
- public Pair> mergeExtents(TypeSystem typeSystem,
- List exps, boolean intersect) {
+ @SuppressWarnings({"rawtypes", "unchecked"})
+ public Pair> intersectExtents(TypeSystem typeSystem,
+ List exps) {
switch (exps.size()) {
case 0:
throw new AssertionError();
@@ -600,28 +637,61 @@ public Pair> mergeExtents(TypeSystem typeSystem,
return Pair.of(simplify(typeSystem, exps.get(0)), ImmutableList.of());
default:
- ImmutableRangeSet rangeSet = intersect
- ? ImmutableRangeSet.of(Range.all())
- : ImmutableRangeSet.of();
+ final List> rangeSetMaps =
+ new ArrayList<>();
final List remainingExps = new ArrayList<>();
for (Core.Exp exp : exps) {
if (exp.isCallTo(BuiltIn.Z_EXTENT)) {
final Core.Literal argLiteral = (Core.Literal) ((Core.Apply) exp).arg;
final RangeExtent list = argLiteral.unwrap(RangeExtent.class);
- rangeSet = intersect
- ? rangeSet.intersection(list.rangeSet)
- : rangeSet.union(list.rangeSet);
+ rangeSetMaps.add(list.rangeSetMap);
continue;
}
remainingExps.add(exp);
}
final ListType listType = (ListType) exps.get(0).type;
+ Map rangeSetMap =
+ Extents.intersect((List) rangeSetMaps);
Core.Exp exp =
- core.extent(typeSystem, listType.elementType, rangeSet);
+ core.extent(typeSystem, listType.elementType, rangeSetMap);
for (Core.Exp remainingExp : remainingExps) {
- exp = intersect
- ? core.intersect(typeSystem, exp, remainingExp)
- : core.union(typeSystem, exp, remainingExp);
+ exp = core.intersect(typeSystem, exp, remainingExp);
+ }
+ return Pair.of(exp, remainingExps);
+ }
+ }
+
+ @SuppressWarnings({"rawtypes", "unchecked"})
+ public Pair> unionExtents(TypeSystem typeSystem,
+ List exps) {
+ switch (exps.size()) {
+ case 0:
+ throw new AssertionError();
+
+ case 1:
+ return Pair.of(simplify(typeSystem, exps.get(0)), ImmutableList.of());
+
+ default:
+ final List> rangeSetMaps =
+ new ArrayList<>();
+ final List remainingExps = new ArrayList<>();
+ for (Core.Exp exp : exps) {
+ if (exp.isCallTo(BuiltIn.Z_EXTENT)) {
+ final Core.Literal argLiteral = (Core.Literal) ((Core.Apply) exp).arg;
+ final Core.Wrapper wrapper = (Core.Wrapper) argLiteral.value;
+ final RangeExtent list = wrapper.unwrap(RangeExtent.class);
+ rangeSetMaps.add(list.rangeSetMap);
+ continue;
+ }
+ remainingExps.add(exp);
+ }
+ final ListType listType = (ListType) exps.get(0).type;
+ Map rangeSetMap =
+ Extents.union((List) rangeSetMaps);
+ Core.Exp exp =
+ core.extent(typeSystem, listType.elementType, rangeSetMap);
+ for (Core.Exp remainingExp : remainingExps) {
+ exp = core.union(typeSystem, exp, remainingExp);
}
return Pair.of(exp, remainingExps);
}
@@ -638,7 +708,7 @@ public Pair> mergeExtents(TypeSystem typeSystem,
* extent "[[1, 5], [10, 20]]"
* }
*/
- Core.Exp simplify(TypeSystem typeSystem, Core.Exp exp) {
+ public Core.Exp simplify(TypeSystem typeSystem, Core.Exp exp) {
switch (exp.op) {
case TUPLE:
final Core.Tuple tuple = (Core.Tuple) exp;
@@ -655,7 +725,7 @@ Core.Exp simplify(TypeSystem typeSystem, Core.Exp exp) {
if (apply.args().stream()
.allMatch(exp1 -> exp1.isCallTo(BuiltIn.Z_EXTENT))) {
Pair> pair =
- mergeExtents(typeSystem, apply.args(), false);
+ unionExtents(typeSystem, apply.args());
if (pair.right.isEmpty()) {
return pair.left;
}
@@ -665,7 +735,7 @@ Core.Exp simplify(TypeSystem typeSystem, Core.Exp exp) {
if (apply.args().stream()
.allMatch(exp1 -> exp1.isCallTo(BuiltIn.Z_EXTENT))) {
Pair> pair =
- mergeExtents(typeSystem, apply.args(), true);
+ intersectExtents(typeSystem, apply.args());
if (pair.right.isEmpty()) {
return pair.left;
}
@@ -707,7 +777,7 @@ private Core.Apply call(TypeSystem typeSystem, BuiltIn builtIn,
}
/** Calls a built-in function with one type parameter. */
- private Core.Apply call(TypeSystem typeSystem, BuiltIn builtIn, Type type,
+ public Core.Apply call(TypeSystem typeSystem, BuiltIn builtIn, Type type,
Pos pos, Core.Exp... args) {
final Core.Literal literal = functionLiteral(typeSystem, builtIn);
final ForallType forallType = (ForallType) literal.type;
@@ -756,18 +826,28 @@ public Core.Exp andAlso(TypeSystem typeSystem, Core.Exp a0, Core.Exp a1) {
return call(typeSystem, BuiltIn.Z_ANDALSO, a0, a1);
}
+ /** Converts a list of 0 or more expressions into an {@code andalso};
+ * simplifies empty list to "true" and singleton list "[e]" to "e". */
public Core.Exp andAlso(TypeSystem typeSystem, Iterable exps) {
- return foldRight(ImmutableList.copyOf(exps),
- (e1, e2) -> andAlso(typeSystem, e1, e2));
+ final List expList = ImmutableList.copyOf(exps);
+ if (expList.isEmpty()) {
+ return trueLiteral;
+ }
+ return foldRight(expList, (e1, e2) -> andAlso(typeSystem, e1, e2));
}
public Core.Exp orElse(TypeSystem typeSystem, Core.Exp a0, Core.Exp a1) {
return call(typeSystem, BuiltIn.Z_ORELSE, a0, a1);
}
+ /** Converts a list of 0 or more expressions into an {@code orelse};
+ * simplifies empty list to "false" and singleton list "[e]" to "e". */
public Core.Exp orElse(TypeSystem typeSystem, Iterable exps) {
- return foldRight(ImmutableList.copyOf(exps),
- (e1, e2) -> orElse(typeSystem, e1, e2));
+ final ImmutableList expList = ImmutableList.copyOf(exps);
+ if (expList.isEmpty()) {
+ return falseLiteral;
+ }
+ return foldRight(expList, (e1, e2) -> orElse(typeSystem, e1, e2));
}
private E foldRight(List list, BiFunction fold) {
@@ -802,6 +882,100 @@ public Core.Exp intersect(TypeSystem typeSystem, Iterable exps) {
return foldRight(ImmutableList.copyOf(exps),
(e1, e2) -> intersect(typeSystem, e1, e2));
}
+
+ /** Returns an expression substituting every given expression as true.
+ *
+ * For example, if {@code exp} is "{@code x = 1 andalso y > 2}"
+ * and {@code trueExps} is [{@code x = 1}, {@code z = 2}],
+ * returns "{@code y > 2}".
+ */
+ public Core.Exp subTrue(TypeSystem typeSystem, Core.Exp exp,
+ List trueExps) {
+ List conjunctions = decomposeAnd(exp);
+ List conjunctions2 = new ArrayList<>();
+ for (Core.Exp conjunction : conjunctions) {
+ if (!trueExps.contains(conjunction)) {
+ conjunctions2.add(conjunction);
+ }
+ }
+ if (conjunctions.size() == conjunctions2.size()) {
+ // Don't create a new expression unless we have to.
+ return exp;
+ }
+ return andAlso(typeSystem, conjunctions2);
+ }
+
+ /** Decomposes an {@code andalso} expression;
+ * inverse of {@link #andAlso(TypeSystem, Iterable)}.
+ *
+ * Examples:
+ *
+ * - "p1 andalso p2" becomes "[p1, p2]" (two elements);
+ *
- "p1 andalso p2 andalso p3" becomes "[p1, p2, p3]" (three elements);
+ *
- "p1 orelse p2" becomes "[p1 orelse p2]" (one element);
+ *
- "true" becomes "[]" (no elements);
+ *
- "false" becomes "[false]" (one element).
+ *
*/
+ public List decomposeAnd(Core.Exp exp) {
+ final ImmutableList.Builder list = ImmutableList.builder();
+ flattenAnd(exp, list::add);
+ return list.build();
+ }
+
+ /** Decomposes an {@code orelse} expression;
+ * inverse of {@link #orElse(TypeSystem, Iterable)}.
+ *
+ * Examples:
+ *
+ * - "p1 orelse p2" becomes "[p1, p2]" (two elements);
+ *
- "p1 orelse p2 orelse p3" becomes "[p1, p2, p3]" (three elements);
+ *
- "p1 andalso p2" becomes "[p1 andalso p2]" (one element);
+ *
- "false" becomes "[]" (no elements);
+ *
- "true" becomes "[true]" (one element).
+ *
*/
+ public List decomposeOr(Core.Exp exp) {
+ final ImmutableList.Builder list = ImmutableList.builder();
+ flattenOr(exp, list::add);
+ return list.build();
+ }
+
+ /** Flattens the {@code andalso}s in an expression into a consumer. */
+ public void flattenAnd(Core.Exp exp, Consumer consumer) {
+ //noinspection StatementWithEmptyBody
+ if (exp.op == Op.BOOL_LITERAL && (boolean) ((Core.Literal) exp).value) {
+ // don't add 'true' to the list
+ } else if (exp.op == Op.APPLY
+ && ((Core.Apply) exp).fn.op == Op.FN_LITERAL
+ && ((Core.Literal) ((Core.Apply) exp).fn).value == BuiltIn.Z_ANDALSO) {
+ flattenAnds(((Core.Apply) exp).args(), consumer);
+ } else {
+ consumer.accept(exp);
+ }
+ }
+
+ /** Flattens the {@code andalso}s in every expression into a consumer. */
+ public void flattenAnds(List exps, Consumer consumer) {
+ exps.forEach(arg -> flattenAnd(arg, consumer));
+ }
+
+ /** Flattens the {@code orelse}s in an expression into a consumer. */
+ public void flattenOr(Core.Exp exp, Consumer consumer) {
+ //noinspection StatementWithEmptyBody
+ if (exp.op == Op.BOOL_LITERAL && !(boolean) ((Core.Literal) exp).value) {
+ // don't add 'false' to the list
+ } else if (exp.op == Op.APPLY
+ && ((Core.Apply) exp).fn.op == Op.FN_LITERAL
+ && ((Core.Literal) ((Core.Apply) exp).fn).value == BuiltIn.Z_ORELSE) {
+ flattenOrs(((Core.Apply) exp).args(), consumer);
+ } else {
+ consumer.accept(exp);
+ }
+ }
+
+ /** Flattens the {@code orelse}s in every expression into a consumer. */
+ public void flattenOrs(List exps, Consumer consumer) {
+ exps.forEach(arg -> flattenOr(arg, consumer));
+ }
}
// End CoreBuilder.java
diff --git a/src/main/java/net/hydromatic/morel/ast/FromBuilder.java b/src/main/java/net/hydromatic/morel/ast/FromBuilder.java
index 60440d685..4ac6c382f 100644
--- a/src/main/java/net/hydromatic/morel/ast/FromBuilder.java
+++ b/src/main/java/net/hydromatic/morel/ast/FromBuilder.java
@@ -23,10 +23,13 @@
import net.hydromatic.morel.compile.RefChecker;
import net.hydromatic.morel.type.Binding;
import net.hydromatic.morel.type.TypeSystem;
+import net.hydromatic.morel.util.Pair;
import net.hydromatic.morel.util.PairList;
import com.google.common.collect.ImmutableList;
+import com.google.common.collect.ImmutableRangeSet;
import com.google.common.collect.Iterables;
+import com.google.common.collect.Range;
import org.apache.calcite.util.Util;
import org.checkerframework.checker.nullness.qual.Nullable;
@@ -37,6 +40,7 @@
import static net.hydromatic.morel.ast.CoreBuilder.core;
import static net.hydromatic.morel.util.Pair.forEach;
+import static net.hydromatic.morel.util.Static.append;
import static com.google.common.collect.Iterables.getLast;
@@ -122,56 +126,79 @@ && isTrivial(tuple, previousBindings, yield.bindings)) {
return this;
}
- public FromBuilder suchThat(Core.Pat pat, Core.Exp exp) {
- Compiles.acceptBinding(typeSystem, pat, bindings);
- return addStep(
- core.scan(Op.SUCH_THAT, bindings, pat, exp, core.boolLiteral(true)));
+ /** Creates an unbounded scan, "from pat". */
+ public FromBuilder scan(Core.Pat pat) {
+ final Core.Exp extent =
+ core.extent(typeSystem, pat.type, ImmutableRangeSet.of(Range.all()));
+ return scan(pat, extent, core.boolLiteral(true));
}
+ /** Creates a bounded scan, "from pat in exp". */
public FromBuilder scan(Core.Pat pat, Core.Exp exp) {
return scan(pat, exp, core.boolLiteral(true));
}
public FromBuilder scan(Core.Pat pat, Core.Exp exp, Core.Exp condition) {
if (exp.op == Op.FROM
- && steps.isEmpty()
&& core.boolLiteral(true).equals(condition)
&& (pat instanceof Core.IdPat
&& !((Core.From) exp).steps.isEmpty()
&& getLast(((Core.From) exp).steps).bindings.size() == 1
|| pat instanceof Core.RecordPat
&& ((Core.RecordPat) pat).args.stream()
+ .allMatch(a -> a instanceof Core.IdPat)
+ || pat instanceof Core.TuplePat
+ && ((Core.TuplePat) pat).args.stream()
.allMatch(a -> a instanceof Core.IdPat))) {
final Core.From from = (Core.From) exp;
+ final Core.FromStep lastStep = getLast(from.steps);
+ final List steps =
+ lastStep.op == Op.YIELD ? Util.skipLast(from.steps) : from.steps;
+
final PairList nameExps = PairList.of();
+ boolean uselessIfLast = this.bindings.isEmpty();
final List bindings;
if (pat instanceof Core.RecordPat) {
final Core.RecordPat recordPat = (Core.RecordPat) pat;
+ this.bindings.forEach(b -> nameExps.add(b.id.name, core.id(b.id)));
forEach(recordPat.type().argNameTypes.keySet(), recordPat.args,
(name, arg) -> nameExps.add(name, core.id((Core.IdPat) arg)));
bindings = null;
+ } else if (pat instanceof Core.TuplePat) {
+ final Core.TuplePat tuplePat = (Core.TuplePat) pat;
+ Pair.forEach(tuplePat.args, lastStep.bindings,
+ (arg, binding) ->
+ nameExps.add(((Core.IdPat) arg).name, core.id(binding.id)));
+ bindings = null;
+ } else if (!this.bindings.isEmpty()) {
+ // With at least one binding, and one new variable, the output will be
+ // a record type.
+ final Core.IdPat idPat = (Core.IdPat) pat;
+ this.bindings.forEach(b -> nameExps.add(b.id.name, core.id(b.id)));
+ lastStep.bindings.forEach(b -> nameExps.add(idPat.name, core.id(b.id)));
+ bindings = null;
} else {
final Core.IdPat idPat = (Core.IdPat) pat;
- final Core.FromStep lastStep = getLast(from.steps);
if (lastStep instanceof Core.Yield
&& ((Core.Yield) lastStep).exp.op != Op.RECORD) {
// The last step is a yield scalar, say 'yield x + 1'.
// Translate it to a yield singleton record, say 'yield {y = x + 1}'
- addAll(Util.skipLast(from.steps));
- if (((Core.Yield) lastStep).exp.op == Op.ID) {
+ addAll(steps);
+ if (((Core.Yield) lastStep).exp.op == Op.ID
+ && this.bindings.size() == 1) {
// The last step is 'yield e'. Skip it.
return this;
}
nameExps.add(idPat.name, ((Core.Yield) lastStep).exp);
bindings = ImmutableList.of(Binding.of(idPat));
- return yield_(true, bindings, core.record(typeSystem, nameExps));
+ return yield_(false, bindings, core.record(typeSystem, nameExps));
}
final Binding binding = Iterables.getOnlyElement(lastStep.bindings);
nameExps.add(idPat.name, core.id(binding.id));
- bindings = ImmutableList.of(Binding.of(idPat));
+ bindings = append(this.bindings, Binding.of(idPat));
}
- addAll(from.steps);
- return yield_(true, bindings, core.record(typeSystem, nameExps));
+ addAll(steps);
+ return yield_(uselessIfLast, bindings, core.record(typeSystem, nameExps));
}
Compiles.acceptBinding(typeSystem, pat, bindings);
return addStep(core.scan(Op.INNER_JOIN, bindings, pat, exp, condition));
@@ -224,7 +251,7 @@ public FromBuilder yield_(Core.Exp exp) {
}
public FromBuilder yield_(boolean uselessIfLast, Core.Exp exp) {
- return yield_(false, null, exp);
+ return yield_(uselessIfLast, null, exp);
}
/** Creates a "yield" step.
@@ -328,25 +355,14 @@ private static TupleType tupleType(Core.Tuple tuple, List bindings,
return identity ? TupleType.IDENTITY : TupleType.RENAME;
}
- /** Returns whether tuple is something like "{i = j, j = x}". */
- private boolean isRename(Core.Tuple tuple) {
- for (int i = 0; i < tuple.args.size(); i++) {
- Core.Exp exp = tuple.args.get(i);
- if (exp.op != Op.ID) {
- return false;
- }
- }
- return true;
- }
-
private Core.Exp build(boolean simplify) {
if (removeIfLastIndex == steps.size() - 1) {
removeIfLastIndex = Integer.MIN_VALUE;
final Core.Yield yield = (Core.Yield) getLast(steps);
- assert yield.exp.op == Op.TUPLE
- && ((Core.Tuple) yield.exp).args.size() == 1
- && isTrivial((Core.Tuple) yield.exp, bindings, yield.bindings)
- : yield.exp;
+ if (yield.exp.op != Op.TUPLE
+ || ((Core.Tuple) yield.exp).args.size() != 1) {
+ throw new AssertionError(yield.exp);
+ }
steps.remove(steps.size() - 1);
}
if (simplify
@@ -380,11 +396,7 @@ private class StepHandler extends Visitor {
}
@Override protected void visit(Core.Scan scan) {
- if (scan.op == Op.SUCH_THAT) {
- suchThat(scan.pat, scan.exp);
- } else {
- scan(scan.pat, scan.exp, scan.condition);
- }
+ scan(scan.pat, scan.exp, scan.condition);
}
@Override protected void visit(Core.Where where) {
diff --git a/src/main/java/net/hydromatic/morel/ast/Op.java b/src/main/java/net/hydromatic/morel/ast/Op.java
index 03bddabb7..0dfef84b9 100644
--- a/src/main/java/net/hydromatic/morel/ast/Op.java
+++ b/src/main/java/net/hydromatic/morel/ast/Op.java
@@ -71,7 +71,6 @@ public enum Op {
// internal
FROM_EQ("$FROM_EQ "),
- SUCH_THAT("$SUCH_THAT "),
// value constructors
TUPLE(true),
diff --git a/src/main/java/net/hydromatic/morel/ast/Shuttle.java b/src/main/java/net/hydromatic/morel/ast/Shuttle.java
index 4182d1280..09333a64e 100644
--- a/src/main/java/net/hydromatic/morel/ast/Shuttle.java
+++ b/src/main/java/net/hydromatic/morel/ast/Shuttle.java
@@ -395,8 +395,7 @@ protected Core.Exp visit(Core.From from) {
protected Core.Scan visit(Core.Scan scan) {
return scan.copy(scan.bindings, scan.pat.accept(this),
- scan.exp.accept(this),
- scan.condition == null ? null : scan.condition.accept(this));
+ scan.exp.accept(this), scan.condition.accept(this));
}
protected Core.Where visit(Core.Where where) {
diff --git a/src/main/java/net/hydromatic/morel/ast/Visitor.java b/src/main/java/net/hydromatic/morel/ast/Visitor.java
index f12e91361..debc4fba5 100644
--- a/src/main/java/net/hydromatic/morel/ast/Visitor.java
+++ b/src/main/java/net/hydromatic/morel/ast/Visitor.java
@@ -188,7 +188,9 @@ protected void visit(Ast.From from) {
protected void visit(Ast.Scan scan) {
scan.pat.accept(this);
- scan.exp.accept(this);
+ if (scan.exp != null) {
+ scan.exp.accept(this);
+ }
if (scan.condition != null) {
scan.condition.accept(this);
}
diff --git a/src/main/java/net/hydromatic/morel/compile/Compiler.java b/src/main/java/net/hydromatic/morel/compile/Compiler.java
index 81ac7f50d..9a69786c5 100644
--- a/src/main/java/net/hydromatic/morel/compile/Compiler.java
+++ b/src/main/java/net/hydromatic/morel/compile/Compiler.java
@@ -35,7 +35,6 @@
import net.hydromatic.morel.foreign.CalciteFunctions;
import net.hydromatic.morel.type.Binding;
import net.hydromatic.morel.type.DataType;
-import net.hydromatic.morel.type.FnType;
import net.hydromatic.morel.type.Keys;
import net.hydromatic.morel.type.PrimitiveType;
import net.hydromatic.morel.type.RecordLikeType;
@@ -71,7 +70,6 @@
import static net.hydromatic.morel.util.Static.skip;
import static net.hydromatic.morel.util.Static.str;
import static net.hydromatic.morel.util.Static.toImmutableList;
-import static net.hydromatic.morel.util.Static.transform;
import static net.hydromatic.morel.util.Static.transformEager;
import static com.google.common.collect.Iterables.getLast;
@@ -274,11 +272,6 @@ private Code compileFieldName(Context cx, Core.NamedPat idPat) {
return Codes.get(idPat.name);
}
- private Code compileFieldNames(Context cx, List fieldNames) {
- return Codes.tuple(
- transform(fieldNames, fieldName -> compileFieldName(cx, fieldName)));
- }
-
protected Code compileApply(Context cx, Core.Apply apply) {
// Is this is a call to a built-in operator?
switch (apply.fn.op) {
@@ -343,45 +336,6 @@ && getOnlyElement(bindings).id.type.equals(elementType)) {
return () -> Codes.scanRowSink(firstStep.op, scan.pat, code,
conditionCode, nextFactory.get());
- case SUCH_THAT:
- // Given
- // (n, d) suchthat hasNameInDept (n, d)
- // that is,
- // pat = (n, d),
- // exp = hasNameInDept (n, d),
- // generate
- // (n, d) in List.filter
- // (fn x => case x of (n, d) => hasNameInDept (n, d))
- // (extent: (string * int) list)
- //
- // but we'd prefer to find the extent internally, e.g. given
- // (n, d) suchthat (n, d) elem nameDeptPairs
- // we generate
- // (n, d) in nameDeptPairs
- //
- final Core.Scan scan2 = (Core.Scan) firstStep;
- final Extents.Analysis extentFilter =
- Extents.create(typeSystem, scan2.pat, ImmutableSortedMap.of(),
- scan2.exp);
- final FnType fnType =
- typeSystem.fnType(scan2.pat.type, PrimitiveType.BOOL);
- final Pos pos = Pos.ZERO;
- final Core.Match match = core.match(pos, scan2.pat, scan2.exp);
- final Core.Exp lambda =
- core.fn(pos, fnType, ImmutableList.of(match),
- typeSystem.nameGenerator);
- final Core.Exp filterCall =
- core.apply(pos, extentFilter.extentExp.type,
- core.functionLiteral(typeSystem, BuiltIn.LIST_FILTER),
- lambda);
- final Core.Exp exp2 =
- core.apply(pos, extentFilter.extentExp.type, filterCall,
- extentFilter.extentExp);
- final Code code2 = compile(cx, exp2);
- final Code conditionCode2 = compile(cx, scan2.condition);
- return () -> Codes.scanRowSink(Op.INNER_JOIN, scan2.pat, code2,
- conditionCode2, nextFactory.get());
-
case WHERE:
final Core.Where where = (Core.Where) firstStep;
final Code filterCode = compile(cx, where.exp);
@@ -738,7 +692,8 @@ private void compileValDecl(Context cx, Core.ValDecl valDecl,
typedVal =
new Pretty.TypedVal(pat2.name,
typedValue.valueAs(Object.class),
- Keys.toProgressive(pat2.typeKey()).toType(typeSystem));
+ Keys.toProgressive(pat2.type().key())
+ .toType(typeSystem));
} else {
typedVal = new Pretty.TypedVal(pat2.name, o2, pat2.type);
}
@@ -763,41 +718,6 @@ private void compileValDecl(Context cx, Core.ValDecl valDecl,
newBindings.clear();
}
- private void shredValue(Core.Pat pat, Object o,
- BiConsumer consumer) {
- switch (pat.op) {
- case ID_PAT:
- consumer.accept((Core.IdPat) pat, o);
- return;
- case AS_PAT:
- final Core.AsPat asPat = (Core.AsPat) pat;
- consumer.accept(asPat, o);
- shredValue(asPat.pat, o, consumer);
- return;
- case TUPLE_PAT:
- final Core.TuplePat tuplePat = (Core.TuplePat) pat;
- forEach(tuplePat.args, (List) o, (pat2, o2) ->
- shredValue(pat2, o2, consumer));
- return;
- case RECORD_PAT:
- final Core.RecordPat recordPat = (Core.RecordPat) pat;
- forEach(recordPat.args, (List) o, (pat2, o2) ->
- shredValue(pat2, o2, consumer));
- return;
- case CON_PAT:
- final Core.ConPat conPat = (Core.ConPat) pat;
- shredValue(conPat.pat, ((List) o).get(1), consumer);
- return;
- case CONS_PAT:
- final Core.ConPat consPat = (Core.ConPat) pat;
- final List list = (List) o;
- final Object head = list.get(0);
- final List tail = list.subList(1, list.size());
- shredValue(consPat.pat, ImmutableList.of(head, tail), consumer);
- return;
- }
- }
-
private void link(Map linkCodes, Core.Pat pat,
Code code) {
if (pat instanceof Core.IdPat) {
diff --git a/src/main/java/net/hydromatic/morel/compile/Compiles.java b/src/main/java/net/hydromatic/morel/compile/Compiles.java
index 95b3bde38..450e74262 100644
--- a/src/main/java/net/hydromatic/morel/compile/Compiles.java
+++ b/src/main/java/net/hydromatic/morel/compile/Compiles.java
@@ -110,9 +110,9 @@ private static CompiledStatement prepareDecl(TypeSystem typeSystem,
checkPatternCoverage(typeSystem, coreDecl0, warningConsumer);
}
- // Ensures that once we discover that there is no suchThat, we stop looking;
- // makes things a bit more efficient.
- boolean mayContainSuchThat = true;
+ // Ensures that once we discover that there are no unbounded variables,
+ // we stop looking; makes things a bit more efficient.
+ boolean mayContainUnbounded = true;
Core.Decl coreDecl;
tracer.onCore(1, coreDecl0);
@@ -143,13 +143,14 @@ private static CompiledStatement prepareDecl(TypeSystem typeSystem,
}
for (int i = 0; i < inlinePassCount; i++) {
final Core.Decl coreDecl2 = coreDecl;
- if (mayContainSuchThat) {
- if (SuchThatShuttle.containsSuchThat(coreDecl)) {
+ if (mayContainUnbounded) {
+ if (SuchThatShuttle.containsUnbounded(coreDecl)) {
coreDecl = coreDecl.accept(new SuchThatShuttle(typeSystem, env));
} else {
- mayContainSuchThat = false;
+ mayContainUnbounded = false;
}
}
+ coreDecl = Extents.infinitePats(typeSystem, coreDecl);
if (coreDecl == coreDecl2) {
break;
}
diff --git a/src/main/java/net/hydromatic/morel/compile/Extents.java b/src/main/java/net/hydromatic/morel/compile/Extents.java
index 88735194e..4e598391e 100644
--- a/src/main/java/net/hydromatic/morel/compile/Extents.java
+++ b/src/main/java/net/hydromatic/morel/compile/Extents.java
@@ -19,30 +19,45 @@
package net.hydromatic.morel.compile;
import net.hydromatic.morel.ast.Core;
+import net.hydromatic.morel.ast.FromBuilder;
import net.hydromatic.morel.ast.Op;
+import net.hydromatic.morel.ast.Pos;
+import net.hydromatic.morel.ast.Shuttle;
+import net.hydromatic.morel.type.RangeExtent;
+import net.hydromatic.morel.type.Type;
import net.hydromatic.morel.type.TypeSystem;
+import net.hydromatic.morel.util.ImmutablePairList;
+import net.hydromatic.morel.util.Ord;
import net.hydromatic.morel.util.Pair;
+import net.hydromatic.morel.util.PairList;
+import com.google.common.collect.HashMultimap;
import com.google.common.collect.ImmutableList;
+import com.google.common.collect.ImmutableMap;
import com.google.common.collect.ImmutableRangeSet;
import com.google.common.collect.ImmutableSet;
import com.google.common.collect.ImmutableSortedMap;
-import com.google.common.collect.LinkedListMultimap;
-import com.google.common.collect.ListMultimap;
import com.google.common.collect.Multimap;
import com.google.common.collect.Range;
+import com.google.common.collect.RangeSet;
+import org.checkerframework.checker.nullness.qual.NonNull;
import java.util.ArrayList;
+import java.util.Collection;
+import java.util.HashMap;
+import java.util.LinkedHashMap;
import java.util.List;
+import java.util.Map;
import java.util.Set;
import java.util.SortedMap;
import static net.hydromatic.morel.ast.CoreBuilder.core;
-import static net.hydromatic.morel.util.Pair.allMatch;
import static net.hydromatic.morel.util.Static.skip;
import static org.apache.calcite.util.Util.minus;
+import static java.util.Objects.requireNonNull;
+
/** Generates an expression for the set of values that a variable can take in
* a program.
*
@@ -60,8 +75,10 @@
* fun isOdd i = i % 2 = 0
* in
* from e in emps,
- * i suchthat isOdd i andalso i < 100
- * where i = e.deptno
+ * i
+ * where isOdd i
+ * andalso i < 100
+ * andalso i = e.deptno
* end
* }
*
@@ -70,13 +87,15 @@
* {@code
* from e in emps
* yield e.deptno
- * where deptno % 2 = 0 andalso deptno < 100
+ * where deptno % 2 = 0
+ * andalso deptno < 100
* }
*/
public class Extents {
private Extents() {}
- /** Returns an expression that generates the extent of a pattern.
+ /** Analyzes the extent of a pattern in an expression and creates an
+ * {@link Analysis}.
*
* For example, given the program
*
@@ -84,7 +103,7 @@ private Extents() {}
* let
* fun f i = i elem [1, 2, 4]
* in
- * from x suchthat f x
+ * from x where f x
* end
* }
*
@@ -95,9 +114,10 @@ private Extents() {}
*
{@code
* let
* val edges = [(1, 2), (2, 3), (1, 4), (4, 2), (4, 3)]
- * fun edge (i, j) = (i, j) elem edges
+ * fun edge (i, j) = (i, j) elem edges
* in
- * from (x, y, z) suchthat edge (x, y) andalso edge (y, z) andalso x <> z
+ * from x, y, z
+ * where edge (x, y) andalso edge (y, z) andalso x <> z
* end
* }
*
@@ -120,24 +140,45 @@ private Extents() {}
* z in (from e in edges group e.j)
* }
*/
- public static Core.Exp generator(TypeSystem typeSystem, Core.Pat pat,
- Core.Exp exp) {
- return create(typeSystem, pat, ImmutableSortedMap.of(), exp).extentExp;
- }
-
public static Analysis create(TypeSystem typeSystem, Core.Pat pat,
- SortedMap boundPats, Core.Exp exp) {
- final Extent extent = new Extent(typeSystem, pat, boundPats);
-
- final ListMultimap map = LinkedListMultimap.create();
- extent.g3(map, exp);
- final List exps = map.get(pat);
- if (exps.isEmpty()) {
- throw new AssertionError();
+ SortedMap boundPats,
+ Iterable followingSteps,
+ PairList idPats) {
+ final Extent extent = new Extent(typeSystem, pat, boundPats, idPats);
+ final List remainingFilters = new ArrayList<>();
+
+ final ExtentMap map = new ExtentMap();
+ for (Core.FromStep step : followingSteps) {
+ if (step instanceof Core.Where) {
+ extent.g3(map.map, ((Core.Where) step).exp);
+ }
}
- final Pair> pair =
- core.mergeExtents(typeSystem, exps, true);
- return new Analysis(boundPats, extent.goalPats, pair.left, pair.right);
+ extent.definitions.forEach((namedPat, exp) -> {
+ // Is this expression better than the existing one?
+ // Yes, if there's no existing expression,
+ // or if the existing expression is infinite.
+ // For example, 'dno = v.deptno' is better than 'dno > 25'.
+ if (!map.map.containsKey(namedPat)
+ || Extents.isInfinite(map.map.get(namedPat).left(0))) {
+ map.map.put(namedPat,
+ ImmutablePairList.of(core.list(typeSystem, exp),
+ core.equal(typeSystem, core.id(namedPat), exp)));
+ }
+ });
+ final PairList foo = map.get(typeSystem, pat);
+ final Pair extentFilter;
+ if (foo.isEmpty()) {
+ extentFilter =
+ Pair.of(
+ core.extent(typeSystem, pat.type,
+ ImmutableRangeSet.of(Range.all())),
+ core.boolLiteral(true));
+ } else {
+ extentFilter = reduceAnd(typeSystem, foo);
+ }
+ return new Analysis(boundPats, extent.goalPats,
+ extentFilter.left, core.decomposeAnd(extentFilter.right),
+ remainingFilters);
}
/** Converts a singleton id pattern "x" or tuple pattern "(x, y)"
@@ -157,24 +198,162 @@ private static List flatten(Core.Pat pat) {
//noinspection unchecked,rawtypes
return (List) tuplePat.args;
+ case RECORD_PAT:
+ final Core.RecordPat recordPat = (Core.RecordPat) pat;
+ for (Core.Pat arg : recordPat.args) {
+ if (arg.op != Op.ID_PAT) {
+ throw new CompileException("must be id", false, arg.pos);
+ }
+ }
+ //noinspection unchecked,rawtypes
+ return (List) recordPat.args;
+
default:
throw new CompileException("must be id", false, pat.pos);
}
}
+ /** Returns whether an expression is an infinite extent. */
+ public static boolean isInfinite(Core.Exp exp) {
+ if (!exp.isCallTo(BuiltIn.Z_EXTENT)) {
+ return false;
+ }
+ final Core.Apply apply = (Core.Apply) exp;
+ final Core.Literal literal = (Core.Literal) apply.arg;
+ final RangeExtent rangeExtent = literal.unwrap(RangeExtent.class);
+ return rangeExtent.iterable == null;
+ }
+
+ public static Core.Decl infinitePats(TypeSystem typeSystem,
+ Core.Decl node) {
+ return node.accept(
+ new Shuttle(typeSystem) {
+ @Override protected Core.From visit(Core.From from) {
+ for (Ord step : Ord.zip(from.steps)) {
+ if (step.e instanceof Core.Scan) {
+ final Core.Scan scan = (Core.Scan) step.e;
+ if (isInfinite(scan.exp)) {
+ final FromBuilder fromBuilder = core.fromBuilder(typeSystem);
+ List followingSteps =
+ skip(from.steps, step.i + 1);
+ final Analysis analysis =
+ create(typeSystem, scan.pat, ImmutableSortedMap.of(),
+ followingSteps, ImmutablePairList.of());
+ for (Core.FromStep step2 : from.steps) {
+ if (step2 == scan) {
+ fromBuilder.scan(scan.pat, analysis.extentExp,
+ scan.condition); // TODO
+ } else if (step2 instanceof Core.Where) {
+ fromBuilder.where(
+ core.subTrue(typeSystem,
+ ((Core.Where) step2).exp,
+ analysis.satisfiedFilters));
+ } else {
+ fromBuilder.addAll(ImmutableList.of(step2));
+ }
+ }
+ return fromBuilder.build();
+ }
+ }
+ }
+ return from; // unchanged
+ }
+ });
+ }
+
+ /** Intersects a collection of range set maps
+ * (maps from prefix to {@link RangeSet}) into one. */
+ public static >
+ Map> intersect(
+ List>> rangeSetMaps) {
+ switch (rangeSetMaps.size()) {
+ case 0:
+ // No filters, therefore the extent allows all values.
+ // An empty map expresses this.
+ return ImmutableMap.of();
+
+ case 1:
+ return rangeSetMaps.get(0);
+
+ default:
+ final Multimap> rangeSetMultimap =
+ HashMultimap.create();
+ for (Map> rangeSetMap : rangeSetMaps) {
+ rangeSetMap.forEach(rangeSetMultimap::put);
+ }
+ final ImmutableMap.Builder> rangeSetMap =
+ ImmutableMap.builder();
+ rangeSetMultimap.asMap().forEach((path, rangeSets) ->
+ rangeSetMap.put(path, intersectRangeSets(rangeSets)));
+ return rangeSetMap.build();
+ }
+ }
+
+ /** Unions a collection of range set maps
+ * (maps from prefix to {@link RangeSet}) into one. */
+ public static >
+ Map> union(
+ List>> rangeSetMaps) {
+ switch (rangeSetMaps.size()) {
+ case 0:
+ // No filters, therefore the extent is empty.
+ // A map containing an empty RangeSet for path "/" expresses this.
+ return ImmutableMap.of("/", ImmutableRangeSet.of());
+
+ case 1:
+ return rangeSetMaps.get(0);
+
+ default:
+ final Multimap> rangeSetMultimap =
+ HashMultimap.create();
+ for (Map> rangeSetMap : rangeSetMaps) {
+ rangeSetMap.forEach(rangeSetMultimap::put);
+ }
+ final ImmutableMap.Builder> rangeSetMap =
+ ImmutableMap.builder();
+ rangeSetMultimap.asMap().forEach((path, rangeSets) ->
+ rangeSetMap.put(path, unionRangeSets(rangeSets)));
+ return rangeSetMap.build();
+ }
+ }
+
+ /** Intersects a collection of {@link RangeSet} into one.
+ *
+ * @see ImmutableRangeSet#intersection(RangeSet) */
+ private static > ImmutableRangeSet
+ intersectRangeSets(Collection> rangeSets) {
+ return rangeSets.stream().reduce(ImmutableRangeSet.of(Range.all()),
+ ImmutableRangeSet::intersection);
+ }
+
+ /** Unions a collection of {@link RangeSet} into one.
+ *
+ * @see ImmutableRangeSet#union(RangeSet) */
+ private static > ImmutableRangeSet unionRangeSets(
+ Collection> rangeSets) {
+ return rangeSets.stream().reduce(ImmutableRangeSet.of(),
+ ImmutableRangeSet::union);
+ }
+
+ /** Result of analyzing the variables in a query, pulling filters into the
+ * extent expression for each variable, so that no variable is over an
+ * infinite extent. */
public static class Analysis {
final SortedMap boundPats;
final Set goalPats;
final Core.Exp extentExp;
+ final List satisfiedFilters; // filters satisfied by extentExp
final List remainingFilters;
- Analysis(SortedMap boundPats,
- Set goalPats, Core.Exp extentExp,
+ private Analysis(SortedMap boundPats,
+ Set goalPats,
+ Core.Exp extentExp, List satisfiedFilters,
List remainingFilters) {
- this.boundPats = boundPats;
- this.goalPats = goalPats;
+ this.boundPats = ImmutableSortedMap.copyOf(boundPats);
+ this.goalPats = ImmutableSet.copyOf(goalPats);
this.extentExp = extentExp;
- this.remainingFilters = remainingFilters;
+ this.satisfiedFilters = ImmutableList.copyOf(satisfiedFilters);
+ this.remainingFilters = ImmutableList.copyOf(remainingFilters);
}
Set unboundPats() {
@@ -187,43 +366,78 @@ private static class Extent {
final Set goalPats;
final SortedMap boundPats;
+ /** New variables introduced as scans over an existing relation (list of
+ * records). Other variables, which are goals of this extent, are typically
+ * fields of this variable. */
+ final PairList idPats;
+
+ /** Contains definitions, such as "name = d.dname".
+ * With such a definition, "name" won't need an extent, because we
+ * can define it (or inline it) as the expression "d.dname". */
+ final Map definitions = new HashMap<>();
+
Extent(TypeSystem typeSystem, Core.Pat pat,
- SortedMap boundPats) {
+ SortedMap boundPats,
+ PairList idPats) {
this.typeSystem = typeSystem;
this.goalPats = ImmutableSet.copyOf(flatten(pat));
this.boundPats = ImmutableSortedMap.copyOf(boundPats);
+ this.idPats = idPats;
}
@SuppressWarnings("SwitchStatementWithTooFewBranches")
- void g3(Multimap map, Core.Exp exp) {
+ void g3(Map> map, Core.Exp filter) {
final Core.Apply apply;
- switch (exp.op) {
+ switch (filter.op) {
case APPLY:
- apply = (Core.Apply) exp;
+ apply = (Core.Apply) filter;
switch (apply.fn.op) {
case FN_LITERAL:
BuiltIn builtIn = ((Core.Literal) apply.fn).unwrap(BuiltIn.class);
+ final Map> map2;
switch (builtIn) {
case Z_ANDALSO:
- // Expression is 'andalso'. Visit each pattern, and union the
- // constraints (intersect the generators).
- apply.arg.forEachArg((arg, i) -> g3(map, arg));
+ // Expression is 'andalso'. Visit each pattern, and 'and' the
+ // filters (intersect the extents).
+ map2 = new LinkedHashMap<>();
+ apply.arg.forEachArg((arg, i) -> g3(map2, arg));
+ map2.forEach((pat, foo) ->
+ map.computeIfAbsent(pat, p -> PairList.of())
+ .addAll(foo));
break;
case Z_ORELSE:
// Expression is 'orelse'. Visit each pattern, and intersect the
// constraints (union the generators).
- final Multimap map2 =
- LinkedListMultimap.create();
+ map2 = new LinkedHashMap<>();
+ final Map> map3 =
+ new LinkedHashMap<>();
apply.arg.forEachArg((arg, i) -> {
- final Multimap map3 =
- LinkedListMultimap.create();
g3(map3, arg);
- map3.asMap().forEach((k, vs) ->
- map2.put(k, core.intersect(typeSystem, vs)));
+ map3.forEach((pat, foo) ->
+ map2.computeIfAbsent(pat, p -> PairList.of())
+ .add(reduceAnd(typeSystem, foo)));
+ map3.clear();
+ });
+ map2.forEach((pat, foo) -> {
+ final PairList foo1 =
+ map.computeIfAbsent(pat, p -> PairList.of());
+ if (foo1.isEmpty()) {
+ // [] union [x2, x3, x4]
+ // =>
+ // [x2, x3, x4]
+ foo1.add(reduceOr(typeSystem, foo));
+ } else {
+ // [x0, x1] union [x2, x3, x4]
+ // =>
+ // [union(intersect(x0, x1), intersect(x2, x3, x4))]
+ PairList intersectExtents = PairList.of();
+ intersectExtents.add(reduceAnd(typeSystem, foo1));
+ intersectExtents.add(reduceAnd(typeSystem, foo));
+ foo1.clear();
+ foo1.add(reduceOr(typeSystem, intersectExtents));
+ }
});
- map2.asMap().forEach((k, vs) ->
- map.put(k, core.union(typeSystem, vs)));
break;
case OP_EQ:
@@ -232,7 +446,36 @@ void g3(Multimap map, Core.Exp exp) {
case OP_GT:
case OP_LT:
case OP_LE:
- g4(map, builtIn, apply.arg(0), apply.arg(1));
+ g4(builtIn, apply.arg(0), apply.arg(1), (pat, filter2, extent) ->
+ map.computeIfAbsent(pat, p -> PairList.of())
+ .add(extent, filter2));
+ break;
+
+ case OP_ELEM:
+ switch (apply.arg(0).op) {
+ case ID:
+ final Core.NamedPat pat = ((Core.Id) apply.arg(0)).idPat;
+ map.computeIfAbsent(pat, p1 -> PairList.of())
+ .add(apply.arg(1), apply);
+ break;
+
+ case TUPLE:
+ final Core.Tuple tuple = (Core.Tuple) apply.arg(0);
+ final Core.Id id = core.id(createId(tuple.type, apply.arg(1)));
+ final Core.Exp elem = core.elem(typeSystem, id, apply.arg(1));
+ g3(map,
+ core.andAlso(typeSystem, elem,
+ core.equal(typeSystem, id, tuple)));
+ final List conjunctions = new ArrayList<>();
+ conjunctions.add(core.elem(typeSystem, id, apply.arg(1)));
+ tuple.forEach((i, name, arg) ->
+ conjunctions.add(
+ core.equal(typeSystem,
+ core.field(typeSystem, id, i),
+ arg)));
+ g3(map, core.andAlso(typeSystem, conjunctions));
+ break;
+ }
break;
}
}
@@ -243,11 +486,23 @@ void g3(Multimap map, Core.Exp exp) {
}
}
+ private void g4(BuiltIn builtIn, Core.Exp arg0, Core.Exp arg1,
+ TriConsumer consumer) {
+ g5(builtIn, arg0, arg1, consumer);
+ g5(builtIn.reverse(), arg1, arg0, consumer);
+ }
+
@SuppressWarnings("SwitchStatementWithTooFewBranches")
- private void g4(Multimap map, BuiltIn builtIn,
- Core.Exp arg0, Core.Exp arg1) {
+ private void g5(BuiltIn builtIn, Core.Exp arg0, Core.Exp arg1,
+ TriConsumer consumer) {
switch (builtIn) {
case OP_EQ:
+ switch (arg0.op) {
+ case ID:
+ final Core.Id id = (Core.Id) arg0;
+ definitions.put(id.idPat, arg1);
+ }
+ // fall through
case OP_NE:
case OP_GE:
case OP_GT:
@@ -259,14 +514,11 @@ private void g4(Multimap map, BuiltIn builtIn,
if (arg1.isConstant()) {
// If exp is "id = literal", add extent "id: [literal]";
// if exp is "id > literal", add extent "id: (literal, inf)", etc.
- map.put(id.idPat, baz(builtIn, arg1));
+ consumer.accept(id.idPat,
+ core.call(typeSystem, builtIn, arg0.type, Pos.ZERO, arg0, arg1),
+ baz(builtIn, arg1));
}
break;
- default:
- if (arg0.isConstant() && arg1.op == Op.ID) {
- // Try switched, "literal = id".
- g4(map, builtIn.reverse(), arg1, arg0);
- }
}
break;
@@ -275,7 +527,6 @@ private void g4(Multimap map, BuiltIn builtIn,
}
}
- @SuppressWarnings("UnstableApiUsage")
private Core.Exp baz(BuiltIn builtIn, Core.Exp arg) {
switch (builtIn) {
case OP_EQ:
@@ -301,73 +552,161 @@ private Core.Exp baz(BuiltIn builtIn, Core.Exp arg) {
}
}
- @SuppressWarnings("UnstableApiUsage")
- ExtentFilter extent(Core.Scan scan) {
- final List extents = new ArrayList<>();
- final List filters = new ArrayList<>();
- extent(scan.pat, scan.exp, extents, filters);
- final Core.Exp extent;
- if (extents.isEmpty()) {
- extent = core.extent(typeSystem, scan.pat.type,
- ImmutableRangeSet.of(Range.all()));
- } else {
- extent = extents.get(0);
- filters.addAll(skip(extents));
+ private Core.IdPat createId(Type type, Core.Exp extent) {
+ int i = idPats.firstMatch((id, e) -> extent.equals(e));
+ if (i >= 0) {
+ return idPats.leftList().get(i);
}
- return new ExtentFilter(extent, ImmutableList.copyOf(filters));
+ final Core.IdPat idPat = core.idPat(type, typeSystem.nameGenerator);
+ idPats.add(idPat, extent);
+ return idPat;
}
+ }
- private void extent(Core.Pat pat, Core.Exp exp, List extents,
- List filters) {
- switch (exp.op) {
- case APPLY:
- final Core.Apply apply = (Core.Apply) exp;
- switch (apply.fn.op) {
- case FN_LITERAL:
- switch ((BuiltIn) ((Core.Literal) apply.fn).value) {
- case OP_ELEM:
- final List args = ((Core.Tuple) apply.arg).args;
- if (matches(args.get(0), pat)) {
- extents.add(args.get(1));
- }
- break;
- case Z_ANDALSO:
- for (Core.Exp e : ((Core.Tuple) apply.arg).args) {
- extent(pat, e, extents, filters);
- return;
- }
- }
- }
+ /** Reduces a list of extent-filter pairs [e0, f0, e1, f1, ...]
+ * to an extent-filter pair [e0 intersect e1 ..., f0 andalso f1 ...].
+ *
+ * If any of the ei are calls to
+ * {@link BuiltIn#Z_EXTENT extent}, merges them into a single extent.
+ * For example, in
+ *
+ *
{@code
+ * [extent "int: (0, inf)", x > 0,
+ * x elem primes, isPrime x,
+ * extent "int: (-inf, 10)", x < 10]
+ * }
+ *
+ * the extents for "(0, inf)" and "(-inf, 10)" are merged into
+ * extent "(0, 10)":
+ *
+ *
{@code
+ * (extent "int: (0, 10)" intersect primes,
+ * x > 0 andalso isPrime x andalso x < 10)
+ * }
+ */
+ static Pair reduceAnd(TypeSystem typeSystem,
+ PairList extentFilters) {
+ if (extentFilters.isEmpty()) {
+ // Empty list would require us to create an infinite extent, but we
+ // don't know the type. Caller must ensure that the list is non-empty.
+ throw new IllegalArgumentException();
+ }
+ final List extents = new ArrayList<>();
+ core.flattenAnds(extentFilters.leftList(), extents::add);
+ final Pair> pair =
+ core.intersectExtents(typeSystem, extents);
+ return Pair.of(pair.left,
+ core.andAlso(typeSystem, extentFilters.rightList()));
+ }
+
+ /** Reduces a list of extent-filter pairs [e0, f0, e1, f1, ...]
+ * to an extent-filter pair [e0 union e1 ..., f0 orelse f1 ...]. */
+ static Pair reduceOr(TypeSystem typeSystem,
+ PairList extentFilters) {
+ return Pair.of(core.union(typeSystem, extentFilters.leftList()),
+ core.orElse(typeSystem, extentFilters.rightList()));
+ }
+
+ @FunctionalInterface
+ interface TriConsumer {
+ void accept(R r, S s, T t);
+ }
+
+ static class ExtentMap {
+ final Map> map =
+ new LinkedHashMap<>();
+
+ public PairList get(TypeSystem typeSystem,
+ Core.Pat pat) {
+ PairList foo = map.get(pat);
+ if (foo != null && !foo.isEmpty()) {
+ return foo;
+ }
+ if (canGet(pat)) {
+ return get_(typeSystem, pat);
}
- filters.add(exp);
+ return ImmutablePairList.of();
}
- /** Returns whether an expression corresponds exactly to a pattern.
- * For example "x" matches the pattern "x",
- * and "(z, y)" matches the pattern "(x, y)". */
- private static boolean matches(Core.Exp exp, Core.Pat pat) {
- if (exp.op == Op.ID && pat.op == Op.ID_PAT) {
- return ((Core.Id) exp).idPat.equals(pat);
+ /**
+ * Constructs an expression for the extent of a pattern.
+ * You must have called {@link #canGet} first.
+ */
+ private @NonNull PairList get_(TypeSystem typeSystem,
+ Core.Pat pat) {
+ final PairList foo = map.get(pat);
+ if (foo != null && !foo.isEmpty()) {
+ return foo;
}
- if (exp.op == Op.TUPLE && pat.op == Op.TUPLE_PAT) {
- final Core.Tuple tuple = (Core.Tuple) exp;
+ switch (pat.op) {
+ case TUPLE_PAT:
final Core.TuplePat tuplePat = (Core.TuplePat) pat;
- if (tuple.args.size() == tuplePat.args.size()) {
- return allMatch(tuple.args, tuplePat.args, Extent::matches);
+ if (tuplePat.args.stream().allMatch(this::canGet)) {
+ // Convert 'from x, y where p(x) andalso q(y)'
+ // to 'from x in extentP, y in extentQ'
+ // and that becomes the extent of '(x, y)'.
+ final FromBuilder fromBuilder = core.fromBuilder(typeSystem);
+ final List filters = new ArrayList<>();
+ for (Core.Pat p : tuplePat.args) {
+ PairList f =
+ requireNonNull(get(typeSystem, p), "contradicts canGet");
+ fromBuilder.scan(p, core.union(typeSystem, f.leftList()));
+ core.flattenAnds(f.rightList(), filters::add);
+ }
+ return PairList.of(fromBuilder.build(),
+ core.andAlso(typeSystem, filters));
+ } else {
+ final PairList foo1 = PairList.of();
+ map.forEach((pat1, foo2) -> {
+ if (pat1.op == Op.TUPLE_PAT) {
+ final Core.TuplePat tuplePat1 = (Core.TuplePat) pat1;
+ final List fieldNames = tuplePat1.fieldNames();
+ if (tuplePat.args.stream().allMatch(arg ->
+ arg instanceof Core.NamedPat
+ && fieldNames.contains(((Core.NamedPat) arg).name))) {
+ foo1.addAll(foo2);
+ }
+ }
+ });
+ return foo1;
}
+ default:
+ throw new AssertionError("contradicts canGet");
}
- return false;
}
- }
-
- /** A "suchthat" expression split into an extent and filters. */
- static class ExtentFilter {
- final Core.Exp extent;
- final ImmutableList filters;
- ExtentFilter(Core.Exp extent, ImmutableList filters) {
- this.extent = extent;
- this.filters = filters;
+ boolean canGet(Core.Pat pat) {
+ PairList foo = map.get(pat);
+ if (foo != null && !foo.isEmpty()) {
+ return true;
+ }
+ if (pat.type.isFinite()) {
+ return true;
+ }
+ switch (pat.op) {
+ case TUPLE_PAT:
+ final Core.TuplePat tuplePat = (Core.TuplePat) pat;
+ if (tuplePat.args.stream().allMatch(this::canGet)) {
+ return true;
+ }
+ // If the map contains a tuple with a field for every one of this
+ // tuple's fields (not necessarily in the same order) then we can use
+ // it.
+ for (Core.Pat pat1 : map.keySet()) {
+ if (pat1.op == Op.TUPLE_PAT) {
+ final Core.TuplePat tuplePat1 = (Core.TuplePat) pat1;
+ final List fieldNames = tuplePat1.fieldNames();
+ if (tuplePat.args.stream().allMatch(arg ->
+ arg instanceof Core.NamedPat
+ && fieldNames.contains(((Core.NamedPat) arg).name))) {
+ return true;
+ }
+ }
+ }
+ return false;
+ default:
+ return false;
+ }
}
}
}
diff --git a/src/main/java/net/hydromatic/morel/compile/Inliner.java b/src/main/java/net/hydromatic/morel/compile/Inliner.java
index 547a50b2e..896e00181 100644
--- a/src/main/java/net/hydromatic/morel/compile/Inliner.java
+++ b/src/main/java/net/hydromatic/morel/compile/Inliner.java
@@ -125,6 +125,7 @@ public static Inliner of(TypeSystem typeSystem, Environment env,
if (apply2.fn.op == Op.RECORD_SELECTOR
&& apply2.arg.op == Op.VALUE_LITERAL) {
final Core.RecordSelector selector = (Core.RecordSelector) apply2.fn;
+ @SuppressWarnings("rawtypes")
final List list = ((Core.Literal) apply2.arg).unwrap(List.class);
final Object o = list.get(selector.slot);
if (o instanceof Applicable || o instanceof Macro) {
diff --git a/src/main/java/net/hydromatic/morel/compile/Resolver.java b/src/main/java/net/hydromatic/morel/compile/Resolver.java
index 1e79d4b9d..692afc8ff 100644
--- a/src/main/java/net/hydromatic/morel/compile/Resolver.java
+++ b/src/main/java/net/hydromatic/morel/compile/Resolver.java
@@ -23,7 +23,6 @@
import net.hydromatic.morel.ast.FromBuilder;
import net.hydromatic.morel.ast.Op;
import net.hydromatic.morel.ast.Pos;
-import net.hydromatic.morel.ast.Shuttle;
import net.hydromatic.morel.ast.Visitor;
import net.hydromatic.morel.eval.Session;
import net.hydromatic.morel.type.Binding;
@@ -41,14 +40,15 @@
import com.google.common.collect.ImmutableList;
import com.google.common.collect.ImmutableMap;
+import com.google.common.collect.ImmutableRangeSet;
import com.google.common.collect.ImmutableSortedMap;
+import com.google.common.collect.Range;
import org.checkerframework.checker.nullness.qual.Nullable;
import java.math.BigDecimal;
import java.util.ArrayDeque;
import java.util.ArrayList;
import java.util.Collection;
-import java.util.Comparator;
import java.util.Deque;
import java.util.HashMap;
import java.util.HashSet;
@@ -612,7 +612,7 @@ private Core.Pat toCore(Ast.Pat pat, Type type, Type targetType) {
case TUPLE_PAT:
final Ast.TuplePat tuplePat = (Ast.TuplePat) pat;
final List argList = transformEager(tuplePat.args, this::toCore);
- return core.tuplePat(type, argList);
+ return core.tuplePat((RecordLikeType) type, argList);
default:
throw new AssertionError("unknown pat " + pat.op);
@@ -866,53 +866,22 @@ Core.Exp run(Ast.From from) {
final Resolver r = withEnv(fromBuilder.bindings());
final Core.Exp coreExp;
final Core.Pat corePat;
- switch (scan.exp.op) {
- case SUCH_THAT:
- corePat =
- r.toCore(scan.pat).accept(
- // Converts tuple patterns into copies sorted by field names.
- // For example, (b, c, a) becomes (a, b, c).
- // Sorting is necessary because "from (b, c, a) suchthat p" will
- // add variables a, b, c to the environment (in that order).
- new Shuttle(typeMap.typeSystem) {
- @Override protected Core.Pat visit(Core.TuplePat tuplePat) {
- final Comparator comparator =
- Comparator.comparing(pat ->
- pat instanceof Core.NamedPat
- ? ((Core.NamedPat) pat).name
- : "");
- return tuplePat.copy(typeSystem,
- ImmutableList.sortedCopyOf(comparator,
- visitList(tuplePat.args)));
- }
- });
-
- final List bindings2 = new ArrayList<>(fromBuilder.bindings());
- Compiles.acceptBinding(typeMap.typeSystem, corePat, bindings2);
- final Resolver r2 = withEnv(bindings2);
-
- final Ast.Exp scanExp = ((Ast.PrefixCall) scan.exp).a;
- coreExp = r2.toCore(scanExp);
- break;
-
- default:
+ if (scan.exp == null) {
+ corePat = r.toCore(scan.pat);
+ coreExp =
+ core.extent(typeMap.typeSystem, corePat.type,
+ ImmutableRangeSet.of(Range.all()));
+ } else {
coreExp = r.toCore(scan.exp);
final ListType listType = (ListType) coreExp.type;
corePat = r.toCore(scan.pat, listType.elementType);
}
- final Op op = scan.exp.op == Op.SUCH_THAT ? Op.SUCH_THAT
- : scan.op == Op.SCAN ? Op.INNER_JOIN
- : scan.op;
final List bindings2 = new ArrayList<>(fromBuilder.bindings());
Compiles.acceptBinding(typeMap.typeSystem, corePat, bindings2);
Core.Exp coreCondition = scan.condition == null
? core.boolLiteral(true)
: r.withEnv(bindings2).toCore(scan.condition);
- if (op == Op.SUCH_THAT) {
- fromBuilder.suchThat(corePat, coreExp);
- } else {
- fromBuilder.scan(corePat, coreExp, coreCondition);
- }
+ fromBuilder.scan(corePat, coreExp, coreCondition);
}
@Override protected void visit(Ast.Where where) {
diff --git a/src/main/java/net/hydromatic/morel/compile/SuchThatShuttle.java b/src/main/java/net/hydromatic/morel/compile/SuchThatShuttle.java
index 33cd37eaa..3e9c6e167 100644
--- a/src/main/java/net/hydromatic/morel/compile/SuchThatShuttle.java
+++ b/src/main/java/net/hydromatic/morel/compile/SuchThatShuttle.java
@@ -20,17 +20,13 @@
import net.hydromatic.morel.ast.Core;
import net.hydromatic.morel.ast.FromBuilder;
-import net.hydromatic.morel.ast.Op;
import net.hydromatic.morel.ast.Shuttle;
import net.hydromatic.morel.ast.Visitor;
-import net.hydromatic.morel.type.ListType;
-import net.hydromatic.morel.type.RecordType;
+import net.hydromatic.morel.type.Binding;
import net.hydromatic.morel.type.TypeSystem;
-import net.hydromatic.morel.util.Ord;
-import net.hydromatic.morel.util.Pair;
+import net.hydromatic.morel.util.PairList;
-import com.google.common.collect.ImmutableList;
-import com.google.common.collect.ImmutableMap;
+import com.google.common.collect.ImmutableSet;
import com.google.common.collect.ImmutableSortedMap;
import org.apache.calcite.util.Holder;
import org.checkerframework.checker.nullness.qual.Nullable;
@@ -38,40 +34,47 @@
import java.util.ArrayDeque;
import java.util.ArrayList;
import java.util.Deque;
+import java.util.LinkedHashSet;
import java.util.List;
import java.util.Map;
import java.util.Set;
-import java.util.SortedMap;
-import java.util.TreeMap;
-import java.util.function.UnaryOperator;
+import java.util.function.Consumer;
import static net.hydromatic.morel.ast.CoreBuilder.core;
-import static net.hydromatic.morel.util.Pair.forEach;
-import static net.hydromatic.morel.util.Static.append;
-import static net.hydromatic.morel.util.Static.plus;
import static net.hydromatic.morel.util.Static.skip;
-import static com.google.common.collect.Iterables.getLast;
-import static com.google.common.collect.Iterables.getOnlyElement;
+import static com.google.common.collect.ImmutableSet.toImmutableSet;
/**
- * Converts {@code suchThat} to {@code in} wherever possible.
+ * Converts unbounded variables to bounded variables.
+ *
+ * For example, converts
+ *
+ *
{@code
+ * from e
+ * where e elem #dept scott
+ * }
+ *
+ * to
+ *
+ *
{@code
+ * from e in #dept scott
+ * }
*/
class SuchThatShuttle extends Shuttle {
- final Deque fromStates = new ArrayDeque<>();
- final Environment env;
+ final @Nullable Environment env;
- SuchThatShuttle(TypeSystem typeSystem, Environment env) {
+ SuchThatShuttle(TypeSystem typeSystem, @Nullable Environment env) {
super(typeSystem);
this.env = env;
}
- static boolean containsSuchThat(Core.Decl decl) {
+ static boolean containsUnbounded(Core.Decl decl) {
final Holder found = Holder.of(false);
decl.accept(new Visitor() {
@Override protected void visit(Core.Scan scan) {
super.visit(scan);
- if (scan.op == Op.SUCH_THAT) {
+ if (Extents.isInfinite(scan.exp)) {
found.set(true);
}
}
@@ -80,332 +83,231 @@ static boolean containsSuchThat(Core.Decl decl) {
}
@Override protected Core.Exp visit(Core.From from) {
- try {
- final FromState fromState = new FromState(from);
- fromStates.push(fromState);
- for (Core.FromStep node : from.steps) {
- fromState.steps.add(node.accept(this));
- }
- return from.copy(typeSystem, env, fromState.steps);
- } finally {
- fromStates.pop();
- }
+ final Core.From from2 = new FromVisitor(typeSystem, env).visit(from);
+ return from2.equals(from) ? from : from2;
}
- @Override protected Core.Scan visit(Core.Scan scan) {
- if (scan.op != Op.SUCH_THAT) {
- return super.visit(scan);
- }
- final ImmutableSortedMap.Builder boundPatBuilder =
- ImmutableSortedMap.orderedBy(Core.NamedPat.ORDERING);
- if (!fromStates.element().steps.isEmpty()) {
- getLast(fromStates.element().steps).bindings.forEach(b ->
- boundPatBuilder.put(b.id, core.id(b.id)));
- }
- final SortedMap boundPats = boundPatBuilder.build();
- final Core.Exp rewritten = rewrite0(boundPats, scan.pat, scan.exp);
- return core.scan(Op.INNER_JOIN, scan.bindings,
- scan.pat, rewritten, scan.condition);
- }
+ /** Workspace for converting unbounded variables in a particular
+ * {@link Core.From} to bounded scans. */
+ static class FromVisitor {
+ final TypeSystem typeSystem;
+ final FromBuilder fromBuilder;
+ final List satisfiedFilters = new ArrayList<>();
- private Core.Exp rewrite0(SortedMap boundPats,
- Core.Pat pat, Core.Exp exp) {
- try {
- final Map scans = ImmutableMap.of();
- final List filters = ImmutableList.of();
- final UnaryOperator originalPats = UnaryOperator.identity();
- return rewrite(originalPats, boundPats, scans, filters,
- conjunctions(exp));
- } catch (RewriteFailedException e) {
- // We could not rewrite.
- // Try a different approach.
- // Generate an iterator over all values of all variables,
- // then filter.
- final Core.Exp generator = Extents.generator(typeSystem, pat, exp);
- final FromBuilder fromBuilder = core.fromBuilder(typeSystem);
- return fromBuilder.scan(pat, generator)
- .where(exp)
- .build();
+ FromVisitor(TypeSystem typeSystem, @Nullable Environment env) {
+ this.typeSystem = typeSystem;
+ this.fromBuilder = core.fromBuilder(typeSystem, env);
}
- }
- /** Rewrites a "from vars suchthat condition" expression to a
- * "from vars in list" expression; returns null if no rewrite is possible.
- *
- * The "filters" argument contains a list of conditions to be applied
- * after generating rows. For example,
- * "from x suchthat x % 2 = 1 and x elem list"
- * becomes "from x in list where x % 2 = 1" with the filter "x % 2 = 1".
- *
- *
The "scans" argument contains scans to be added. For example,
- * "from x suchthat x elem list" adds the scan "(x, list)".
- *
- *
The "boundPats" argument contains expressions that are bound to
- * variables. For example, "from (x, y) suchthat (x, y) elem list"
- * will add the scan "(e, list)" and boundPats [(x, #1 e), (y, #2 e)].
- *
- * @param mapper Renames variables
- * @param boundPats Variables that have been bound to a list
- * @param scans Scans (joins) to be appended to the resulting "from"
- * @param filters Filters to be appended as "where" in the resulting "from"
- * @param exps The condition, decomposed into conjunctions
- * @return Rewritten expression
- */
- private Core.Exp rewrite(UnaryOperator mapper,
- SortedMap boundPats,
- Map scans, List filters,
- List exps) {
- if (exps.isEmpty()) {
- final ImmutableSortedMap.Builder b =
- ImmutableSortedMap.naturalOrder();
- boundPats.forEach((p, e) -> b.put(mapper.apply(p), e));
- final SortedMap boundPats2 = b.build();
-
- final SortedMap nameExps = RecordType.mutableMap();
- if (scans.isEmpty()) {
- final Core.Scan scan = (Core.Scan) fromStates.element().currentStep();
- final Extents.Analysis extent =
- Extents.create(typeSystem, scan.pat, boundPats2, scan.exp);
- final Set unboundPats = extent.unboundPats();
- if (!unboundPats.isEmpty()) {
- throw new RewriteFailedException("Cannot implement 'suchthat'; "
- + "variables " + unboundPats + " are not grounded" + "]");
- }
- boundPats2.forEach((p, e) -> {
- if (extent.goalPats.contains(p)) {
- nameExps.put(p.name, e);
+ Core.From visit(Core.From from) {
+ final List steps = from.steps;
+ final DeferredStepList deferredScans =
+ DeferredStepList.create(typeSystem, steps);
+
+ Environment env = Environments.empty();
+ final PairList idPats = PairList.of();
+ for (int i = 0; i < steps.size(); i++) {
+ final Core.FromStep step = steps.get(i);
+ switch (step.op) {
+ case SCAN:
+ case INNER_JOIN:
+ final Core.Scan scan = (Core.Scan) step;
+ if (Extents.isInfinite(scan.exp)) {
+ final int idPatCount = idPats.size();
+ final Core.Exp rewritten = rewrite1(scan, skip(steps, i), idPats);
+
+ // Create a scan for any new variables introduced by rewrite.
+ idPats.forEachIndexed((j, pat, extent) -> {
+ if (j >= idPatCount) {
+ fromBuilder.scan(pat, extent);
+ }
+ });
+ deferredScans.scan(env, scan.pat, rewritten, scan.condition);
+ } else {
+ deferredScans.scan(env, scan.pat, scan.exp);
}
- });
- } else {
- boundPats2.forEach((p, e) -> nameExps.put(p.name, e));
- }
+ break;
- final FromBuilder fromBuilder = core.fromBuilder(typeSystem);
- scans.forEach(fromBuilder::scan);
- filters.forEach(fromBuilder::where);
- fromBuilder.yield_(nameExps.size() == 1
- ? getOnlyElement(nameExps.values())
- : core.record(typeSystem, nameExps));
+ case YIELD:
+ final Core.Yield yield = (Core.Yield) step;
+ killTemporaryScans(idPats);
+ deferredScans.flush(fromBuilder);
+ fromBuilder.yield_(false, yield.bindings, yield.exp);
+ break;
+
+ case WHERE:
+ final Core.Where where = (Core.Where) step;
+ Core.Exp condition =
+ core.subTrue(typeSystem, where.exp, satisfiedFilters);
+ deferredScans.where(env, condition);
+ break;
+
+ case GROUP:
+ final Core.Group group = (Core.Group) step;
+ killTemporaryScans(idPats);
+ deferredScans.flush(fromBuilder);
+ fromBuilder.group(group.groupExps, group.aggregates);
+ break;
+
+ case ORDER:
+ final Core.Order order = (Core.Order) step;
+ killTemporaryScans(idPats);
+ deferredScans.flush(fromBuilder);
+ fromBuilder.order(order.orderItems);
+ break;
+
+ default:
+ throw new AssertionError(step.op);
+ }
+ env = Environments.empty().bindAll(step.bindings);
+ }
+ deferredScans.flush(fromBuilder);
+ killTemporaryScans(idPats);
return fromBuilder.build();
}
- final Core.Exp exp = exps.get(0);
- final List exps2 = skip(exps);
- switch (exp.op) {
- case APPLY:
- final Core.Apply apply = (Core.Apply) exp;
- if (exp.isCallTo(BuiltIn.OP_ELEM)) {
- Core.Exp a0 = apply.args().get(0);
- Core.Exp a1 = apply.args().get(1);
- Core.@Nullable Exp e =
- rewriteElem(typeSystem, mapper, boundPats, scans, filters, a0, a1,
- exps2);
- if (e != null) {
- return e;
- }
- throw new AssertionError(exp);
+
+ private void killTemporaryScans(PairList idPats) {
+ if (idPats.isEmpty()) {
+ return;
}
- if (exp.isCallTo(BuiltIn.OP_EQ)) {
- Core.Exp a0 = apply.args().get(0);
- Core.Exp a1 = apply.args().get(1);
- if (a1.op == Op.ID && a0.op != Op.ID) {
- final Core.Exp tmp = a0;
- a0 = a1;
- a1 = tmp;
- }
- Core.Exp a1List = core.list(typeSystem, a1);
- Core.@Nullable Exp e =
- rewriteElem(typeSystem, mapper, boundPats, scans,
- filters, a0, a1List, exps2);
- if (e != null) {
- return e;
+ final PairList nameExps = PairList.of();
+ for (Binding b : fromBuilder.bindings()) {
+ Core.IdPat id = (Core.IdPat) b.id;
+ if (!idPats.leftList().contains(id)) {
+ nameExps.add(id.name, core.id(id));
}
}
- final List filters2 = append(filters, exp);
- return rewrite(mapper, boundPats, scans, filters2,
- exps2);
-
- case CASE:
- final Core.Case case_ = (Core.Case) exp;
- if (case_.matchList.size() == 1) {
- // A simple renaming case, e.g. "case (e, j) of (a, b) => #job a = b",
- // boundPats is "{e}" translate as if the expression were "#job e = j",
- // boundPats = "{a}".
- final Core.Match match = case_.matchList.get(0);
- final SortedMap boundPats2 =
- new TreeMap<>(boundPats.comparator());
- boundPats.forEach((p, e) -> boundPats2.put(mapper.apply(p), e));
- final PatMap patMap = PatMap.of(match.pat, case_.exp);
- return rewrite(mapper.andThen(patMap::apply)::apply, boundPats2,
- scans, filters, plus(match.exp, exps2));
+ if (nameExps.size() == 1) {
+ fromBuilder.yield_(false, null, nameExps.get(0).getValue());
+ } else {
+ fromBuilder.yield_(false, null, core.record(typeSystem, nameExps));
}
- break;
+ idPats.clear();
}
- throw new RewriteFailedException("not implemented: suchthat " + exp.op
- + " [" + exp + "]");
- }
-
- private Core.@Nullable Exp rewriteElem(TypeSystem typeSystem,
- UnaryOperator mapper,
- SortedMap boundPats,
- Map scans,
- List filters, Core.Exp a0,
- Core.Exp a1, List exps2) {
- if (a0.op == Op.ID) {
- // from ... v suchthat (v elem list)
- final Core.IdPat idPat = (Core.IdPat) ((Core.Id) a0).idPat;
- if (!boundPats.containsKey(idPat)) {
- // "from a, b, c suchthat (b in list-valued-expression)"
- // --> remove b from unbound
- // add (b, scans.size) to bound
- // add list to scans
- // from ... v in list
- final SortedMap boundPats2 =
- plus(boundPats, idPat, core.id(idPat));
- final Map scans2 = plus(scans, idPat, a1);
- return rewrite(mapper, boundPats2, scans2, filters, exps2);
- } else {
- final Core.Exp e = boundPats.get(idPat);
- final List filters2 =
- append(filters, core.elem(typeSystem, e, a1));
- return rewrite(mapper, boundPats, scans, filters2, exps2);
- }
- } else if (a0.op == Op.TUPLE) {
- // from v, w, x suchthat ((v, w, x) elem list)
- // -->
- // from e suchthat (e elem list)
- // yield (e.v, e.w, e.x)
- final Core.Tuple tuple = (Core.Tuple) a0;
- final Core.IdPat idPat =
- core.idPat(((ListType) a1.type).elementType,
- typeSystem.nameGenerator);
- final Core.Id id = core.id(idPat);
- SortedMap boundPats2 = boundPats;
- List filters2 = filters;
- for (Ord arg : Ord.zip(tuple.args)) {
- final Core.Exp e = core.field(typeSystem, id, arg.i);
- if (arg.e instanceof Core.Id) {
- final Core.NamedPat idPat2 = ((Core.Id) arg.e).idPat;
- if (!boundPats2.containsKey(idPat2)) {
- // This variable was not previously bound; bind it.
- boundPats2 = plus(boundPats2, idPat2, e);
- } else {
- // This variable is already bound; now add a filter.
- filters2 =
- append(filters, core.equal(typeSystem, e, arg.e));
- }
- } else {
- filters2 =
- append(filters, core.equal(typeSystem, e, arg.e));
- }
- }
- final Map scans2 = plus(scans, idPat, a1);
- return rewrite(mapper, boundPats2, scans2, filters2, exps2);
- } else {
- return null;
+ /** Rewrites an unbounded scan to a {@code from} expression,
+ * using predicates in later steps to determine the ranges of variables. */
+ private Core.From rewrite1(Core.Scan scan,
+ List laterSteps,
+ PairList idPats) {
+ final Extents.Analysis analysis =
+ Extents.create(typeSystem, scan.pat, ImmutableSortedMap.of(),
+ laterSteps, idPats);
+ satisfiedFilters.addAll(analysis.satisfiedFilters);
+ final FromBuilder fromBuilder = core.fromBuilder(typeSystem);
+ fromBuilder.scan(scan.pat, analysis.extentExp);
+ return fromBuilder.build();
}
}
- /**
- * Returns an expression as a list of conjunctions.
+ /** Maintains a list of steps that have not been applied yet.
*
- * For example
- * {@code conjunctions(a andalso b)}
- * returns [{@code a}, {@code b}] (two elements);
- * {@code conjunctions(a andalso b andalso c)}
- * returns [{@code a}, {@code b}, {@code c}] (three elements);
- * {@code conjunctions(a orelse b)}
- * returns [{@code a orelse b}] (one element);
- * {@code conjunctions(true)}
- * returns [] (no elements);
- * {@code conjunctions(false)}
- * returns [{@code false}] (one element).
+ *
Holds the state necessary for a classic topological sort algorithm:
+ * For each node, keep the list of unresolved forward references.
+ * After each reference is resolved, remove it from each node's list.
+ * Output each node as its unresolved list becomes empty.
+ * The topological sort is stable.
*/
- static List conjunctions(Core.Exp e) {
- final ImmutableList.Builder b = ImmutableList.builder();
- addConjunctions(b, e);
- return b.build();
- }
+ static class DeferredStepList {
+ final PairList, Consumer> steps = PairList.of();
+ final FreeFinder freeFinder;
+ final List refs;
- private static void addConjunctions(ImmutableList.Builder b,
- Core.Exp e) {
- if (e.op == Op.APPLY
- && ((Core.Apply) e).fn.op == Op.FN_LITERAL
- && ((Core.Literal) ((Core.Apply) e).fn).value == BuiltIn.Z_ANDALSO) {
- ((Core.Apply) e).args().forEach(a -> addConjunctions(b, a));
- } else if (e.op != Op.BOOL_LITERAL
- || !((boolean) ((Core.Literal) e).value)) {
- // skip true
- b.add(e);
+ DeferredStepList(FreeFinder freeFinder, List refs) {
+ this.freeFinder = freeFinder;
+ this.refs = refs;
}
- }
- /** Workspace for converting a particular {@link Core.From} from "suchthat"
- * to "in" form. */
- static class FromState {
- final Core.From from;
- final List steps = new ArrayList<>();
-
- FromState(Core.From from) {
- this.from = from;
+ static DeferredStepList create(TypeSystem typeSystem,
+ List steps) {
+ final ImmutableSet forwardRefs =
+ steps.stream()
+ .filter(step -> step instanceof Core.Scan)
+ .map(step -> ((Core.Scan) step).pat)
+ .collect(toImmutableSet());
+ final List refs = new ArrayList<>();
+ final Consumer consumer = p -> {
+ if (forwardRefs.contains(p)) {
+ refs.add(p);
+ }
+ };
+ final FreeFinder freeFinder =
+ new FreeFinder(typeSystem, Environments.empty(),
+ new ArrayDeque<>(), consumer);
+ return new DeferredStepList(freeFinder, refs);
}
- Core.FromStep currentStep() {
- // We assume that from.steps are translated 1:1 into steps that get added
- // to this.steps. If steps.size() is N, we are currently working on
- // from.steps.get(N).
- return from.steps.get(steps.size());
+ void scan(Environment env, Core.Pat pat, Core.Exp exp, Core.Exp condition) {
+ final Set unresolvedRefs = unresolvedRefs(env, exp);
+ steps.add(unresolvedRefs, fromBuilder -> {
+ fromBuilder.scan(pat, exp, condition);
+ resolve(pat);
+ });
}
- }
- /** Maps patterns from their name in the "from" to their name after a sequence
- * of renames.
- *
- * For example, in "case (x, y) of (a, b) => a + b", "x" is renamed to "a"
- * and "y" is renamed to "b". */
- private static class PatMap {
- private final ImmutableMap map;
+ void scan(Environment env, Core.Pat pat, Core.Exp exp) {
+ final Set unresolvedRefs = unresolvedRefs(env, exp);
+ steps.add(unresolvedRefs, fromBuilder -> {
+ fromBuilder.scan(pat, exp);
+ resolve(pat);
+ });
+ }
- PatMap(ImmutableMap map) {
- this.map = map;
+ void where(Environment env, Core.Exp condition) {
+ final Set unresolvedRefs = unresolvedRefs(env, condition);
+ steps.add(unresolvedRefs,
+ fromBuilder -> fromBuilder.where(condition));
}
- static PatMap of(Core.Pat pat, Core.Exp exp) {
- final ImmutableMap.Builder builder =
- ImmutableMap.builder();
- populate(pat, exp, builder);
- return new PatMap(builder.build());
+ private Set unresolvedRefs(Environment env, Core.Exp exp) {
+ refs.clear();
+ exp.accept(freeFinder.push(env));
+ return new LinkedHashSet<>(refs);
}
- private static void populate(Core.Pat pat, Core.Exp exp,
- ImmutableMap.Builder nameBuilder) {
- switch (pat.op) {
- case ID_PAT:
- nameBuilder.put(Pair.of(((Core.Id) exp).idPat, (Core.IdPat) pat));
- break;
- case TUPLE_PAT:
- final Core.TuplePat tuplePat = (Core.TuplePat) pat;
- final Core.Tuple tuple = (Core.Tuple) exp;
- forEach(tuplePat.args, tuple.args,
- (pat2, exp2) -> populate(pat2, exp2, nameBuilder));
- break;
- }
+ /** Marks that a pattern has now been defined.
+ *
+ * After this method, it is possible that some steps might have no
+ * unresolved references. Those steps are now ready to add to the
+ * builder. */
+ void resolve(Core.Pat pat) {
+ steps.forEach((unresolvedRefs, consumer) -> unresolvedRefs.remove(pat));
}
- Core.NamedPat apply(Core.NamedPat p) {
- for (Map.Entry pair : map.entrySet()) {
- if (pair.getValue().equals(p)) {
- p = pair.getKey();
+ void flush(FromBuilder fromBuilder) {
+ // Are there any scans that had forward references previously but
+ // whose references are now all satisfied? Add them to the builder.
+ for (;;) {
+ int j = steps.firstMatch((unresolvedRefs, consumer) ->
+ unresolvedRefs.isEmpty());
+ if (j < 0) {
+ break;
}
+ final Map.Entry, Consumer> step =
+ steps.remove(j);
+ step.getValue().accept(fromBuilder);
}
- return p;
}
}
- /** Signals that we could not rewrite. */
- private static class RewriteFailedException extends RuntimeException {
- RewriteFailedException(String message) {
- super(message);
+ /** Finds free variables in an expression. */
+ private static class FreeFinder extends EnvVisitor {
+ final Consumer consumer;
+
+ FreeFinder(TypeSystem typeSystem, Environment env,
+ Deque fromStack, Consumer consumer) {
+ super(typeSystem, env, fromStack);
+ this.consumer = consumer;
+ }
+
+ @Override protected EnvVisitor push(Environment env) {
+ return new FreeFinder(typeSystem, env, fromStack, consumer);
+ }
+
+ @Override protected void visit(Core.Id id) {
+ if (env.getOpt(id.idPat) == null) {
+ consumer.accept(id.idPat);
+ }
}
}
}
diff --git a/src/main/java/net/hydromatic/morel/compile/TypeResolver.java b/src/main/java/net/hydromatic/morel/compile/TypeResolver.java
index 2d6276aed..c100d700d 100644
--- a/src/main/java/net/hydromatic/morel/compile/TypeResolver.java
+++ b/src/main/java/net/hydromatic/morel/compile/TypeResolver.java
@@ -484,49 +484,29 @@ private Pair deduceStepType(TypeEnv env,
final Ast.Scan scan = (Ast.Scan) step;
final Ast.Exp scanExp;
final boolean eq;
+ final Ast.Exp scanExp3;
final Unifier.Variable v15 = unifier.variable();
final Unifier.Variable v16 = unifier.variable();
final Map termMap1 = new HashMap<>();
- switch (scan.exp.op) {
- case SUCH_THAT:
+ if (scan.exp == null) {
+ scanExp = null;
+ eq = false;
+ scanExp3 = null;
+ } else if (scan.exp.op == Op.FROM_EQ) {
scanExp = ((Ast.PrefixCall) scan.exp).a;
- final Ast.Pat pat2 =
- deducePatType(env2, scan.pat, termMap1, null, v16);
- TypeEnv env4 = env2;
- for (Map.Entry e : termMap1.entrySet()) {
- env4 = env4.bind(e.getKey().name, e.getValue());
- fieldVars.put(ast.id(Pos.ZERO, e.getKey().name),
- (Unifier.Variable) e.getValue());
- }
- final Ast.Exp scanExp2 = deduceType(env4, scanExp, v15);
- final Ast.Exp scanExp3 = ast.fromSuchThat(scanExp2);
- reg(scanExp, v15, toTerm(PrimitiveType.BOOL));
- final Ast.Exp scanCondition2;
- if (scan.condition != null) {
- final Unifier.Variable v5 = unifier.variable();
- scanCondition2 = deduceType(env4, scan.condition, v5);
- equiv(v5, toTerm(PrimitiveType.BOOL));
- } else {
- scanCondition2 = null;
- }
- fromSteps.add(scan.copy(pat2, scanExp3, scanCondition2));
- return Pair.of(env4, v);
-
- case FROM_EQ:
eq = true;
- scanExp = ((Ast.PrefixCall) scan.exp).a;
- break;
-
- default:
- eq = false;
+ final Ast.Exp scanExp2 = deduceType(env2, scanExp, v15);
+ scanExp3 = ast.fromEq(scanExp2);
+ } else {
scanExp = scan.exp;
- break;
+ eq = false;
+ scanExp3 = deduceType(env2, scanExp, v15);
}
- final Ast.Exp scanExp2 = deduceType(env2, scanExp, v15);
- final Ast.Exp scanExp3 = eq ? ast.fromEq(scanExp2) : scanExp2;
final Ast.Pat pat2 =
deducePatType(env2, scan.pat, termMap1, null, v16);
- reg(scanExp, v15, eq ? v16 : unifier.apply(LIST_TY_CON, v16));
+ if (scanExp != null) {
+ reg(scanExp, v15, eq ? v16 : unifier.apply(LIST_TY_CON, v16));
+ }
TypeEnv env4 = env2;
for (Map.Entry e : termMap1.entrySet()) {
env4 = env4.bind(e.getKey().name, e.getValue());
diff --git a/src/main/java/net/hydromatic/morel/eval/Codes.java b/src/main/java/net/hydromatic/morel/eval/Codes.java
index 5a14badf7..cf2bfe97a 100644
--- a/src/main/java/net/hydromatic/morel/eval/Codes.java
+++ b/src/main/java/net/hydromatic/morel/eval/Codes.java
@@ -2663,7 +2663,10 @@ private static Applicable vectorFindi(Applicable f) {
new ApplicableImpl(BuiltIn.Z_EXTENT) {
@Override public List apply(EvalEnv env, Object arg) {
final RangeExtent rangeExtent = (RangeExtent) arg;
- return Lists.newArrayList(rangeExtent.toIterable());
+ if (rangeExtent.iterable == null) {
+ throw new AssertionError("infinite: " + rangeExtent);
+ }
+ return ImmutableList.copyOf(rangeExtent.iterable);
}
};
diff --git a/src/main/java/net/hydromatic/morel/foreign/Converters.java b/src/main/java/net/hydromatic/morel/foreign/Converters.java
index f94a0058b..628686326 100644
--- a/src/main/java/net/hydromatic/morel/foreign/Converters.java
+++ b/src/main/java/net/hydromatic/morel/foreign/Converters.java
@@ -71,7 +71,7 @@ public static Converter ofRow(RelDataType rowType) {
public static Converter ofRow2(RelDataType rowType,
RecordLikeType type) {
return ofRow3(rowType.getFieldList().iterator(),
- new AtomicInteger(), Linq4j.enumerator(type.argNameTypes().values()));
+ new AtomicInteger(), Linq4j.enumerator(type.argTypes()));
}
static Converter ofRow3(Iterator fields,
diff --git a/src/main/java/net/hydromatic/morel/type/BaseType.java b/src/main/java/net/hydromatic/morel/type/BaseType.java
index 17019a773..7301db251 100644
--- a/src/main/java/net/hydromatic/morel/type/BaseType.java
+++ b/src/main/java/net/hydromatic/morel/type/BaseType.java
@@ -37,6 +37,16 @@ public Op op() {
@Override public String toString() {
return key().toString();
}
+
+ @Override public boolean equals(Object o) {
+ return this == o
+ || o instanceof BaseType
+ && key().equals(((BaseType) o).key());
+ }
+
+ @Override public int hashCode() {
+ return key().hashCode();
+ }
}
// End BaseType.java
diff --git a/src/main/java/net/hydromatic/morel/type/DummyType.java b/src/main/java/net/hydromatic/morel/type/DummyType.java
index aca4c5513..ff9236f7b 100644
--- a/src/main/java/net/hydromatic/morel/type/DummyType.java
+++ b/src/main/java/net/hydromatic/morel/type/DummyType.java
@@ -33,7 +33,7 @@ public Key key() {
}
public Op op() {
- return Op.NAMED_TYPE;
+ return Op.DUMMY_TYPE;
}
public R accept(TypeVisitor typeVisitor) {
diff --git a/src/main/java/net/hydromatic/morel/type/Keys.java b/src/main/java/net/hydromatic/morel/type/Keys.java
index 168dabb44..00f0045a4 100644
--- a/src/main/java/net/hydromatic/morel/type/Keys.java
+++ b/src/main/java/net/hydromatic/morel/type/Keys.java
@@ -266,7 +266,7 @@ private static class ApplyKey extends Type.Key {
final Type.Key key;
final ImmutableList args;
- ApplyKey(Type.Key key, ImmutableList args) {
+ ApplyKey(Type.Key key, List args) {
super(Op.APPLY_TYPE);
this.key = requireNonNull(key);
this.args = ImmutableList.copyOf(args);
diff --git a/src/main/java/net/hydromatic/morel/type/PrimitiveType.java b/src/main/java/net/hydromatic/morel/type/PrimitiveType.java
index b40048b12..e0097d02b 100644
--- a/src/main/java/net/hydromatic/morel/type/PrimitiveType.java
+++ b/src/main/java/net/hydromatic/morel/type/PrimitiveType.java
@@ -59,10 +59,15 @@ public enum PrimitiveType implements RecordLikeType {
return Op.ID;
}
+
public R accept(TypeVisitor typeVisitor) {
return typeVisitor.visit(this);
}
+ @Override public boolean isFinite() {
+ return this == BOOL || this == UNIT;
+ }
+
@Override public PrimitiveType copy(TypeSystem typeSystem,
UnaryOperator transform) {
return this;
diff --git a/src/main/java/net/hydromatic/morel/type/RangeExtent.java b/src/main/java/net/hydromatic/morel/type/RangeExtent.java
index d7fdf674b..4bd949717 100644
--- a/src/main/java/net/hydromatic/morel/type/RangeExtent.java
+++ b/src/main/java/net/hydromatic/morel/type/RangeExtent.java
@@ -18,193 +18,196 @@
*/
package net.hydromatic.morel.type;
-import com.google.common.collect.ContiguousSet;
-import com.google.common.collect.DiscreteDomain;
-import com.google.common.collect.ImmutableList;
+import net.hydromatic.morel.ast.Op;
+
+import com.google.common.collect.BoundType;
+import com.google.common.collect.ImmutableMap;
import com.google.common.collect.ImmutableRangeSet;
-import com.google.common.collect.Iterables;
+import com.google.common.collect.Lists;
+import com.google.common.collect.Maps;
import com.google.common.collect.Range;
import com.google.common.collect.RangeSet;
import org.apache.calcite.runtime.FlatLists;
-import org.apache.calcite.util.RangeSets;
+import org.apache.calcite.runtime.Unit;
+import org.checkerframework.checker.nullness.qual.Nullable;
import java.math.BigDecimal;
import java.util.ArrayList;
import java.util.List;
-import java.util.stream.Collectors;
-import javax.annotation.CheckForNull;
+import java.util.Map;
+import java.util.function.Consumer;
/** A type and a range set. */
-@SuppressWarnings("UnstableApiUsage")
+@SuppressWarnings("rawtypes")
public class RangeExtent {
- public final RangeSet rangeSet;
+ /** Map from path to range set.
+ *
+ * The path designates the item within the type.
+ *
+ *
For example, consider the type {@code int option list}.
+ *
+ *
+ * - "/" relates to the {@code int option list}
+ *
- "/0/" relates to each {@code int option} within the list
+ *
- "/0/SOME/" relates to each {@code int} within a "SOME" element of the
+ * list
+ *
- "/0/NONE/" relates to each "NONE" element of the list
+ *
+ *
+ * Using a map {@code ["/O/SOME/" "[0, 3], [6]"]} we can generate
+ * {@code SOME 0, SOME 1, SOME 2, SOME 3, SOME 6, NONE}
+ */
+ public final Map rangeSetMap;
public final Type type;
- private final Iterable iterable;
-
- private static final List BOOLEANS = ImmutableList.of(false, true);
+ public final @Nullable Iterable iterable;
/** Creates a RangeExtent. */
- public RangeExtent(RangeSet rangeSet, Type type) {
- this.rangeSet = ImmutableRangeSet.copyOf(rangeSet);
+ @SuppressWarnings("unchecked")
+ public RangeExtent(TypeSystem typeSystem, Type type,
+ Map rangeSetMap) {
+ this.rangeSetMap =
+ ImmutableMap.copyOf(
+ Maps.transformValues(rangeSetMap,
+ r -> ImmutableRangeSet.copyOf(r)));
this.type = type;
- this.iterable = toIterable(type, rangeSet);
+ this.iterable = toList(type, typeSystem);
}
@Override public String toString() {
- return type + " " + rangeSet;
+ if (isUnbounded()) {
+ return type.toString(); // range set is unconstrained; don't print it
+ }
+ return type + " " + rangeSetMap;
}
- /** Returns the collection of values in the range. */
- @SuppressWarnings("unchecked")
- public Iterable toIterable() {
- return iterable;
+ /** Whether this extent returns all, or an unbounded number of, the values of
+ * its type.
+ *
+ * Examples:
+ * "(-inf,+inf)" (true),
+ * "(-inf,0]" (x ≤ 0),
+ * "{(-inf,3),(10,+inf)}" (x < 3 or x > 10) are unbounded;
+ * "{}" (false),
+ * "{3, 10}" (x in [3, 10]),
+ * "(3, 10)" (x ≥ 3 andalso x ≤ 10) are bounded. */
+ public boolean isUnbounded() {
+ return rangeSetMap.isEmpty();
}
- /** Returns the collection of values in the range. */
- @SuppressWarnings("unchecked")
- private Iterable toIterable(Type type, RangeSet rangeSet) {
- final List> setList = new ArrayList<>();
- rangeSet.asRanges()
- .forEach(range -> setList.add(toIterable(type, range)));
- return concat(setList);
+ /** Derives the collection of values in the range, or returns empty if
+ * the range is infinite. */
+ private > Iterable toList(Type type,
+ TypeSystem typeSystem) {
+ final List list = new ArrayList<>();
+ if (populate(typeSystem, type, "/", rangeSetMap, (Consumer) list::add)) {
+ return list;
+ }
+ return null;
}
- /** Returns the collection of values in the range. */
+ /** Populates a list (or other consumer) with all values of this type. Returns
+ * false if this type is not finite and the range is open above or below. */
@SuppressWarnings("unchecked")
- private Iterable toIterable(Type type, Range range) {
+ private > boolean populate(TypeSystem typeSystem,
+ Type type, String path, Map rangeSetMap,
+ Consumer consumer) {
+ final RangeSet rangeSet = rangeSetMap.get(path);
+ final Consumer filteredConsumer;
+ if (rangeSet != null) {
+ filteredConsumer = e -> {
+ if (rangeSet.contains(e)) {
+ consumer.accept(e);
+ }
+ };
+ } else {
+ filteredConsumer = consumer;
+ }
switch (type.op()) {
case ID:
- final PrimitiveType primitiveType = (PrimitiveType) type;
- switch (primitiveType) {
- case INT:
- return ContiguousSet.create(
- RangeSets.copy(range, BigDecimal::intValue),
- DiscreteDomain.integers());
-
+ switch ((PrimitiveType) type) {
case BOOL:
- return Iterables.filter(BOOLEANS, b -> range.contains(b));
- }
- break;
+ filteredConsumer.accept((E) Boolean.FALSE);
+ filteredConsumer.accept((E) Boolean.TRUE);
+ return true;
- case TUPLE_TYPE:
- final TupleType tupleType = (TupleType) type;
- // TODO: copy rangeSet, to convert embedded BigDecimal to Integer
- return ContiguousSet.create(range, discreteDomain(tupleType));
- }
- throw new AssertionError("cannot iterate type '" + type + "'");
- }
+ case UNIT:
+ filteredConsumer.accept((E) Unit.INSTANCE);
+ return true;
- private DiscreteDomain discreteDomain(Type type) {
- switch (type.op()) {
- case ID:
- final PrimitiveType primitiveType = (PrimitiveType) type;
- switch (primitiveType) {
- case BOOL:
- return new BooleanDiscreteDomain();
+ case CHAR:
+ for (int i = 0; i < 256; i++) {
+ filteredConsumer.accept((E) Character.valueOf((char) i));
+ }
+ return true;
case INT:
- return DiscreteDomain.integers();
+ if (rangeSet != null) {
+ for (Range range : rangeSet.asRanges()) {
+ if (!range.hasLowerBound() || !range.hasUpperBound()) {
+ return false;
+ }
+ final int lower =
+ ((BigDecimal) range.lowerEndpoint()).intValue()
+ + (range.lowerBoundType() == BoundType.OPEN ? 1 : 0);
+ final int upper =
+ ((BigDecimal) range.upperEndpoint()).intValue()
+ - (range.upperBoundType() == BoundType.OPEN ? 1 : 0);
+ for (int i = lower; i <= upper; i++) {
+ consumer.accept((E) Integer.valueOf(i));
+ }
+ }
+ return true;
+ }
+ // fall through
}
- break;
-
- case TUPLE_TYPE:
- final List> domains = new ArrayList<>();
- final TupleType tupleType = (TupleType) type;
- tupleType.argTypes.forEach(t -> domains.add(discreteDomain(t)));
- return new ProductDiscreteDomain(domains);
- }
-
- throw new AssertionError("cannot convert type '" + type
- + "' to discrete domain");
- }
-
- /** Calls {@link Iterables#concat(Iterable)}, optimizing for the case with 0
- * or 1 entries. */
- private static Iterable concat(
- List> iterableList) {
- switch (iterableList.size()) {
- case 0:
- return ImmutableList.of();
- case 1:
- return iterableList.get(0);
- default:
- return Iterables.concat(iterableList);
- }
- }
-
- private static class BooleanDiscreteDomain extends DiscreteDomain {
- @CheckForNull
- @Override public Boolean next(Boolean value) {
- return value ? null : true;
- }
-
- @CheckForNull @Override public Boolean previous(Boolean value) {
- return value ? false : null;
- }
-
- @Override public long distance(Boolean start, Boolean end) {
- return (end == (boolean) start) ? 0 : (end ? 1 : -1);
- }
-
- @Override public Boolean minValue() {
return false;
- }
- @Override public Boolean maxValue() {
+ case DUMMY_TYPE:
+ assert type == DummyType.INSTANCE;
+ filteredConsumer.accept((E) Unit.INSTANCE);
return true;
- }
- }
- private static class ProductDiscreteDomain
- extends DiscreteDomain> {
- private final List domains;
- private final FlatLists.ComparableList minValue;
- private final FlatLists.ComparableList