Support nested update

ast/ast.go

@@ -539,6 +539,15 @@ type InsertInput interface {
 func (ValuesInput) isInsertInput()   {}
 func (SubQueryInput) isInsertInput() {}
 
+// UpdateItem represents SET clause items in UPDATE.
+type UpdateItem interface {
+	Node
+	isUpdateItem()
+}
+
+func (UpdateItemSetValue) isUpdateItem() {}
+func (UpdateItemDML) isUpdateItem()      {}
+
 // ChangeStreamFor represents FOR clause in CREATE/ALTER CHANGE STREAM statement.
 type ChangeStreamFor interface {
 	Node
@@ -3953,7 +3962,7 @@ type Insert struct {
 
 	Hint       *Hint // optional
 	TableName  *Path
-	Columns    []*Ident
+	Columns    []*Ident // optional when nested
 	Input      InsertInput
 	ThenReturn *ThenReturn // optional
 }
@@ -4037,16 +4046,27 @@ type Update struct {
 
 	Hint       *Hint // optional
 	TableName  *Path
-	As         *AsAlias      // optional
-	Updates    []*UpdateItem // len(Updates) > 0
+	As         *AsAlias     // optional
+	Updates    []UpdateItem // len(Updates) > 0
 	Where      *Where
 	ThenReturn *ThenReturn // optional
 }
 
-// UpdateItem is SET clause items in UPDATE.
+// UpdateItemDML is nested update UpdateItem node in UPDATE statement.
+//
+//	({{.DML | sql}})
+type UpdateItemDML struct {
+	// pos = Lparen
+	// end = Rparen + 1
+
+	Lparen, Rparen token.Pos // position of "(", ")"
+	DML            DML
+}
+
+// UpdateItemSetValue is assignment style UpdateItem node in UPDATE statement .
 //
 //	{{.Path | sqlJoin "."}} = {{.DefaultExpr | sql}}
-type UpdateItem struct {
+type UpdateItemSetValue struct {
 	// pos = Path[0].pos
 	// end = DefaultExpr.end
 

ast/sql.go

@@ -1354,10 +1354,14 @@ func (u *Update) SQL() string {
 		sqlOpt(" ", u.ThenReturn, "")
 }
 
-func (u *UpdateItem) SQL() string {
+func (u *UpdateItemSetValue) SQL() string {
 	return sqlJoin(u.Path, ".") + " = " + u.DefaultExpr.SQL()
 }
 
+func (u *UpdateItemDML) SQL() string {
+	return "(" + u.DML.SQL() + ")"
+}
+
 // ================================================================================
 //
 // Procedural language

parser.go

@@ -178,7 +178,7 @@ func (p *Parser) parseStatementInternal(hint *ast.Hint) (stmt ast.Statement) {
 	case p.Token.Kind == "SELECT" || p.Token.Kind == "WITH" || p.Token.Kind == "(" || p.Token.Kind == "FROM":
 		return p.parseQueryStatementInternal(hint)
 	case p.Token.IsKeywordLike("INSERT") || p.Token.IsKeywordLike("DELETE") || p.Token.IsKeywordLike("UPDATE"):
-		return p.parseDMLInternal(hint)
+		return p.parseDMLInternal(hint, false)
 	case hint != nil:
 		panic(p.errorfAtPosition(hint.Pos(), p.Token.End, "statement hint is only permitted before query or DML, but got: %s", p.Token.Raw))
 	case p.Token.Kind == "CREATE" || p.Token.IsKeywordLike("ALTER") || p.Token.IsKeywordLike("DROP") ||
@@ -5014,6 +5014,8 @@ func (p *Parser) parseIfExists() bool {
 //
 // ================================================================================
 
+// parseDML parses non-nested DML with optional hints.
+// This function is parseStatements friendly.
 func (p *Parser) parseDML() (dml ast.DML) {
 	l := p.Lexer.Clone()
 	defer func() {
@@ -5024,10 +5026,13 @@ func (p *Parser) parseDML() (dml ast.DML) {
 	}()
 
 	hint := p.tryParseHint()
-	return p.parseDMLInternal(hint)
+	return p.parseDMLInternal(hint, false)
 }
 
-func (p *Parser) parseDMLInternal(hint *ast.Hint) (dml ast.DML) {
+// parseDMLInternal can parse nested and non-nested DML with parsed hints.
+// The behavior is controlled by nested flag.
+// Note: It is recommended to use parseDML if you want to parse a complete DML statement.
+func (p *Parser) parseDMLInternal(hint *ast.Hint, nested bool) (dml ast.DML) {
 	l := p.Lexer.Clone()
 	defer func() {
 		if r := recover(); r != nil {
@@ -5042,7 +5047,7 @@ func (p *Parser) parseDMLInternal(hint *ast.Hint) (dml ast.DML) {
 	pos := id.Pos
 	switch {
 	case id.IsKeywordLike("INSERT"):
-		return p.parseInsert(pos, hint)
+		return p.parseInsert(pos, hint, nested)
 	case id.IsKeywordLike("DELETE"):
 		return p.parseDelete(pos, hint)
 	case id.IsKeywordLike("UPDATE"):
@@ -5085,7 +5090,7 @@ func (p *Parser) tryParseThenReturn() *ast.ThenReturn {
 	}
 }
 
-func (p *Parser) parseInsert(pos token.Pos, hint *ast.Hint) *ast.Insert {
+func (p *Parser) parseInsert(pos token.Pos, hint *ast.Hint, nested bool) *ast.Insert {
 	var insertOrType ast.InsertOrType
 	if p.Token.Kind == "OR" {
 		p.nextToken()
@@ -5106,18 +5111,22 @@ func (p *Parser) parseInsert(pos token.Pos, hint *ast.Hint) *ast.Insert {
 
 	name := p.parsePath()
 
-	p.expect("(")
+	// Column list is optional only when nested update(not top-level DML).
+	// Note: There is a ambiguity between column list and parenthesized query.
 	var columns []*ast.Ident
-	if p.Token.Kind != ")" {
-		for p.Token.Kind != token.TokenEOF {
-			columns = append(columns, p.parseIdent())
-			if p.Token.Kind != "," {
-				break
+	if !nested || (p.Token.Kind == "(" && !p.lookaheadSubQuery()) {
+		p.expect("(")
+		if p.Token.Kind != ")" {
+			for p.Token.Kind != token.TokenEOF {
+				columns = append(columns, p.parseIdent())
+				if p.Token.Kind != "," {
+					break
+				}
+				p.nextToken()
 			}
-			p.nextToken()
 		}
+		p.expect(")")
 	}
-	p.expect(")")
 
 	var input ast.InsertInput
 	if p.Token.IsKeywordLike("VALUES") {
@@ -5237,12 +5246,23 @@ func (p *Parser) parseUpdate(pos token.Pos, hint *ast.Hint) *ast.Update {
 	}
 }
 
-func (p *Parser) parseUpdateItem() *ast.UpdateItem {
+func (p *Parser) parseUpdateItem() ast.UpdateItem {
+	if p.Token.Kind == "(" {
+		lparen := p.expect("(").Pos
+		dml := p.parseDMLInternal(nil, true)
+		rparen := p.expect(")").Pos
+		return &ast.UpdateItemDML{
+			Lparen: lparen,
+			Rparen: rparen,
+			DML:    dml,
+		}
+	}
+
 	path := p.parseIdentOrPath()
 	p.expect("=")
 	defaultExpr := p.parseDefaultExpr()
 
-	return &ast.UpdateItem{
+	return &ast.UpdateItemSetValue{
 		Path:        path,
 		DefaultExpr: defaultExpr,
 	}

testdata/input/dml/nested_update_delete_update_insert.sql

@@ -0,0 +1,6 @@
+UPDATE Singers s
+SET
+  (DELETE FROM s.SingerInfo.Residence r WHERE r.City = 'Seattle'),
+  (UPDATE s.Albums.Song song SET song.songtitle = 'No, This Is Rubbish' WHERE song.songtitle = 'This Is Pretty Good'),
+  (INSERT s.Albums.Song VALUES ("songtitle: 'The Second Best Song'"))
+WHERE SingerId = 3 AND s.Albums.title = 'Go! Go! Go!'

testdata/input/dml/nested_update_insert_song.sql

@@ -0,0 +1,4 @@
+UPDATE Singers s
+SET (INSERT s.AlbumInfo.Song(Song)
+     VALUES ("songtitle: 'Bonus Track', length: 180"))
+WHERE s.SingerId = 5 AND s.AlbumInfo.title = "Fire is Hot"

testdata/input/dml/nested_update_insert_song_paren_query_input.sql

@@ -0,0 +1,5 @@
+-- In nested query, column list is optional so there is ambiguity between parenthesized query input and column list.
+-- I believe Spanner hasn't yet supported this kind of query, but it can be parsed.
+UPDATE Singers s
+SET (INSERT s.AlbumInfo.Song (SELECT AS VALUE CAST("songtitle: 'The Second Best Song'" AS googlesql.example.Album.Song)))
+WHERE TRUE

testdata/input/dml/nested_update_insert_song_path.sql

@@ -0,0 +1,5 @@
+UPDATE Singers s
+SET (INSERT s.AlbumInfo.Song
+     VALUES ('''songtitle: 'Bonus Track', length:180''')),
+    s.Albums.tracks = 16
+WHERE s.SingerId = 5 and s.AlbumInfo.title = "Fire is Hot"

testdata/input/dml/nested_update_insert_string.sql

@@ -0,0 +1,4 @@
+UPDATE Singers s
+SET (INSERT s.AlbumInfo.comments
+     VALUES ("Groovy!"))
+WHERE s.SingerId = 5 AND s.AlbumInfo.title = "Fire is Hot"

testdata/input/dml/nested_update_update_nested_insert.sql

@@ -0,0 +1,6 @@
+UPDATE Singers s
+SET (UPDATE s.AlbumInfo.Song so
+    SET (INSERT INTO so.Chart
+         VALUES ("chartname: 'Galaxy Top 100', rank: 5"))
+    WHERE so.songtitle = "Bonus Track")
+WHERE s.SingerId = 5

testdata/input/dml/nested_update_update_nested_update.sql

@@ -0,0 +1,7 @@
+UPDATE Singers s
+SET (UPDATE s.AlbumInfo.Song so
+     SET (UPDATE so.Chart c
+          SET c.rank = 2
+          WHERE c.chartname = "Galaxy Top 100")
+     WHERE so.songtitle = "Bonus Track")
+WHERE s.SingerId = 5