Function parseColumns

rel/parse_sql.go:876–1002

(m expr.TokenPager, fr expr.FuncResolver, stmt ColumnsStatement)

}

func parseColumns(m expr.TokenPager, fr expr.FuncResolver, stmt ColumnsStatement) error {

	var col *Column

	comment := readComment(m)

	for {

		comment += readComment(m)

		//u.Debug(m.Cur())
		switch m.Cur().T {
		case lex.TokenStar, lex.TokenMultiply:
			col = &Column{Star: true}
			m.Next()
		case lex.TokenUdfExpr:
			// we have a udf/functional expression column
			col = NewColumnFromToken(m.Cur())
			// function canoncial names are always lowercase
			funcName := strings.ToLower(m.Cur().V)
			exprNode, err := expr.ParseExprWithFuncs(m, fr)
			if err != nil {
				return err
			}
			col.Expr = exprNode
			col.SourceField = expr.FindFirstIdentity(col.Expr)
			if _, r, ok := expr.LeftRight(col.SourceField); ok {
				col.SourceField = r
			}
			if strings.Contains(col.SourceField, ".") {
				if _, right, hasLeft := expr.LeftRight(col.SourceField); hasLeft {
					col.SourceOriginal = col.SourceField
					col.SourceField = right
				}
			}

			if m.Cur().T != lex.TokenAs {
				switch n := col.Expr.(type) {
				case *expr.FuncNode:
					n.Name = funcName
					col.Agg = n.F.Aggregate
					col.As = expr.FindIdentityName(0, n, "")
					if col.As == "" {
						if n.Name == "count" {
							col.As = "count(*)"
						} else {
							col.As = n.Name
						}
					}
				case *expr.BinaryNode:
					//u.Debugf("udf? %T ", col.Expr)
					col.As = expr.FindIdentityName(0, n, "")
					if col.As == "" {
						u.Errorf("could not find as name: %#v", n)
					}
				}
			} else {
				switch n := col.Expr.(type) {