The return of DETACHED

[elprans]

Recent changes to the semantic model and the interpretation of view declarations necessitate the return of the DETACHED keyword.

To recap, view declarations in the WITH clause are no longer interpreted as a computation of a set in a nested scope. Instead, we define the turnstile operator (:=) as the "lexical equivalence" operator. The Ident := Expr means "treat every occurrence of Ident as Expr literally, but interpret Expr using the context captured at the site of the declaration".

Essentially, views become a pure refactoring tool, and so the following query

WITH I := (SELECT Issue FILTER Issue.priority = 'High')
SELECT I

is perfectly equivalent to

(SELECT Issue FILTER Issue.priority = 'High')

This new interpretation is vital to the usefulness of views, as we now have the "nested scope must not affect outer scopes" rule, so the old "nested scope" views would be unusable in many cases.

However, the original "nested scope" interpretation was necessary to support the "detached set" case:

WITH I := Issue SELECT (I, Issue)  # Produced a Cartesian product of the Issue set with itself.

Now, WITH I := Issue SELECT (I, Issue) is perfectly equivalent to SELECT (Issue, Issue), which, obviously, would not result in a Cartesian product. This is because both the view declaration and the SELECT body are in the same scope.

So, basically, we need the DETACHED keyword back:

WITH I := DETACHED Issue SELECT (I, Issue)

The general form is DETACHED Expr, which means "interpret Expr in a completely detached scope". This is equivalent to how schema-level link computables and schema-level views are interpreted.

[elprans]

ISOLATED may be a better candidate for the name.

[elprans]

I also happen to like the explicitness of DETACHED. No matter how I refactor the query, my view expression is visibly guaranteed to not interact with any other scope.

[vpetrovykh]

OTHER may be a better alternative. It has the advantage to be clearer in the typical simple use-cases:

• U := OTHER User
• (User.name, OTHER User.name)

[vpetrovykh]

DETACHED seems to create an ad hoc schema level view. In case of being used in the WITH block, first the ad hoc view is created and then the lexical substitution takes place. Consider the following:

WITH MODULE test
   U := DETACHED User
SELECT User
FILTER User.name = U.name AND User != U;

It is important that the U refers to the same DETAHED User for the semantics of the query. So to keep things generalized and simple we can say that DETACHED "creates" a new view and "replaces" the symbols first and then := aliases are all lexically substituted. This would keep DETACHED doing the same thing in all cases and aliasing also doing the same in all cases, regardless of what is the aliased expression.