This is an automated email from the ASF dual-hosted git repository.
jimin pushed a commit to branch 2.x
in repository https://gitbox.apache.org/repos/asf/incubator-seata.git
The following commit(s) were added to refs/heads/2.x by this push:
new 72363f4d60 test: add Antlr tests to improve test coverage. (#7912)
72363f4d60 is described below
commit 72363f4d60f8c9ca48f01ca3348165ef362848d4
Author: maple <[email protected]>
AuthorDate: Fri Jan 2 12:05:08 2026 +0800
test: add Antlr tests to improve test coverage. (#7912)
---
changes/en-us/2.x.md | 1 +
changes/zh-cn/2.x.md | 1 +
.../mysql/AntlrMySQLDeleteRecognizerTest.java | 176 +++++++++++++
.../mysql/AntlrMySQLInsertRecognizerTest.java | 252 +++++++++++++++++++
.../mysql/AntlrMySQLUpdateRecognizerTest.java | 278 +++++++++++++++++++++
5 files changed, 708 insertions(+)
diff --git a/changes/en-us/2.x.md b/changes/en-us/2.x.md
index b15da0d960..e07b267062 100644
--- a/changes/en-us/2.x.md
+++ b/changes/en-us/2.x.md
@@ -164,6 +164,7 @@ Add changes here for all PR submitted to the 2.x branch.
- [[#7874](https://github.com/apache/incubator-seata/pull/7874)] add unit
tests for DBType and RedisKeyConstants in core module
- [[#7899](https://github.com/apache/incubator-seata/pull/7899)] add unit
tests for ConnectionContext class
- [[#7907](https://github.com/apache/incubator-seata/pull/7907)] test: fixes
CI errors caused by timing issues in ZkConfigurationTest
+- [[#7912](https://github.com/apache/incubator-seata/pull/7912)] test: add
Antlr tests to improve test coverage
### refactor:
diff --git a/changes/zh-cn/2.x.md b/changes/zh-cn/2.x.md
index 09379e2543..1e79ac91e2 100644
--- a/changes/zh-cn/2.x.md
+++ b/changes/zh-cn/2.x.md
@@ -160,6 +160,7 @@
- [[#7859](https://github.com/apache/incubator-seata/pull/7859)] 修复
`MetadataTest` 因共享状态与依赖 `toString()` 输出不稳定导致的测试用例间歇性失败问题
- [[#7858](https://github.com/apache/incubator-seata/pull/7858)] 修复
`HttpTest.convertParamOfJsonStringTest` 因 Map 遍历顺序不确定导致的测试用例间歇性失败问题
- [[#7907](https://github.com/apache/incubator-seata/pull/7907)] test:
修复ZkConfigurationTest的时序问题导致的ci错误
+- [[#7912](https://github.com/apache/incubator-seata/pull/7912)] test: 添加
Antlr 测试以提高测试覆盖率
### refactor:
diff --git
a/sqlparser/seata-sqlparser-antlr/src/test/java/org/apache/seata/sqlparser/antlr/mysql/AntlrMySQLDeleteRecognizerTest.java
b/sqlparser/seata-sqlparser-antlr/src/test/java/org/apache/seata/sqlparser/antlr/mysql/AntlrMySQLDeleteRecognizerTest.java
new file mode 100644
index 0000000000..7a585f97df
--- /dev/null
+++
b/sqlparser/seata-sqlparser-antlr/src/test/java/org/apache/seata/sqlparser/antlr/mysql/AntlrMySQLDeleteRecognizerTest.java
@@ -0,0 +1,176 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.apache.seata.sqlparser.antlr.mysql;
+
+import org.apache.seata.sqlparser.SQLType;
+import org.junit.jupiter.api.Assertions;
+import org.junit.jupiter.api.Test;
+
+/**
+ * Unit tests for AntlrMySQLDeleteRecognizer
+ */
+public class AntlrMySQLDeleteRecognizerTest {
+
+ /**
+ * Test simple DELETE statement
+ */
+ @Test
+ public void testSimpleDelete() {
+ String sql = "DELETE FROM t1 WHERE id = 1";
+ AntlrMySQLDeleteRecognizer recognizer = new
AntlrMySQLDeleteRecognizer(sql);
+
+ Assertions.assertEquals("t1", recognizer.getTableName());
+ Assertions.assertEquals("id = 1", recognizer.getWhereCondition());
+ Assertions.assertNull(recognizer.getTableAlias());
+ Assertions.assertEquals(SQLType.DELETE, recognizer.getSQLType());
+ Assertions.assertEquals(sql, recognizer.getOriginalSQL());
+ }
+
+ /**
+ * Test DELETE statement with alias
+ */
+ @Test
+ public void testDeleteWithAlias() {
+ String sql = "DELETE t FROM t1 AS t WHERE t.id = 1";
+ AntlrMySQLDeleteRecognizer recognizer = new
AntlrMySQLDeleteRecognizer(sql);
+
+ Assertions.assertEquals("t1", recognizer.getTableName());
+ Assertions.assertEquals("t", recognizer.getTableAlias());
+ Assertions.assertEquals("t.id = 1", recognizer.getWhereCondition());
+ Assertions.assertEquals(SQLType.DELETE, recognizer.getSQLType());
+ }
+
+ /**
+ * Test DELETE statement with string condition
+ */
+ @Test
+ public void testDeleteWithStringCondition() {
+ String sql = "DELETE FROM users WHERE name = 'John'";
+ AntlrMySQLDeleteRecognizer recognizer = new
AntlrMySQLDeleteRecognizer(sql);
+
+ Assertions.assertEquals("users", recognizer.getTableName());
+ Assertions.assertEquals("name = 'John'",
recognizer.getWhereCondition());
+ Assertions.assertEquals(SQLType.DELETE, recognizer.getSQLType());
+ }
+
+ /**
+ * Test DELETE statement with placeholder
+ */
+ @Test
+ public void testDeleteWithPlaceholder() {
+ String sql = "DELETE FROM t1 WHERE id = ?";
+ AntlrMySQLDeleteRecognizer recognizer = new
AntlrMySQLDeleteRecognizer(sql);
+
+ Assertions.assertEquals("t1", recognizer.getTableName());
+ Assertions.assertEquals("id = ?", recognizer.getWhereCondition());
+ Assertions.assertEquals(SQLType.DELETE, recognizer.getSQLType());
+ }
+
+ /**
+ * Test DELETE statement with IN condition
+ */
+ @Test
+ public void testDeleteWithInCondition() {
+ String sql = "DELETE FROM t1 WHERE id IN (1, 2, 3)";
+ AntlrMySQLDeleteRecognizer recognizer = new
AntlrMySQLDeleteRecognizer(sql);
+
+ Assertions.assertEquals("t1", recognizer.getTableName());
+ Assertions.assertNotNull(recognizer.getWhereCondition());
+ Assertions.assertTrue(recognizer.getWhereCondition().contains("IN"));
+ Assertions.assertEquals(SQLType.DELETE, recognizer.getSQLType());
+ }
+
+ /**
+ * Test DELETE statement with BETWEEN condition
+ */
+ @Test
+ public void testDeleteWithBetweenCondition() {
+ String sql = "DELETE FROM t1 WHERE id BETWEEN 1 AND 10";
+ AntlrMySQLDeleteRecognizer recognizer = new
AntlrMySQLDeleteRecognizer(sql);
+
+ Assertions.assertEquals("t1", recognizer.getTableName());
+ Assertions.assertNotNull(recognizer.getWhereCondition());
+
Assertions.assertTrue(recognizer.getWhereCondition().toLowerCase().contains("between"));
+ Assertions.assertEquals(SQLType.DELETE, recognizer.getSQLType());
+ }
+
+ /**
+ * Test DELETE statement with multiple conditions
+ */
+ @Test
+ public void testDeleteWithMultipleConditions() {
+ String sql = "DELETE FROM t1 WHERE id > 10 AND status = 'active'";
+ AntlrMySQLDeleteRecognizer recognizer = new
AntlrMySQLDeleteRecognizer(sql);
+
+ Assertions.assertEquals("t1", recognizer.getTableName());
+ Assertions.assertNotNull(recognizer.getWhereCondition());
+ Assertions.assertTrue(recognizer.getWhereCondition().contains("AND"));
+ Assertions.assertEquals(SQLType.DELETE, recognizer.getSQLType());
+ }
+
+ /**
+ * Test getLimitCondition method (should return null)
+ */
+ @Test
+ public void testGetLimitCondition() {
+ String sql = "DELETE FROM t1 WHERE id = 1";
+ AntlrMySQLDeleteRecognizer recognizer = new
AntlrMySQLDeleteRecognizer(sql);
+
+ Assertions.assertNull(recognizer.getLimitCondition());
+ Assertions.assertNull(recognizer.getLimitCondition(null, null));
+ }
+
+ /**
+ * Test getOrderByCondition method (should return null)
+ */
+ @Test
+ public void testGetOrderByCondition() {
+ String sql = "DELETE FROM t1 WHERE id = 1";
+ AntlrMySQLDeleteRecognizer recognizer = new
AntlrMySQLDeleteRecognizer(sql);
+
+ Assertions.assertNull(recognizer.getOrderByCondition());
+ Assertions.assertNull(recognizer.getOrderByCondition(null, null));
+ }
+
+ /**
+ * Test DELETE with backtick table name
+ */
+ @Test
+ public void testDeleteWithBacktickTableName() {
+ String sql = "DELETE FROM `table_name` WHERE id = 1";
+ AntlrMySQLDeleteRecognizer recognizer = new
AntlrMySQLDeleteRecognizer(sql);
+
+ Assertions.assertNotNull(recognizer.getTableName());
+ Assertions.assertEquals("id = 1", recognizer.getWhereCondition());
+ Assertions.assertEquals(SQLType.DELETE, recognizer.getSQLType());
+ }
+
+ /**
+ * Test getWhereCondition overloaded methods
+ */
+ @Test
+ public void testGetWhereConditionOverloads() {
+ String sql = "DELETE FROM t1 WHERE id = 1";
+ AntlrMySQLDeleteRecognizer recognizer = new
AntlrMySQLDeleteRecognizer(sql);
+
+ String whereCondition1 = recognizer.getWhereCondition();
+ String whereCondition2 = recognizer.getWhereCondition(null, null);
+
+ Assertions.assertEquals(whereCondition1, whereCondition2);
+ Assertions.assertEquals("id = 1", whereCondition1);
+ }
+}
diff --git
a/sqlparser/seata-sqlparser-antlr/src/test/java/org/apache/seata/sqlparser/antlr/mysql/AntlrMySQLInsertRecognizerTest.java
b/sqlparser/seata-sqlparser-antlr/src/test/java/org/apache/seata/sqlparser/antlr/mysql/AntlrMySQLInsertRecognizerTest.java
new file mode 100644
index 0000000000..87ba64553a
--- /dev/null
+++
b/sqlparser/seata-sqlparser-antlr/src/test/java/org/apache/seata/sqlparser/antlr/mysql/AntlrMySQLInsertRecognizerTest.java
@@ -0,0 +1,252 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.apache.seata.sqlparser.antlr.mysql;
+
+import org.apache.seata.sqlparser.SQLType;
+import org.junit.jupiter.api.Assertions;
+import org.junit.jupiter.api.Test;
+
+import java.util.List;
+
+/**
+ * Unit tests for AntlrMySQLInsertRecognizer
+ */
+public class AntlrMySQLInsertRecognizerTest {
+
+ /**
+ * Test simple INSERT statement
+ */
+ @Test
+ public void testSimpleInsert() {
+ String sql = "INSERT INTO t1 (id, name) VALUES (1, 'test')";
+ AntlrMySQLInsertRecognizer recognizer = new
AntlrMySQLInsertRecognizer(sql);
+
+ Assertions.assertEquals("t1", recognizer.getTableName());
+ Assertions.assertEquals(SQLType.INSERT, recognizer.getSQLType());
+ Assertions.assertEquals(sql, recognizer.getOriginalSQL());
+ Assertions.assertFalse(recognizer.insertColumnsIsEmpty());
+ }
+
+ /**
+ * Test getting insert column names
+ */
+ @Test
+ public void testGetInsertColumns() {
+ String sql = "INSERT INTO t1 (id, name, age) VALUES (1, 'John', 30)";
+ AntlrMySQLInsertRecognizer recognizer = new
AntlrMySQLInsertRecognizer(sql);
+
+ List<String> columns = recognizer.getInsertColumns();
+ Assertions.assertNotNull(columns);
+ // 列数应该是3
+ Assertions.assertEquals(3, columns.size());
+ }
+
+ /**
+ * Test single column insert
+ */
+ @Test
+ public void testSingleColumnInsert() {
+ String sql = "INSERT INTO t1 (id) VALUES (1)";
+ AntlrMySQLInsertRecognizer recognizer = new
AntlrMySQLInsertRecognizer(sql);
+
+ List<String> columns = recognizer.getInsertColumns();
+ Assertions.assertEquals(1, columns.size());
+ Assertions.assertFalse(recognizer.insertColumnsIsEmpty());
+ }
+
+ /**
+ * Test multi-row insert
+ */
+ @Test
+ public void testMultiRowInsert() {
+ String sql = "INSERT INTO t1 (id, name) VALUES (1, 'Alice'), (2,
'Bob'), (3, 'Charlie')";
+ AntlrMySQLInsertRecognizer recognizer = new
AntlrMySQLInsertRecognizer(sql);
+
+ List<String> columns = recognizer.getInsertColumns();
+ Assertions.assertEquals(2, columns.size());
+ Assertions.assertFalse(recognizer.insertColumnsIsEmpty());
+ }
+
+ /**
+ * Test insert with backtick column names
+ */
+ @Test
+ public void testInsertWithBacktickColumns() {
+ String sql = "INSERT INTO t1 (`id`, `user_name`) VALUES (1, 'test')";
+ AntlrMySQLInsertRecognizer recognizer = new
AntlrMySQLInsertRecognizer(sql);
+
+ List<String> columns = recognizer.getInsertColumns();
+ Assertions.assertNotNull(columns);
+ Assertions.assertEquals(2, columns.size());
+ Assertions.assertFalse(recognizer.insertColumnsIsEmpty());
+ }
+
+ /**
+ * Test insertColumnsIsEmpty method - with columns
+ */
+ @Test
+ public void testInsertColumnsIsNotEmpty() {
+ String sql = "INSERT INTO t1 (id) VALUES (1)";
+ AntlrMySQLInsertRecognizer recognizer = new
AntlrMySQLInsertRecognizer(sql);
+ Assertions.assertFalse(recognizer.insertColumnsIsEmpty());
+ }
+
+ /**
+ * Test getInsertRows method (should return null)
+ */
+ @Test
+ public void testGetInsertRows() {
+ String sql = "INSERT INTO t1 (id) VALUES (1)";
+ AntlrMySQLInsertRecognizer recognizer = new
AntlrMySQLInsertRecognizer(sql);
+
+ Assertions.assertNull(recognizer.getInsertRows(null));
+ }
+
+ /**
+ * Test getInsertParamsValue method (should return null)
+ */
+ @Test
+ public void testGetInsertParamsValue() {
+ String sql = "INSERT INTO t1 (id) VALUES (1)";
+ AntlrMySQLInsertRecognizer recognizer = new
AntlrMySQLInsertRecognizer(sql);
+
+ Assertions.assertNull(recognizer.getInsertParamsValue());
+ }
+
+ /**
+ * Test getDuplicateKeyUpdate method (should return null)
+ */
+ @Test
+ public void testGetDuplicateKeyUpdate() {
+ String sql = "INSERT INTO t1 (id) VALUES (1)";
+ AntlrMySQLInsertRecognizer recognizer = new
AntlrMySQLInsertRecognizer(sql);
+
+ Assertions.assertNull(recognizer.getDuplicateKeyUpdate());
+ }
+
+ /**
+ * Test insert with table name
+ */
+ @Test
+ public void testInsertWithTableName() {
+ String sql = "INSERT INTO t1 (id, name) VALUES (1, 'test')";
+ AntlrMySQLInsertRecognizer recognizer = new
AntlrMySQLInsertRecognizer(sql);
+
+ Assertions.assertEquals("t1", recognizer.getTableName());
+ }
+
+ /**
+ * Test insert with backtick table name
+ */
+ @Test
+ public void testInsertWithBacktickTableName() {
+ String sql = "INSERT INTO `user_table` (id, name) VALUES (1, 'test')";
+ AntlrMySQLInsertRecognizer recognizer = new
AntlrMySQLInsertRecognizer(sql);
+
+ Assertions.assertNotNull(recognizer.getTableName());
+ Assertions.assertEquals(SQLType.INSERT, recognizer.getSQLType());
+ }
+
+ /**
+ * Test insert with mixed value types
+ */
+ @Test
+ public void testInsertWithMixedValues() {
+ String sql = "INSERT INTO t1 (id, name, age, salary) VALUES (1,
'John', 30, 5000.50)";
+ AntlrMySQLInsertRecognizer recognizer = new
AntlrMySQLInsertRecognizer(sql);
+
+ List<String> columns = recognizer.getInsertColumns();
+ Assertions.assertEquals(4, columns.size());
+ }
+
+ /**
+ * Test insert with placeholders
+ */
+ @Test
+ public void testInsertWithPlaceholders() {
+ String sql = "INSERT INTO t1 (id, name) VALUES (?, ?)";
+ AntlrMySQLInsertRecognizer recognizer = new
AntlrMySQLInsertRecognizer(sql);
+
+ List<String> columns = recognizer.getInsertColumns();
+ Assertions.assertEquals(2, columns.size());
+ }
+
+ /**
+ * Test getTableAlias method
+ */
+ @Test
+ public void testGetTableAlias() {
+ String sql = "INSERT INTO t1 (id) VALUES (1)";
+ AntlrMySQLInsertRecognizer recognizer = new
AntlrMySQLInsertRecognizer(sql);
+
+ // INSERT statements typically don't have table aliases
+ String alias = recognizer.getTableAlias();
+ // Alias may be null or empty
+ Assertions.assertTrue(alias == null || alias.isEmpty() ||
alias.length() >= 0);
+ }
+
+ /**
+ * Test complex INSERT statement
+ */
+ @Test
+ public void testComplexInsert() {
+ String sql = "INSERT INTO users (id, username, email, created_at)
VALUES (1, 'admin', '[email protected]', NOW())";
+ AntlrMySQLInsertRecognizer recognizer = new
AntlrMySQLInsertRecognizer(sql);
+
+ Assertions.assertEquals("users", recognizer.getTableName());
+ Assertions.assertEquals(SQLType.INSERT, recognizer.getSQLType());
+ Assertions.assertFalse(recognizer.insertColumnsIsEmpty());
+
+ List<String> columns = recognizer.getInsertColumns();
+ Assertions.assertNotNull(columns);
+ Assertions.assertEquals(4, columns.size());
+ }
+
+ /**
+ * Test insert with database name
+ */
+ @Test
+ public void testInsertWithDatabaseName() {
+ String sql = "INSERT INTO db1.t1 (id, name) VALUES (1, 'test')";
+ AntlrMySQLInsertRecognizer recognizer = new
AntlrMySQLInsertRecognizer(sql);
+
+ Assertions.assertNotNull(recognizer.getTableName());
+ Assertions.assertEquals(SQLType.INSERT, recognizer.getSQLType());
+ }
+
+ /**
+ * Test SQL type
+ */
+ @Test
+ public void testGetSQLType() {
+ String sql = "INSERT INTO t1 (id) VALUES (1)";
+ AntlrMySQLInsertRecognizer recognizer = new
AntlrMySQLInsertRecognizer(sql);
+
+ Assertions.assertEquals(SQLType.INSERT, recognizer.getSQLType());
+ }
+
+ /**
+ * Test getting original SQL
+ */
+ @Test
+ public void testGetOriginalSQL() {
+ String sql = "INSERT INTO t1 (id, name) VALUES (1, 'test')";
+ AntlrMySQLInsertRecognizer recognizer = new
AntlrMySQLInsertRecognizer(sql);
+
+ Assertions.assertEquals(sql, recognizer.getOriginalSQL());
+ }
+}
diff --git
a/sqlparser/seata-sqlparser-antlr/src/test/java/org/apache/seata/sqlparser/antlr/mysql/AntlrMySQLUpdateRecognizerTest.java
b/sqlparser/seata-sqlparser-antlr/src/test/java/org/apache/seata/sqlparser/antlr/mysql/AntlrMySQLUpdateRecognizerTest.java
new file mode 100644
index 0000000000..0a54f13fdc
--- /dev/null
+++
b/sqlparser/seata-sqlparser-antlr/src/test/java/org/apache/seata/sqlparser/antlr/mysql/AntlrMySQLUpdateRecognizerTest.java
@@ -0,0 +1,278 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.apache.seata.sqlparser.antlr.mysql;
+
+import org.apache.seata.sqlparser.SQLType;
+import org.junit.jupiter.api.Assertions;
+import org.junit.jupiter.api.Test;
+
+import java.util.List;
+
+/**
+ * Unit tests for AntlrMySQLUpdateRecognizer
+ */
+public class AntlrMySQLUpdateRecognizerTest {
+
+ /**
+ * Test simple UPDATE statement
+ */
+ @Test
+ public void testSimpleUpdate() {
+ String sql = "UPDATE t1 SET name = 'John' WHERE id = 1";
+ AntlrMySQLUpdateRecognizer recognizer = new
AntlrMySQLUpdateRecognizer(sql);
+
+ Assertions.assertEquals("t1", recognizer.getTableName());
+ Assertions.assertEquals("id = 1", recognizer.getWhereCondition());
+ Assertions.assertEquals(SQLType.UPDATE, recognizer.getSQLType());
+ Assertions.assertEquals(sql, recognizer.getOriginalSQL());
+ }
+
+ /**
+ * Test getting update columns
+ */
+ @Test
+ public void testGetUpdateColumns() {
+ String sql = "UPDATE t1 SET name = 'John', age = 30 WHERE id = 1";
+ AntlrMySQLUpdateRecognizer recognizer = new
AntlrMySQLUpdateRecognizer(sql);
+
+ List<String> columns = recognizer.getUpdateColumns();
+ Assertions.assertNotNull(columns);
+ Assertions.assertEquals(2, columns.size());
+ Assertions.assertTrue(columns.contains("name"));
+ Assertions.assertTrue(columns.contains("age"));
+ }
+
+ /**
+ * Test getting update values
+ */
+ @Test
+ public void testGetUpdateValues() {
+ String sql = "UPDATE t1 SET name = 'John', age = 30 WHERE id = 1";
+ AntlrMySQLUpdateRecognizer recognizer = new
AntlrMySQLUpdateRecognizer(sql);
+
+ List<Object> values = recognizer.getUpdateValues();
+ Assertions.assertNotNull(values);
+ Assertions.assertEquals(2, values.size());
+ }
+
+ /**
+ * Test single column update
+ */
+ @Test
+ public void testSingleColumnUpdate() {
+ String sql = "UPDATE t1 SET status = 'active' WHERE id = 1";
+ AntlrMySQLUpdateRecognizer recognizer = new
AntlrMySQLUpdateRecognizer(sql);
+
+ List<String> columns = recognizer.getUpdateColumns();
+ Assertions.assertEquals(1, columns.size());
+ Assertions.assertEquals("status", columns.get(0));
+
+ List<Object> values = recognizer.getUpdateValues();
+ Assertions.assertEquals(1, values.size());
+ }
+
+ /**
+ * Test UPDATE statement with alias
+ */
+ @Test
+ public void testUpdateWithAlias() {
+ String sql = "UPDATE t1 AS t SET t.name = 'John' WHERE t.id = 1";
+ AntlrMySQLUpdateRecognizer recognizer = new
AntlrMySQLUpdateRecognizer(sql);
+
+ Assertions.assertEquals("t1", recognizer.getTableName());
+ Assertions.assertEquals("t", recognizer.getTableAlias());
+ Assertions.assertNotNull(recognizer.getWhereCondition());
+ Assertions.assertEquals(SQLType.UPDATE, recognizer.getSQLType());
+ }
+
+ /**
+ * Test UPDATE statement with placeholder
+ */
+ @Test
+ public void testUpdateWithPlaceholder() {
+ String sql = "UPDATE t1 SET name = ? WHERE id = ?";
+ AntlrMySQLUpdateRecognizer recognizer = new
AntlrMySQLUpdateRecognizer(sql);
+
+ Assertions.assertEquals("t1", recognizer.getTableName());
+ List<String> columns = recognizer.getUpdateColumns();
+ Assertions.assertEquals(1, columns.size());
+ Assertions.assertEquals("name", columns.get(0));
+ }
+
+ /**
+ * Test UPDATE statement with IN condition
+ */
+ @Test
+ public void testUpdateWithInCondition() {
+ String sql = "UPDATE t1 SET status = 'inactive' WHERE id IN (1, 2, 3)";
+ AntlrMySQLUpdateRecognizer recognizer = new
AntlrMySQLUpdateRecognizer(sql);
+
+ Assertions.assertEquals("t1", recognizer.getTableName());
+ Assertions.assertNotNull(recognizer.getWhereCondition());
+
Assertions.assertTrue(recognizer.getWhereCondition().toLowerCase().contains("in"));
+ }
+
+ /**
+ * Test UPDATE statement with BETWEEN condition
+ */
+ @Test
+ public void testUpdateWithBetweenCondition() {
+ String sql = "UPDATE t1 SET status = 'processed' WHERE id BETWEEN 1
AND 10";
+ AntlrMySQLUpdateRecognizer recognizer = new
AntlrMySQLUpdateRecognizer(sql);
+
+ Assertions.assertEquals("t1", recognizer.getTableName());
+ Assertions.assertNotNull(recognizer.getWhereCondition());
+
Assertions.assertTrue(recognizer.getWhereCondition().toLowerCase().contains("between"));
+ }
+
+ /**
+ * Test multiple columns update
+ */
+ @Test
+ public void testMultipleColumnsUpdate() {
+ String sql = "UPDATE t1 SET name = 'John', age = 30, city = 'NYC',
status = 'active' WHERE id = 1";
+ AntlrMySQLUpdateRecognizer recognizer = new
AntlrMySQLUpdateRecognizer(sql);
+
+ List<String> columns = recognizer.getUpdateColumns();
+ Assertions.assertEquals(4, columns.size());
+ Assertions.assertTrue(columns.contains("name"));
+ Assertions.assertTrue(columns.contains("age"));
+ Assertions.assertTrue(columns.contains("city"));
+ Assertions.assertTrue(columns.contains("status"));
+ }
+
+ /**
+ * Test UPDATE with multiple conditions
+ */
+ @Test
+ public void testUpdateWithMultipleConditions() {
+ String sql = "UPDATE t1 SET status = 'active' WHERE id > 10 AND age <
50";
+ AntlrMySQLUpdateRecognizer recognizer = new
AntlrMySQLUpdateRecognizer(sql);
+
+ Assertions.assertEquals("t1", recognizer.getTableName());
+ Assertions.assertNotNull(recognizer.getWhereCondition());
+ Assertions.assertTrue(recognizer.getWhereCondition().contains("AND"));
+ }
+
+ /**
+ * Test getLimitCondition method (should return null)
+ */
+ @Test
+ public void testGetLimitCondition() {
+ String sql = "UPDATE t1 SET name = 'John' WHERE id = 1";
+ AntlrMySQLUpdateRecognizer recognizer = new
AntlrMySQLUpdateRecognizer(sql);
+
+ Assertions.assertNull(recognizer.getLimitCondition());
+ Assertions.assertNull(recognizer.getLimitCondition(null, null));
+ }
+
+ /**
+ * Test getOrderByCondition method (should return null)
+ */
+ @Test
+ public void testGetOrderByCondition() {
+ String sql = "UPDATE t1 SET name = 'John' WHERE id = 1";
+ AntlrMySQLUpdateRecognizer recognizer = new
AntlrMySQLUpdateRecognizer(sql);
+
+ Assertions.assertNull(recognizer.getOrderByCondition());
+ Assertions.assertNull(recognizer.getOrderByCondition(null, null));
+ }
+
+ /**
+ * Test UPDATE with backtick table name
+ */
+ @Test
+ public void testUpdateWithBacktickTableName() {
+ String sql = "UPDATE `user_table` SET name = 'John' WHERE id = 1";
+ AntlrMySQLUpdateRecognizer recognizer = new
AntlrMySQLUpdateRecognizer(sql);
+
+ Assertions.assertNotNull(recognizer.getTableName());
+ Assertions.assertEquals(SQLType.UPDATE, recognizer.getSQLType());
+ }
+
+ /**
+ * Test UPDATE with table prefix in column names
+ */
+ @Test
+ public void testUpdateWithTablePrefix() {
+ String sql = "UPDATE t1 SET t1.name = 'John' WHERE t1.id = 1";
+ AntlrMySQLUpdateRecognizer recognizer = new
AntlrMySQLUpdateRecognizer(sql);
+
+ Assertions.assertEquals("t1", recognizer.getTableName());
+ List<String> columns = recognizer.getUpdateColumns();
+ Assertions.assertEquals(1, columns.size());
+ }
+
+ /**
+ * Test UPDATE with NULL value
+ */
+ @Test
+ public void testUpdateWithNullValue() {
+ String sql = "UPDATE t1 SET name = NULL WHERE id = 1";
+ AntlrMySQLUpdateRecognizer recognizer = new
AntlrMySQLUpdateRecognizer(sql);
+
+ List<String> columns = recognizer.getUpdateColumns();
+ Assertions.assertEquals(1, columns.size());
+ Assertions.assertEquals("name", columns.get(0));
+ }
+
+ /**
+ * Test UPDATE with expression value
+ */
+ @Test
+ public void testUpdateWithExpression() {
+ String sql = "UPDATE t1 SET age = age + 1 WHERE id = 1";
+ AntlrMySQLUpdateRecognizer recognizer = new
AntlrMySQLUpdateRecognizer(sql);
+
+ List<String> columns = recognizer.getUpdateColumns();
+ Assertions.assertEquals(1, columns.size());
+ Assertions.assertEquals("age", columns.get(0));
+ }
+
+ /**
+ * Test getWhereCondition overloaded methods
+ */
+ @Test
+ public void testGetWhereConditionOverloads() {
+ String sql = "UPDATE t1 SET name = 'John' WHERE id = 1";
+ AntlrMySQLUpdateRecognizer recognizer = new
AntlrMySQLUpdateRecognizer(sql);
+
+ String whereCondition1 = recognizer.getWhereCondition();
+ String whereCondition2 = recognizer.getWhereCondition(null, null);
+
+ Assertions.assertEquals(whereCondition1, whereCondition2);
+ Assertions.assertEquals("id = 1", whereCondition1);
+ }
+
+ /**
+ * Test complex UPDATE statement
+ */
+ @Test
+ public void testComplexUpdate() {
+ String sql =
+ "UPDATE users AS u SET u.status = 'active', u.last_login =
NOW() WHERE u.id IN (1, 2, 3) AND u.deleted = 0";
+ AntlrMySQLUpdateRecognizer recognizer = new
AntlrMySQLUpdateRecognizer(sql);
+
+ Assertions.assertEquals("users", recognizer.getTableName());
+ Assertions.assertEquals("u", recognizer.getTableAlias());
+ Assertions.assertEquals(SQLType.UPDATE, recognizer.getSQLType());
+
+ List<String> columns = recognizer.getUpdateColumns();
+ Assertions.assertNotNull(columns);
+ Assertions.assertTrue(columns.size() >= 1);
+ }
+}
---------------------------------------------------------------------
To unsubscribe, e-mail: [email protected]
For additional commands, e-mail: [email protected]
