Allow multiple yield steps in from

[julianhyde]

Allow multiple yield steps in from.

In #21 we allowed from to contain multiple group and where clauses, in any order, but yield had to come last. Since yield is analogous to the Project relational operator, it makes sense to allow it to be before and after the other operators, and repeated.

So, the grammar will change from

from fromSource1 , ... , fromSources
      (fromFilter | fromGroup | fromOrder )*
      [ yield exp ]

to

from fromSource1 , ... , fromSources
      (fromFilter | fromGroup | fromOrder | yield exp)*

But we have to impose a side condition: if the yield expression is not a record, it has to come last. This is due to language scoping rules, not relational algebra. The from clause, and each subsequent step, must bind some variable names that are visible to the next step. A yield with a record expression binds the fields of the record; a yield with a scalar expression binds nothing, so would be no way for the next step to reference the incoming element.

Example:

from e in scott.emp,
  d in scott.dept
 (* at this point, we have e and d *)
where e.deptno = d.deptno
 (* we still have e and d, because where propagates *)
group x = d.deptno compute c as count, s as sum of e.sal
 (* we now have x, c and s, because group returns its keys and aggregates *)
yield {p = x + c, q = s}
 (* we now have p and q *)
where p < 20
 (* we still have p and q, because where propagates *)
yield p / q
 (* this has to be the last step, because p / q is a scalar, and no variables are bound *)

In the Core language (classes From, FromStep and its sub-classes Where, Group, Order, Yield, all of which are inner classes of class Core) we allow similar patterns. A Yield must be the last step if its expression is not a record.

But suppose you have

from e in emp
yield e.empno + e.deptno

and you want to add another step, say yield $incomingValue$ * 2. You can do this by assigning the previous expression in to a record with a single field:

from e in emp
yield {v0 = e.empno + e.deptno}
yield v0 * 2

This technique works for other step types too (group, record-valued yield, order). We intend to use this technique in our fix for #45, to deal with the case where there are nested calls to the map function.

[julianhyde]

Fixed in 3413702.