Method scalarSubqueryCheck

compiler/semantic/expr.go:1315–1361

(n ast.Node, seq sem.Seq, thisType super.Type)

}

func (t *translator) scalarSubqueryCheck(n ast.Node, seq sem.Seq, thisType super.Type) (sem.Seq, super.Type) {
	// In a SQL expression (except for RHS of EXISTS or IN, which both use array result),
	// a subquery returns a scalar but the result of the subquery is a relation.
	// The runtime already checks if the subquery returns multiple "rows", so
	// here we just check if the relation is a single column and error appropriately
	// or otherwise pull out the value to make the scalar.
	// values is_error(this) ? this : (len(this) == 1 ? this[1] : error(...) )
	lenCall := &sem.CallExpr{
		Node: n,
		Tag:  "len",
		Args: []sem.Expr{sem.NewThis(n, nil)},
	}
	lenCond := &sem.BinaryExpr{
		Node: n,
		Op:   "==",
		LHS:  lenCall,
		RHS:  sem.NewLiteral(n, super.NewInt64(1)),
	}
	// Note no need to check index_base here since we are directly
	// creating the underlying index expression.
	indexExpr := &sem.IndexExpr{
		Node:  n,
		Expr:  sem.NewThis(n, nil),
		Index: sem.NewLiteral(n, super.NewInt64(0)),
	}
	innerCond := &sem.CondExpr{
		Node: n,
		Cond: lenCond,
		Then: indexExpr,
		Else: sem.NewStructuredError(n, "subquery expression cannot have multiple columns", sem.NewThis(n, nil)),
	}
	isErrCond := &sem.CallExpr{
		Node: n,
		Tag:  "is_error",
		Args: []sem.Expr{sem.NewThis(n, nil)},
	}
	outerCond := &sem.CondExpr{
		Node: n,
		Cond: isErrCond,
		Then: sem.NewThis(n, nil),
		Else: innerCond,
	}
	return append(seq, &sem.ValuesOp{
		Node:  n,
		Exprs: []sem.Expr{outerCond},
	}), t.checker.expr(thisType, outerCond)
}

func isCorrelated(seq sem.Seq) bool {
	if len(seq) >= 1 {