Method sqlTableExpr

compiler/semantic/op.go:115–176

(e ast.SQLTableExpr, seq sem.Seq)

}

func (t *translator) sqlTableExpr(e ast.SQLTableExpr, seq sem.Seq) (sem.Seq, relScope) {
	switch e := e.(type) {
	case *ast.SQLFromItem:
		if e.Ordinality != nil {
			t.error(e.Ordinality, errors.New("WITH ORDINALITY clause is not yet supported"))
			return seq, badTable
		}
		alias := e.Alias
		switch input := e.Input.(type) {
		case *ast.FromItem:
			var table relTable
			if c, name := t.maybeCTE(input.Source); c != nil {
				if bad := t.hasFromParent(input, seq); bad != nil {
					return bad, badTable
				}
				if len(input.Args) != 0 {
					t.error(input, fmt.Errorf("CTE cannot use operator arguments"))
					return seq, badTable
				}
				if alias == nil {
					alias = c.Name
				}
				seq, table = t.fromCTE(input, c)
			} else {
				if _, ok := input.Source.(*ast.FromEval); !ok {
					if bad := t.hasFromParent(e, seq); bad != nil {
						return bad, badTable
					}
				}
				var typ super.Type
				seq, typ, name = t.fromSource(input.Source, input.Args, seq)
				table = newTableFromType(typ, t.checker.unknown)
				if _, ok := table.(*dynamicTable); !ok && alias == nil {
					alias = &ast.TableAlias{Name: name, Loc: input.Loc}
				}
			}
			if table == badTable {
				return seq, badTable
			}
			seq, table, err := applyAlias(t.sctx, alias, table, seq)
			if err != nil {
				t.error(alias, err)
			}
			return seq, table
		case *ast.SQLPipe:
			seq, sch := t.sqlFromPipe(input, seq)
			seq, sch, err := applyAlias(t.sctx, alias, sch, seq)
			if err != nil {
				t.error(alias, err)
			}
			return seq, sch
		default:
			panic(input)
		}
	case *ast.SQLJoin:
		return t.sqlJoin(e, seq)
	case *ast.SQLCrossJoin:
		return t.sqlCrossJoin(e, seq)