feat: support anonymous table constraint style PRIMARY KEY

ast/ast.go

@@ -426,6 +426,8 @@ type Constraint interface {
 
 func (ForeignKey) isConstraint() {}
 func (Check) isConstraint()      {}
+func (TablePrimaryKey) isConstraint() {}
+
 
 // TableAlteration represents ALTER TABLE action.
 type TableAlteration interface {
@@ -2659,6 +2661,21 @@ type TableConstraint struct {
 	Constraint Constraint
 }
 
+// TablePrimaryKey is primary key constraint in CREATE TABLE.
+// Note: While it implements Constraint interface to be stored in TableConstraints,
+// it is only used for anonymous style as Spanner doesn't support named primary keys.
+//
+//	PRIMARY KEY ({{.Columns | sqlJoin ", "}})
+type TablePrimaryKey struct {
+	// pos = Primary
+	// end = Rparen + 1
+
+	Primary token.Pos // position of "PRIMARY" keyword
+	Rparen  token.Pos // position of ")" after columns
+
+	Columns []*IndexKey
+}
+
 // ForeignKey is foreign key specifier in CREATE TABLE and ALTER TABLE.
 //
 //	FOREIGN KEY ({{.ColumnNames | sqlJoin ","}}) REFERENCES {{.ReferenceTable}} ({{.ReferenceColumns | sqlJoin ","}})

ast/sql.go

@@ -869,6 +869,10 @@ func (c *TableConstraint) SQL() string {
 	return sqlOpt("CONSTRAINT ", c.Name, " ") + c.Constraint.SQL()
 }
 
+func (p *TablePrimaryKey) SQL() string {
+	return "PRIMARY KEY (" + sqlJoin(p.Columns, ", ") + ")"
+}
+
 func (f *ForeignKey) SQL() string {
 	return "FOREIGN KEY (" + sqlJoin(f.Columns, ", ") + ") " +
 		"REFERENCES " + f.ReferenceTable.SQL() + " (" +

parser.go

@@ -3292,6 +3292,12 @@ func (p *Parser) parseCreateTable(pos token.Pos) *ast.CreateTable {
 				ConstraintPos: token.InvalidPos,
 				Constraint:    c,
 			})
+		case p.Token.IsKeywordLike("PRIMARY"):
+			pk := p.parseTablePrimaryKey()
+			constraints = append(constraints, &ast.TableConstraint{
+				ConstraintPos: token.InvalidPos,
+				Constraint:    pk,
+			})
 		case p.Token.IsKeywordLike("SYNONYM"):
 			synonym := p.parseSynonym()
 			synonyms = append(synonyms, synonym)
@@ -3498,6 +3504,21 @@ func (p *Parser) parseConstraint() *ast.TableConstraint {
 	}
 }
 
+func (p *Parser) parseTablePrimaryKey() *ast.TablePrimaryKey {
+	pos := p.expectKeywordLike("PRIMARY").Pos
+	p.expectKeywordLike("KEY")
+
+	p.expect("(")
+	keys := parseCommaSeparatedList(p, p.parseIndexKey)
+	rparen := p.expect(")").Pos
+
+	return &ast.TablePrimaryKey{
+		Primary: pos,
+		Rparen:  rparen,
+		Columns: keys,
+	}
+}
+
 func (p *Parser) parseForeignKey() *ast.ForeignKey {
 	pos := p.expectKeywordLike("FOREIGN").Pos
 	p.expectKeywordLike("KEY")

testdata/input/ddl/create_table_anonymous_primary_key.sql

@@ -0,0 +1,5 @@
+CREATE TABLE PKsTable(
+  PK1 INT64,
+  PK2 INT64,
+  PRIMARY KEY (PK1, PK2)
+)

testdata/result/ddl/create_table_anonymous_primary_key.sql.txt

@@ -0,0 +1,84 @@
+--- create_table_anonymous_primary_key.sql
+CREATE TABLE PKsTable(
+  PK1 INT64,
+  PK2 INT64,
+  PRIMARY KEY (PK1, PK2)
+)
+--- AST
+&ast.CreateTable{
+  Rparen:           74,
+  PrimaryKeyRparen: -1,
+  Name:             &ast.Path{
+    Idents: []*ast.Ident{
+      &ast.Ident{
+        NamePos: 13,
+        NameEnd: 21,
+        Name:    "PKsTable",
+      },
+    },
+  },
+  Columns: []*ast.ColumnDef{
+    &ast.ColumnDef{
+      Null: -1,
+      Key:  -1,
+      Name: &ast.Ident{
+        NamePos: 25,
+        NameEnd: 28,
+        Name:    "PK1",
+      },
+      Type: &ast.ScalarSchemaType{
+        NamePos: 29,
+        Name:    "INT64",
+      },
+      Hidden: -1,
+    },
+    &ast.ColumnDef{
+      Null: -1,
+      Key:  -1,
+      Name: &ast.Ident{
+        NamePos: 38,
+        NameEnd: 41,
+        Name:    "PK2",
+      },
+      Type: &ast.ScalarSchemaType{
+        NamePos: 42,
+        Name:    "INT64",
+      },
+      Hidden: -1,
+    },
+  },
+  TableConstraints: []*ast.TableConstraint{
+    &ast.TableConstraint{
+      ConstraintPos: -1,
+      Constraint:    &ast.TablePrimaryKey{
+        Primary: 51,
+        Rparen:  72,
+        Columns: []*ast.IndexKey{
+          &ast.IndexKey{
+            DirPos: -1,
+            Name:   &ast.Ident{
+              NamePos: 64,
+              NameEnd: 67,
+              Name:    "PK1",
+            },
+          },
+          &ast.IndexKey{
+            DirPos: -1,
+            Name:   &ast.Ident{
+              NamePos: 69,
+              NameEnd: 72,
+              Name:    "PK2",
+            },
+          },
+        },
+      },
+    },
+  },
+}
+
+--- SQL
+CREATE TABLE PKsTable (
+  PK1 INT64,
+  PK2 INT64,
+  PRIMARY KEY (PK1, PK2)
+)