adds support for select stm as insert rows (#258)

Author: cmoog

internal/mysql/parse.go

@@ -309,38 +309,46 @@ func parseUpdate(node *sqlparser.Update, query string, s *Schema, settings dinos
 }
 
 func parseInsert(node *sqlparser.Insert, query string, s *Schema, settings dinosql.GenerateSettings) (*Query, error) {
+	params := []*Param{}
 	cols := node.Columns
 	tableName := node.Table.Name.String()
-	rows, ok := node.Rows.(sqlparser.Values)
-	if !ok {
-		return nil, fmt.Errorf("Unknown insert row type of %T", node.Rows)
-	}
 
-	params := []*Param{}
-
-	for _, row := range rows {
-		for colIx, item := range row {
-			switch v := item.(type) {
-			case *sqlparser.SQLVal:
-				if v.Type == sqlparser.ValArg {
-					colName := cols[colIx].String()
-					colDfn, err := s.schemaLookup(tableName, colName)
-					varName := string(v.Val)
-					p := &Param{OriginalName: varName}
-					if err == nil {
-						p.Name = paramName(colDfn.Name, varName)
-						p.Typ = goTypeCol(colDfn, settings)
-					} else {
-						p.Name = "Unknown"
-						p.Typ = "interface{}"
+	switch rows := node.Rows.(type) {
+	case *sqlparser.Select:
+		selectQuery, err := parseSelect(rows, query, s, settings)
+		if err != nil {
+			return nil, err
+		}
+		params = append(params, selectQuery.Params...)
+	case sqlparser.Values:
+		for _, row := range rows {
+			for colIx, item := range row {
+				switch v := item.(type) {
+				case *sqlparser.SQLVal:
+					if v.Type == sqlparser.ValArg {
+						colName := cols[colIx].String()
+						colDfn, err := s.schemaLookup(tableName, colName)
+						varName := string(v.Val)
+						p := &Param{OriginalName: varName}
+						if err == nil {
+							p.Name = paramName(colDfn.Name, varName)
+							p.Typ = goTypeCol(colDfn, settings)
+						} else {
+							p.Name = "Unknown"
+							p.Typ = "interface{}"
+						}
+						params = append(params, p)
 					}
-					params = append(params, p)
+
+				default:
+					panic("Error occurred in parsing INSERT statement")
 				}
-			default:
-				panic("Error occurred in parsing INSERT statement")
 			}
 		}
+	default:
+		return nil, fmt.Errorf("Unknown insert row type of %T", node.Rows)
 	}
+
 	parsedQuery := &Query{
 		SQL:              query,
 		Params:           params,

internal/mysql/parse_test.go

@@ -355,16 +355,12 @@ func TestParseInsertUpdate(t *testing.T) {
 		input  expected
 		output *Query
 	}
-	query1 := `/* name: InsertNewUser :exec */
-INSERT INTO users (first_name, last_name) VALUES (?, ?)`
-	query2 := `/* name: UpdateUserAt :exec */
-UPDATE users SET first_name = ?, last_name = ? WHERE id > ? AND first_name = ? LIMIT 3`
 
 	tests := []testCase{
 		testCase{
 			name: "insert_users",
 			input: expected{
-				query:  query1,
+				query:  "/* name: InsertNewUser :exec */\nINSERT INTO users (first_name, last_name) VALUES (?, ?)",
 				schema: mockSchema,
 			},
 			output: &Query{
@@ -407,7 +403,7 @@ UPDATE users SET first_name = ?, last_name = ? WHERE id > ? AND first_name = ? L
 		testCase{
 			name: "update_users",
 			input: expected{
-				query:  query2,
+				query:  "/* name: UpdateUserAt :exec */\nUPDATE users SET first_name = ?, last_name = ? WHERE id > ? AND first_name = ? LIMIT 3",
 				schema: mockSchema,
 			},
 			output: &Query{
@@ -441,6 +437,28 @@ UPDATE users SET first_name = ?, last_name = ? WHERE id > ? AND first_name = ? L
 				SchemaLookup:     mockSchema,
 			},
 		},
+		testCase{
+			name: "insert_users_from_orders",
+			input: expected{
+				query:  "/* name: InsertUsersFromOrders :exec */\ninsert into users ( first_name ) select user_id from orders where id = ?;",
+				schema: mockSchema,
+			},
+			output: &Query{
+				SQL:     "insert into users(first_name) select user_id from orders where id = ?",
+				Columns: nil,
+				Params: []*Param{
+					&Param{
+						OriginalName: ":v1",
+						Name:         "id",
+						Typ:          "int",
+					},
+				},
+				Name:             "InsertUsersFromOrders",
+				Cmd:              ":exec",
+				DefaultTableName: "users",
+				SchemaLookup:     mockSchema,
+			},
+		},
 	}
 
 	for _, tt := range tests {