Add support for LOCK TABLES & UNLOCK TABLES statements

Author: atavakoliyext

analyzer.go

@@ -97,7 +97,7 @@ func Preview(sql string) int {
 		return StmtShow
 	case "use":
 		return StmtUse
-	case "analyze", "describe", "desc", "explain", "repair", "optimize":
+	case "analyze", "describe", "desc", "explain", "repair", "optimize", "lock", "unlock":
 		return StmtOther
 	}
 	if strings.Index(trimmed, "/*!") == 0 {

analyzer_test.go

@@ -64,6 +64,8 @@ func TestPreview(t *testing.T) {
 		{"describe", StmtOther},
 		{"desc", StmtOther},
 		{"explain", StmtOther},
+		{"lock", StmtOther},
+		{"unlock", StmtOther},
 		{"repair", StmtOther},
 		{"optimize", StmtOther},
 		{"truncate", StmtDDL},

ast.go

@@ -200,6 +200,8 @@ func (*Execute) iStatement()         {}
 func (*Begin) iStatement()           {}
 func (*Commit) iStatement()          {}
 func (*Rollback) iStatement()        {}
+func (*LockTables) iStatement()      {}
+func (*UnlockTables) iStatement()    {}
 func (*DropUser) iStatement()        {}
 func (*DropRole) iStatement()        {}
 func (*Grant) iStatement()           {}
@@ -1916,6 +1918,79 @@ func (node *Rollback) walkSubtree(visit Visit) error {
 	return nil
 }
 
+// LockTables represents a LOCK TABLE[S] statement.
+type LockTables struct {
+	Tables TableLocks
+}
+
+// Format formats the node.
+func (node *LockTables) Format(buf *TrackedBuffer) {
+	buf.Myprintf("lock tables %v", node.Tables)
+}
+
+func (node *LockTables) walkSubtree(visit Visit) error {
+	if node == nil {
+		return nil
+	}
+	return Walk(visit, node.Tables)
+}
+
+// TableLocks is a list of table locks in a LOCK TABLES statement.
+type TableLocks []*TableLock
+
+// Format formats the node.
+func (node TableLocks) Format(buf *TrackedBuffer) {
+	prefix := ""
+	for _, lock := range node {
+		buf.Myprintf("%s%v", prefix, lock)
+		prefix = ", "
+	}
+}
+
+func (node TableLocks) walkSubtree(visit Visit) error {
+	for _, lock := range node {
+		if err := Walk(visit, lock); err != nil {
+			return err
+		}
+	}
+	return nil
+}
+
+// TableLock represents one table lock target and lock mode.
+type TableLock struct {
+	Table TableName
+	Alias TableIdent
+	Lock  string
+}
+
+// Format formats the node.
+func (node *TableLock) Format(buf *TrackedBuffer) {
+	buf.Myprintf("%v", node.Table)
+	if !node.Alias.IsEmpty() {
+		buf.Myprintf(" as %v", node.Alias)
+	}
+	buf.Myprintf(" %s", node.Lock)
+}
+
+func (node *TableLock) walkSubtree(visit Visit) error {
+	if node == nil {
+		return nil
+	}
+	return Walk(visit, node.Table, node.Alias)
+}
+
+// UnlockTables represents an UNLOCK TABLE[S] statement.
+type UnlockTables struct{}
+
+// Format formats the node.
+func (node *UnlockTables) Format(buf *TrackedBuffer) {
+	buf.WriteString("unlock tables")
+}
+
+func (node *UnlockTables) walkSubtree(visit Visit) error {
+	return nil
+}
+
 // DropUser represents a DROP USER statement.
 type DropUser struct {
 	IfExists bool

parse_test.go

@@ -1280,6 +1280,27 @@ var (
 	}, {
 		input:  "optimize table foo",
 		output: "otheradmin",
+	}, {
+		input:  "lock table tbl_a read",
+		output: "lock tables tbl_a read",
+	}, {
+		input:  "lock tables tbl_a read local",
+		output: "lock tables tbl_a read local",
+	}, {
+		input:  "lock tables tbl_a t_a write",
+		output: "lock tables tbl_a as t_a write",
+	}, {
+		input:  "lock tables tbl_a as `By` read",
+		output: "lock tables tbl_a as `By` read",
+	}, {
+		input:  "lock tables db_a.tbl_b as t_b low_priority write, tbl_c read",
+		output: "lock tables db_a.tbl_b as t_b low_priority write, tbl_c read",
+	}, {
+		input:  "unlock table",
+		output: "unlock tables",
+	}, {
+		input:  "unlock tables",
+		output: "unlock tables",
 	}, {
 		input: "select /* EQ true */ 1 from t where a = true",
 	}, {
@@ -1499,6 +1520,24 @@ func TestSelectLockInvalid(t *testing.T) {
 	}
 }
 
+func TestTableLockInvalid(t *testing.T) {
+	invalidSQL := []string{
+		"lock table",
+		"lock tables",
+		"lock tables tbl_a",
+		"lock tables tbl_a local",
+		"lock tables tbl_a write low_priority",
+		"lock tables tbl_a as read read",
+		"unlock",
+		"unlock tables tbl_a",
+	}
+	for _, sql := range invalidSQL {
+		if _, err := Parse(sql); err == nil {
+			t.Errorf("Parse(%q) err: nil, want non-nil", sql)
+		}
+	}
+}
+
 func TestSelectIntoInvalid(t *testing.T) {
 	invalidSQL := []string{
 		"select col_a into col_b from tbl_a",