[jdbc-v2] Support multi-dot notation for database names

Fixes #2650

Changes:
- Updated ANTLR grammar databaseIdentifier rule to support multiple
  dot-separated identifiers: identifier (DOT identifier)*
- Added extractTableName() helper method in SqlParserFacade to properly
  handle multi-part table identifiers by unquoting each part separately
- Added testMultiDotNotation() test with 3 test cases covering SELECT,
  INSERT, and quoted identifiers
- All 367 existing tests continue to pass

This allows database names like 'a.b' in table references such as
'a.b.c' or '`db.part1`.`table`' to be parsed correctly.

Author: devdavidkarlsson

jdbc-v2/src/main/antlr4/com/clickhouse/jdbc/internal/parser/antlr4/ClickHouseParser.g4

@@ -1172,7 +1172,7 @@ tableArgExpr
 // Databases
 
 databaseIdentifier
-    : identifier
+    : identifier (DOT identifier)*
     ;
 
 // Basics

jdbc-v2/src/main/java/com/clickhouse/jdbc/internal/SqlParserFacade.java

@@ -265,18 +265,47 @@ public void enterAssignmentValuesList(ClickHouseParser.AssignmentValuesListConte
             }
 
 
+            private String extractTableName(ClickHouseParser.TableIdentifierContext tableId) {
+                if (tableId == null) {
+                    return null;
+                }
+                
+                StringBuilder tableName = new StringBuilder();
+                
+                // Handle database identifier if present
+                if (tableId.databaseIdentifier() != null) {
+                    ClickHouseParser.DatabaseIdentifierContext dbCtx = tableId.databaseIdentifier();
+                    // Database identifier can have multiple parts: identifier (DOT identifier)*
+                    List<ClickHouseParser.IdentifierContext> dbParts = dbCtx.identifier();
+                    for (int i = 0; i < dbParts.size(); i++) {
+                        if (i > 0) {
+                            tableName.append('.');
+                        }
+                        tableName.append(SQLUtils.unquoteIdentifier(dbParts.get(i).getText()));
+                    }
+                    tableName.append('.');
+                }
+                
+                // Handle table identifier
+                if (tableId.identifier() != null) {
+                    tableName.append(SQLUtils.unquoteIdentifier(tableId.identifier().getText()));
+                }
+                
+                return tableName.toString();
+            }
+
             @Override
             public void enterTableExprIdentifier(ClickHouseParser.TableExprIdentifierContext ctx) {
                 if (ctx.tableIdentifier() != null) {
-                    parsedStatement.setTable(SQLUtils.unquoteIdentifier(ctx.tableIdentifier().getText()));
+                    parsedStatement.setTable(extractTableName(ctx.tableIdentifier()));
                 }
             }
 
             @Override
             public void enterInsertStmt(ClickHouseParser.InsertStmtContext ctx) {
                 ClickHouseParser.TableIdentifierContext tableId = ctx.tableIdentifier();
                 if (tableId != null) {
-                    parsedStatement.setTable(SQLUtils.unquoteIdentifier(tableId.getText()));
+                    parsedStatement.setTable(extractTableName(tableId));
                 }
 
                 ClickHouseParser.ColumnsClauseContext columns = ctx.columnsClause();

jdbc-v2/src/test/java/com/clickhouse/jdbc/internal/BaseSqlParserFacadeTest.java

@@ -160,6 +160,31 @@ public void testStmtWithUUID() {
         Assert.assertFalse(stmt.isHasErrors());
     }
 
+    @Test
+    public void testMultiDotNotation() {
+        // Test with three parts: a.b.c where a.b is database and c is table
+        String sql1 = "SELECT * FROM a.b.c WHERE id = ?";
+        ParsedPreparedStatement stmt1 = parser.parsePreparedStatement(sql1);
+        Assert.assertEquals(stmt1.getArgCount(), 1);
+        Assert.assertFalse(stmt1.isHasErrors());
+        Assert.assertEquals(stmt1.getTable(), "a.b.c");
+        
+        // Test with quoted identifiers
+        String sql2 = "SELECT * FROM `db.part1`.`table` WHERE id = ?";
+        ParsedPreparedStatement stmt2 = parser.parsePreparedStatement(sql2);
+        Assert.assertEquals(stmt2.getArgCount(), 1);
+        Assert.assertFalse(stmt2.isHasErrors());
+        Assert.assertEquals(stmt2.getTable(), "db.part1.table");
+        
+        // Test INSERT with multi-dot notation
+        String sql3 = "INSERT INTO a.b.c (col1, col2) VALUES (?, ?)";
+        ParsedPreparedStatement stmt3 = parser.parsePreparedStatement(sql3);
+        Assert.assertEquals(stmt3.getArgCount(), 2);
+        Assert.assertFalse(stmt3.isHasErrors());
+        Assert.assertTrue(stmt3.isInsert());
+        Assert.assertEquals(stmt3.getTable(), "a.b.c");
+    }
+
     @Test(dataProvider = "testCreateStmtDP")
     public void testCreateStatement(String sql) {
         ParsedPreparedStatement stmt = parser.parsePreparedStatement(sql);