join table functions (#1405)

* join table functions

* fix todo

enginetest/engine_only_test.go

@@ -721,7 +721,7 @@ func (s SimpleTableFunction) WithDatabase(_ sql.Database) (sql.Node, error) {
 	return s, nil
 }
 
-func (s SimpleTableFunction) FunctionName() string {
+func (s SimpleTableFunction) Name() string {
 	return "simple_table_function"
 }
 
@@ -758,7 +758,7 @@ type TestProvider struct {
 func NewTestProvider(dbProvider *sql.MutableDatabaseProvider, tf sql.TableFunction) *TestProvider {
 	return &TestProvider{
 		*dbProvider,
-		map[string]sql.TableFunction{strings.ToLower(tf.FunctionName()): tf},
+		map[string]sql.TableFunction{strings.ToLower(tf.Name()): tf},
 	}
 }
 

sql/analyzer/coster.go

@@ -51,6 +51,8 @@ func (c *coster) costRel(n relExpr) (float64, error) {
 		return c.costAntiJoin(n)
 	case *subqueryAlias:
 		return c.costSubqueryAlias(n)
+	case *tableFunc:
+		return c.costTableFunc(n)
 	case *fullOuterJoin:
 		return c.costFullOuterJoin(n)
 	case *concatJoin:
@@ -190,7 +192,12 @@ func (c *coster) costSemiJoin(n *semiJoin) (float64, error) {
 	return l, nil
 }
 
-func (c *coster) costSubqueryAlias(n *subqueryAlias) (float64, error) {
+func (c *coster) costSubqueryAlias(_ *subqueryAlias) (float64, error) {
 	// TODO: if the whole plan was memo, we would have accurate costs for subqueries
 	return 10000, nil
 }
+
+func (c *coster) costTableFunc(_ *tableFunc) (float64, error) {
+	// TODO: sql.TableFunction should expose RowCount()
+	return 10, nil
+}

sql/analyzer/exec_builder.go

@@ -201,6 +201,10 @@ func (b *ExecBuilder) buildSubqueryAlias(r *subqueryAlias, input sql.Schema, chi
 	return r.table, nil
 }
 
+func (b *ExecBuilder) buildTableFunc(r *tableFunc, input sql.Schema, children ...sql.Node) (sql.Node, error) {
+	return r.table, nil
+}
+
 func (b *ExecBuilder) buildRecursiveCte(r *recursiveCte, input sql.Schema, children ...sql.Node) (sql.Node, error) {
 	return r.table, nil
 }

sql/analyzer/join_order_builder.go

@@ -231,6 +231,8 @@ func (j *joinOrderBuilder) buildJoinLeaf(n sql.Nameable) *exprGroup {
 		rel = &tableScan{relBase: b, table: n.ResolvedTable}
 	case *plan.ValueDerivedTable:
 		rel = &values{relBase: b, table: n}
+	case sql.TableFunction:
+		rel = &tableFunc{relBase: b, table: n}
 	default:
 		panic(fmt.Sprintf("unrecognized join leaf: %T", n))
 	}

sql/analyzer/resolve_functions.go

@@ -37,7 +37,7 @@ func resolveTableFunctions(ctx *sql.Context, a *Analyzer, n sql.Node, _ *Scope,
 			return n, transform.SameTree, nil
 		}
 
-		tableFunction, err := a.Catalog.TableFunction(ctx, utf.FunctionName())
+		tableFunction, err := a.Catalog.TableFunction(ctx, utf.Name())
 		if err != nil {
 			return nil, transform.SameTree, err
 		}

sql/core.go

@@ -352,11 +352,10 @@ type TableFunction interface {
 	Node
 	Expressioner
 	Databaser
+	Nameable
 
 	// NewInstance returns a new instance of the table function
 	NewInstance(ctx *Context, db Database, expressions []Expression) (Node, error)
-	// FunctionName returns the name of this table function
-	FunctionName() string
 }
 
 // Table represents the backend of a SQL table.

sql/expression/unresolved.go

@@ -137,8 +137,8 @@ func (utf *UnresolvedTableFunction) WithDatabase(database sql.Database) (sql.Nod
 	return utf, nil
 }
 
-// FunctionName implements the TableFunction interface
-func (utf *UnresolvedTableFunction) FunctionName() string {
+// Name implements the TableFunction interface
+func (utf *UnresolvedTableFunction) Name() string {
 	return utf.name
 }