Method sqlJoinCond

compiler/semantic/sql.go:609–648

(cond ast.JoinCond, typ super.Type)

}

func (t *translator) sqlJoinCond(cond ast.JoinCond, typ super.Type) sem.Expr {
	switch cond := cond.(type) {
	case *ast.JoinOnCond:
		e, typ := t.expr(cond.Expr, typ)
		t.checker.boolean(cond.Expr, typ)
		return e
	case *ast.JoinUsingCond:
		jsch := t.scope.sql.(*joinUsingScope).joinScope
		var exprs []sem.Expr
		for _, id := range cond.Fields {
			left, _, err := jsch.left.resolveUnqualified(id.Name)
			if err != nil {
				t.error(id, err)
				continue
			}
			if left == nil {
				t.error(id, fmt.Errorf("column %q in USING clause does not exist in left table", id.Name))
				continue
			}
			right, _, err := jsch.right.resolveUnqualified(id.Name)
			if err != nil {
				t.error(id, err)
				continue
			}
			if right == nil {
				t.error(id, fmt.Errorf("column %q in USING clause does not exist in right table", id.Name))
				continue
			}
			lhs := sem.NewThis(id, append([]string{"left"}, left...))
			rhs := sem.NewThis(id, append([]string{"right"}, right...))
			exprs = append(exprs, sem.NewBinaryExpr(id, "==", lhs, rhs))
		}
		if len(exprs) == 0 {
			return badExpr
		}
		return andUsingExprs(cond, exprs)
	default:
		panic(cond)
	}
}

func andUsingExprs(cond ast.Node, exprs []sem.Expr) sem.Expr {
	n := len(exprs)