99 lines
2.1 KiB
Go
99 lines
2.1 KiB
Go
package influxql
|
|
|
|
import (
|
|
"fmt"
|
|
|
|
"github.com/influxdata/flux/ast"
|
|
"github.com/influxdata/influxql"
|
|
)
|
|
|
|
type joinCursor struct {
|
|
expr ast.Expression
|
|
m map[influxql.Expr]string
|
|
exprs []influxql.Expr
|
|
}
|
|
|
|
func Join(t *transpilerState, cursors []cursor, on []string) cursor {
|
|
if len(cursors) == 1 {
|
|
return cursors[0]
|
|
}
|
|
|
|
// Iterate through each cursor and each expression within each cursor to assign them an id.
|
|
var exprs []influxql.Expr
|
|
m := make(map[influxql.Expr]string)
|
|
tables := make([]*ast.Property, 0, len(cursors))
|
|
for _, cur := range cursors {
|
|
// Perform a variable assignment and use it for the table name.
|
|
ident := t.assignment(cur.Expr())
|
|
tableName := ident.Name
|
|
tables = append(tables, &ast.Property{
|
|
Key: ident,
|
|
Value: &ast.Identifier{
|
|
Name: ident.Name,
|
|
},
|
|
})
|
|
for _, k := range cur.Keys() {
|
|
// Combine the table name with the name to access this attribute so we can know
|
|
// what it will be mapped to.
|
|
varName, _ := cur.Value(k)
|
|
name := fmt.Sprintf("%s_%s", tableName, varName)
|
|
exprs = append(exprs, k)
|
|
m[k] = name
|
|
}
|
|
}
|
|
|
|
// Construct the expression for the on parameter.
|
|
onExpr := make([]ast.Expression, 0, len(on))
|
|
for _, name := range on {
|
|
onExpr = append(onExpr, &ast.StringLiteral{
|
|
Value: name,
|
|
})
|
|
}
|
|
|
|
expr := &ast.CallExpression{
|
|
Callee: &ast.Identifier{
|
|
Name: "join",
|
|
},
|
|
Arguments: []ast.Expression{
|
|
&ast.ObjectExpression{
|
|
Properties: []*ast.Property{
|
|
{
|
|
Key: &ast.Identifier{Name: "tables"},
|
|
Value: &ast.ObjectExpression{
|
|
Properties: tables,
|
|
},
|
|
},
|
|
{
|
|
Key: &ast.Identifier{Name: "on"},
|
|
Value: &ast.ArrayExpression{
|
|
Elements: onExpr,
|
|
},
|
|
},
|
|
},
|
|
},
|
|
},
|
|
}
|
|
return &joinCursor{
|
|
expr: expr,
|
|
m: m,
|
|
exprs: exprs,
|
|
}
|
|
}
|
|
|
|
func (c *joinCursor) Expr() ast.Expression {
|
|
return c.expr
|
|
}
|
|
|
|
func (c *joinCursor) Keys() []influxql.Expr {
|
|
keys := make([]influxql.Expr, 0, len(c.m))
|
|
for k := range c.m {
|
|
keys = append(keys, k)
|
|
}
|
|
return keys
|
|
}
|
|
|
|
func (c *joinCursor) Value(expr influxql.Expr) (string, bool) {
|
|
value, ok := c.m[expr]
|
|
return value, ok
|
|
}
|