feat(sql): support wildcard with other selects

internal/topo/operator/project_test.go

@@ -582,6 +582,29 @@ func TestProjectPlan_Apply1(t *testing.T) {
 				"b": "true",
 			}},
 		},
+		//35
+		{
+			sql: `SELECT a->b AS ab, *, abs(f1) FROM test`,
+			data: &xsql.Tuple{
+				Emitter: "test",
+				Message: xsql.Message{
+					"a": map[string]interface{}{
+						"b": "test",
+					},
+					"b":  "b",
+					"f1": -12,
+				},
+			},
+			result: []map[string]interface{}{{
+				"a": map[string]interface{}{
+					"b": "test",
+				},
+				"ab":  "test",
+				"abs": 12,
+				"b":   "b",
+				"f1":  -12,
+			}},
+		},
 	}
 
 	fmt.Printf("The test bucket size is %d.\n\n", len(tests))

internal/topo/planner/planner_test.go

@@ -416,7 +416,7 @@ func Test_createLogicalPlan(t *testing.T) {
 				fields: []ast.Field{
 					{
 						Expr:  &ast.Wildcard{Token: ast.ASTERISK},
-						Name:  "",
+						Name:  "*",
 						AName: ""},
 				},
 				isAggregate: false,
@@ -1182,6 +1182,68 @@ func Test_createLogicalPlan(t *testing.T) {
 				sendMeta:    false,
 			}.Init(),
 		},
+		{ // 14
+			sql: `SELECT name, *, meta(device) FROM src1`,
+			p: ProjectPlan{
+				baseLogicalPlan: baseLogicalPlan{
+					children: []LogicalPlan{
+						DataSourcePlan{
+							baseLogicalPlan: baseLogicalPlan{},
+							name:            "src1",
+							streamFields: []interface{}{
+								&ast.StreamField{
+									Name:      "id1",
+									FieldType: &ast.BasicType{Type: ast.BIGINT},
+								},
+								&ast.StreamField{
+									Name:      "temp",
+									FieldType: &ast.BasicType{Type: ast.BIGINT},
+								},
+								&ast.StreamField{
+									Name:      "name",
+									FieldType: &ast.BasicType{Type: ast.STRINGS},
+								},
+								&ast.StreamField{
+									Name:      "myarray",
+									FieldType: &ast.ArrayType{Type: ast.STRINGS},
+								},
+							},
+							streamStmt: streams["src1"],
+							metaFields: []string{"device"},
+							isWildCard: true,
+						}.Init(),
+					},
+				},
+				fields: []ast.Field{
+					{
+						Expr:  &ast.FieldRef{Name: "name", StreamName: "src1"},
+						Name:  "name",
+						AName: "",
+					},
+					{
+						Name: "*",
+						Expr: &ast.Wildcard{
+							Token: ast.ASTERISK,
+						},
+					},
+					{
+						Name: "meta",
+						Expr: &ast.Call{
+							Name: "meta",
+							Args: []ast.Expr{
+								&ast.MetaRef{
+									StreamName: ast.DefaultStream,
+									Name:       "device",
+								},
+							},
+						},
+					},
+				},
+				isAggregate: false,
+				allWildcard: true,
+				sendMeta:    false,
+			}.Init(),
+		},
 	}
 	fmt.Printf("The test bucket size is %d.\n\n", len(tests))
 
@@ -1520,7 +1582,7 @@ func Test_createLogicalPlanSchemaless(t *testing.T) {
 				fields: []ast.Field{
 					{
 						Expr:  &ast.Wildcard{Token: ast.ASTERISK},
-						Name:  "",
+						Name:  "*",
 						AName: ""},
 				},
 				isAggregate: false,
@@ -2600,7 +2662,7 @@ func Test_createLogicalPlan4Lookup(t *testing.T) {
 				fields: []ast.Field{
 					{
 						Expr:  &ast.Wildcard{Token: ast.ASTERISK},
-						Name:  "",
+						Name:  "*",
 						AName: "",
 					},
 				},

internal/topo/topotest/rule_test.go

@@ -29,32 +29,37 @@ func TestSingleSQL(t *testing.T) {
 	var tests = []RuleTest{
 		{
 			Name: `TestSingleSQLRule1`,
-			Sql:  `SELECT * FROM demo`,
+			Sql:  `SELECT *, upper(color) FROM demo`,
 			R: [][]map[string]interface{}{
 				{{
 					"color": "red",
 					"size":  float64(3),
 					"ts":    float64(1541152486013),
+					"upper": "RED",
 				}},
 				{{
 					"color": "blue",
 					"size":  float64(6),
 					"ts":    float64(1541152486822),
+					"upper": "BLUE",
 				}},
 				{{
 					"color": "blue",
 					"size":  float64(2),
 					"ts":    float64(1541152487632),
+					"upper": "BLUE",
 				}},
 				{{
 					"color": "yellow",
 					"size":  float64(4),
 					"ts":    float64(1541152488442),
+					"upper": "YELLOW",
 				}},
 				{{
 					"color": "red",
 					"size":  float64(1),
 					"ts":    float64(1541152489252),
+					"upper": "RED",
 				}},
 			},
 			M: map[string]interface{}{

internal/xsql/parser.go

@@ -411,13 +411,6 @@ func (p *Parser) parseSorts() (ast.SortFields, error) {
 func (p *Parser) parseFields() (ast.Fields, error) {
 	var fields ast.Fields
 
-	tok, _ := p.scanIgnoreWhitespace()
-	if tok == ast.ASTERISK {
-		fields = append(fields, ast.Field{AName: "", Expr: &ast.Wildcard{Token: tok}})
-		return fields, nil
-	}
-	p.unscan()
-
 	for {
 		field, err := p.parseField()
 
@@ -427,7 +420,7 @@ func (p *Parser) parseFields() (ast.Fields, error) {
 			fields = append(fields, *field)
 		}
 
-		tok, _ = p.scanIgnoreWhitespace()
+		tok, _ := p.scanIgnoreWhitespace()
 		if tok != ast.COMMA {
 			p.unscan()
 			break
@@ -449,6 +442,9 @@ func (p *Parser) parseField() (*ast.Field, error) {
 		return nil, err
 	} else {
 		if alias != "" {
+			if field.Name == "*" {
+				return nil, fmt.Errorf("alias is not supported for *")
+			}
 			field.AName = alias
 		}
 	}
@@ -466,6 +462,8 @@ func nameExpr(exp ast.Expr) string {
 		return e.Name
 	case *ast.Call:
 		return e.Name
+	case *ast.Wildcard:
+		return ast.Tokens[ast.ASTERISK]
 	default:
 		return ""
 	}
@@ -1487,8 +1485,6 @@ func (p *Parser) parseAsterisk() (ast.Expr, error) {
 	switch p.inFunc {
 	case "mqtt", "meta":
 		return &ast.MetaRef{StreamName: ast.DefaultStream, Name: "*"}, nil
-	case "":
-		return nil, fmt.Errorf("unsupported * expression, it must be used inside fields or function parameters.")
 	default:
 		return &ast.Wildcard{Token: ast.ASTERISK}, nil
 	}