IdentifierRules (General SQL Parser Java Library Core 4.2.19 API)

Object
- gudusoft.gsqlparser.sqlenv.IdentifierRules

public final class IdentifierRules
extends Object

标识符规则四元组（per vendor, per object group）

定义数据库厂商的标识符大小写规则，区分 quoted 和 unquoted 标识符的处理方式。

设计来源：dbobject_search.md 资深设计师方案

使用示例：

 // Oracle: unquoted 折叠为大写且不敏感，quoted 保留原样且敏感
 IdentifierRules oracleRules = IdentifierRules.forOracle();

 // Couchbase: 全部大小写敏感
 IdentifierRules couchbaseRules = IdentifierRules.forCouchbase();

Since:: 3.1.0.9

Nested Class Summary

Nested Classes
Modifier and Type	Class and Description
`static class`	`IdentifierRules.CaseCollapse` The mapping under which an `INSENSITIVE`, non-folding branch compares: two names are one name when their images are equal.
`static class`	`IdentifierRules.CaseCompare` 大小写比较规则（Case Comparison）
`static class`	`IdentifierRules.CaseFold` 大小写折叠规则（Case Folding）

Field Summary

Fields
Modifier and Type	Field and Description
`IdentifierRules.CaseCollapse`	`collapse` How a branch of this cell that compares `INSENSITIVE` but does not fold (`IdentifierRules.CaseFold.NONE`) decides equality: two names are equal when their images under this mapping are equal.
`int`	`maxUtf8Bytes` The longest name the database keeps, in UTF-8 bytes; a longer name is cut to the longest prefix of whole characters that fits, for storing and looking up alike, quoted or not.
`static int`	`POSTGRESQL_MAX_IDENTIFIER_BYTES` PostgreSQL's NAMEDATALEN - 1 with the default build (NAMEDATALEN = 64).
`IdentifierRules.CaseCompare`	`quotedCompare` Quoted 标识符的大小写比较规则
`IdentifierRules.CaseFold`	`quotedFold` Quoted 标识符的大小写折叠规则（通常为 NONE，保留原样）
`IdentifierRules.CaseCompare`	`unquotedCompare` Unquoted 标识符的大小写比较规则
`IdentifierRules.CaseFold`	`unquotedFold` Unquoted 标识符的大小写折叠规则

Constructor Summary

Constructors
Constructor and Description
`IdentifierRules(IdentifierRules.CaseFold unquotedFold, IdentifierRules.CaseCompare unquotedCompare, IdentifierRules.CaseFold quotedFold, IdentifierRules.CaseCompare quotedCompare)` 构造标识符规则
`IdentifierRules(IdentifierRules.CaseFold unquotedFold, IdentifierRules.CaseCompare unquotedCompare, IdentifierRules.CaseFold quotedFold, IdentifierRules.CaseCompare quotedCompare, IdentifierRules.CaseCollapse collapse, int maxUtf8Bytes)` 构造标识符规则（完整参数）

Method Summary

All Methods Static Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`boolean`	`equals(Object o)`
`static IdentifierRules`	`forAccess()` Microsoft Access 标识符规则
`static IdentifierRules`	`forAnsi()` ANSI / ISO SQL 标识符规则（SQL-92 起的标准，与 Oracle 相同）
`static IdentifierRules`	`forAthena()` Athena 标识符规则（与 Presto 相同）
`static IdentifierRules`	`forBigQueryColumn()` BigQuery 列名规则（大小写不敏感）
`static IdentifierRules`	`forBigQueryTable()` BigQuery 表名规则（大小写敏感）
`static IdentifierRules`	`forCouchbase()` Couchbase N1QL 标识符规则
`static IdentifierRules`	`forDameng()` Dameng (达梦) 标识符规则（与 Oracle 相同）
`static IdentifierRules`	`forDatabricks()` Databricks 标识符规则（与 Hive 相同）
`static IdentifierRules`	`forDax()` DAX 标识符规则
`static IdentifierRules`	`forDB2()` DB2 / Netezza / Exasol 标识符规则（与 Oracle 相同）
`static IdentifierRules`	`forDoris()` Apache Doris 标识符规则（默认配置，相当于 lower_case_table_names=1）
`static IdentifierRules`	`forDoris(int lowerCaseTableNames)` Apache Doris 标识符规则（与 MySQL 相同）
`static IdentifierRules`	`forDorisColumn()` Apache Doris 列名规则（与 MySQL 列名相同，始终大小写不敏感）
`static IdentifierRules`	`forDuckDB()` DuckDB 标识符规则
`static IdentifierRules`	`forFirebird()` Firebird 标识符规则（与 Oracle 相同）
`static IdentifierRules`	`forFlink()` Apache Flink SQL 标识符规则
`static IdentifierRules`	`forGaussDB()` GaussDB 标识符规则（与 PostgreSQL 相同）
`static IdentifierRules`	`forGeneric()` 通用规则（`dbvgeneric`）：没有具体方言时按 SQL 标准，见 `forAnsi()`
`static IdentifierRules`	`forHANA()` SAP HANA 标识符规则（与 Oracle 相同）
`static IdentifierRules`	`forHive()` Hive / SparkSQL / Impala / Databricks 标识符规则
`static IdentifierRules`	`forMdx()` MDX 标识符规则
`static IdentifierRules`	`forMySQL(int lowerCaseTableNames)` MySQL 标识符规则（table/schema names）
`static IdentifierRules`	`forMySQLColumn()` MySQL 列名规则（始终大小写不敏感）
`static IdentifierRules`	`forMySQLNative(int lowerCaseTableNames)` MySQL table / schema / table-alias names, as verified on MySQL 8.4.10, used by `EDbVendor.dbvmysql`.
`static IdentifierRules`	`forMySQLNativeColumn()` MySQL column, column-alias and index names, as verified on MySQL 8.4.10: kept as written and compared by the simple lowercase mapping (`IdentifierRules.CaseCollapse.LOWER_SIMPLE`), whatever `lower_case_table_names` is.
`static IdentifierRules`	`forMySQLNativeRoutine()` MySQL function, procedure and routine-parameter names, as verified on MySQL 8.4.10: kept as written; two names are the same when their simple UPPERCASE forms are equal (`IdentifierRules.CaseCollapse.UPPER_SIMPLE`), whatever `lower_case_table_names` is.
`static IdentifierRules`	`forMySQLRoutine()` MySQL 函数名规则（始终大小写不敏感）
`static IdentifierRules`	`forOracle()` Oracle 标识符规则
`static IdentifierRules`	`forOracleNative()` Oracle 标识符规则，as verified on Oracle 23.26 (AL32UTF8), used by `EDbVendor.dbvoracle`.
`static IdentifierRules`	`forPostgreSQL()` PostgreSQL / Redshift / Greenplum 标识符规则
`static IdentifierRules`	`forPostgreSQLNative()` PostgreSQL 标识符规则，as verified on PostgreSQL 16.15 with a UTF8 database, used by `EDbVendor.dbvpostgresql`.
`static IdentifierRules`	`forPowerQuery()` Power Query M 标识符规则
`static IdentifierRules`	`forPresto()` Presto / Trino 标识符规则
`static IdentifierRules`	`forRedshift()` Amazon Redshift 标识符规则（默认配置，`enable_case_sensitive_identifier = false`）
`static IdentifierRules`	`forSnowflake()` Snowflake 标识符规则（与 Oracle 相同）
`static IdentifierRules`	`forSnowflake(boolean quotedIdentifiersIgnoreCase)` Snowflake 标识符规则（根据 QUOTED_IDENTIFIERS_IGNORE_CASE 决定）
`static IdentifierRules`	`forSqlAnywhere()` SAP IQ / SQL Anywhere 标识符规则
`static IdentifierRules`	`forSqlite()` SQLite 标识符规则
`static IdentifierRules`	`forSQLServer()` SQL Server / Azure SQL 标识符规则
`static IdentifierRules`	`forSQLServer(String collation)` SQL Server / Azure SQL 标识符规则（根据 collation 决定大小写比较）
`static IdentifierRules`	`forStarrocks()` StarRocks 标识符规则（默认配置，相当于 lower_case_table_names=1）
`static IdentifierRules`	`forStarrocks(int lowerCaseTableNames)` StarRocks 标识符规则（带参数，相当于 MySQL 的 lower_case_table_names）
`static IdentifierRules`	`forStarrocksColumn()` StarRocks 列名规则（与 MySQL 列名相同，始终大小写不敏感）
`static IdentifierRules`	`forSybase()` Sybase ASE 标识符规则
`static IdentifierRules`	`forTeradata()` Teradata 标识符规则
`static IdentifierRules`	`forVertica()` Vertica 标识符规则（与 Presto 相同）
`int`	`hashCode()`
`IdentifierRules`	`resolvedCell()` This cell with `IdentifierRules.CaseCompare.SAME_AS_UNQUOTED` resolved — the form that identifies a rule domain, so two cells that behave identically are not treated as two domains merely because one spells its quoted compare as "same as unquoted".
`String`	`toString()`

Methods inherited from class Object
clone, finalize, getClass, notify, notifyAll, wait, wait, wait

- Field Detail
  - unquotedFold
```
public final IdentifierRules.CaseFold unquotedFold
```
    Unquoted 标识符的大小写折叠规则
  - unquotedCompare
```
public final IdentifierRules.CaseCompare unquotedCompare
```
    Unquoted 标识符的大小写比较规则
  - quotedFold
```
public final IdentifierRules.CaseFold quotedFold
```
    Quoted 标识符的大小写折叠规则（通常为 NONE，保留原样）
  - quotedCompare
```
public final IdentifierRules.CaseCompare quotedCompare
```
    Quoted 标识符的大小写比较规则
  - collapse
```
public final IdentifierRules.CaseCollapse collapse
```
    How a branch of this cell that compares INSENSITIVE but does not fold (IdentifierRules.CaseFold.NONE) decides equality: two names are equal when their images under this mapping are equal. IdentifierRules.CaseCollapse.SIMPLE_FOLD (Unicode simple case folding) for every cell built with the four-argument constructor. A branch that folds is compared by its folded text and never consults this.
    Kept apart from the fold on purpose: the fold is the name a database STORES (what IdentifierService.normalize(java.lang.String, gudusoft.gsqlparser.sqlenv.ESQLDataObjectType) returns), the collapse is only how it COMPARES. MySQL keeps a column name as written but compares it by its simple lowercase mapping, so its column cell is NONE with collapse IdentifierRules.CaseCollapse.LOWER_SIMPLE.
  - maxUtf8Bytes
```
public final int maxUtf8Bytes
```
    The longest name the database keeps, in UTF-8 bytes; a longer name is cut to the longest prefix of whole characters that fits, for storing and looking up alike, quoted or not. 0 means no truncation. PostgreSQL: 63 (NAMEDATALEN - 1).
  - POSTGRESQL_MAX_IDENTIFIER_BYTES
```
public static final int POSTGRESQL_MAX_IDENTIFIER_BYTES
```
    PostgreSQL's NAMEDATALEN - 1 with the default build (NAMEDATALEN = 64).
    
    See Also:
    
    Constant Field Values
- Constructor Detail
  - IdentifierRules
```
public IdentifierRules(IdentifierRules.CaseFold unquotedFold,
                       IdentifierRules.CaseCompare unquotedCompare,
                       IdentifierRules.CaseFold quotedFold,
                       IdentifierRules.CaseCompare quotedCompare)
```
    构造标识符规则
    
    Parameters:
    
    unquotedFold - unquoted 标识符的折叠规则
    
    unquotedCompare - unquoted 标识符的比较规则
    
    quotedFold - quoted 标识符的折叠规则
    
    quotedCompare - quoted 标识符的比较规则
  - IdentifierRules
```
public IdentifierRules(IdentifierRules.CaseFold unquotedFold,
                       IdentifierRules.CaseCompare unquotedCompare,
                       IdentifierRules.CaseFold quotedFold,
                       IdentifierRules.CaseCompare quotedCompare,
                       IdentifierRules.CaseCollapse collapse,
                       int maxUtf8Bytes)
```
    构造标识符规则（完整参数）
    
    Parameters:
    
    unquotedFold - unquoted 标识符的折叠规则
    
    unquotedCompare - unquoted 标识符的比较规则
    
    quotedFold - quoted 标识符的折叠规则
    
    quotedCompare - quoted 标识符的比较规则
    
    collapse - how an INSENSITIVE branch that does not fold compares (collapse)
    
    maxUtf8Bytes - the length in UTF-8 bytes a name is cut to, 0 for none (maxUtf8Bytes)
- Method Detail
  - forOracle
```
public static IdentifierRules forOracle()
```
    Oracle 标识符规则
    实际数据库行为（Oracle 12c+）：
    - Unquoted: 折叠为大写，比较不敏感 (CREATE TABLE foo → stored as FOO, foo=FOO=Foo)
    - Quoted: 保留原样，比较敏感 (CREATE TABLE "foo" → stored as foo, "foo"!="FOO")
    与 Legacy TSQLEnv 兼容性：
    - columnCollationCaseSensitive = true → ❌ INCOMPATIBLE (legacy preserved case, new folds to UPPER)
    - functionCollationCaseSensitive = true → ❌ INCOMPATIBLE (legacy preserved case, new folds to UPPER)
    - tableCollationCaseSensitive = true → ❌ INCOMPATIBLE (legacy preserved case, new folds to UPPER)
    - catalogCollationCaseSensitive = false → ✅ COMPATIBLE (both fold to UPPER)
    测试用例影响：
    - ✅ 新规则正确：Oracle 确实将 unquoted identifiers 折叠为大写
    - ⚠️ 如果旧测试期望保留原始大小写 (如 "myTable" 保持为 "myTable")，则测试会失败
    - ⚠️ 应更新测试期望为大写 (如 "myTable" → "MYTABLE")
    IdentifierRules 配置：
    - Unquoted: 折叠为大写 (IdentifierRules.CaseFold.UPPER), 比较不敏感 (IdentifierRules.CaseCompare.INSENSITIVE)
    - Quoted: 保留原样 (IdentifierRules.CaseFold.NONE), 比较敏感 (IdentifierRules.CaseCompare.SENSITIVE)
    Since 2026-10-11 this is the shape the Oracle-like FORKS share (DB2, Netezza, Exasol, HANA, Snowflake, Dameng, Firebird), none of which has been verified on its own engine. EDbVendor.dbvoracle itself uses forOracleNative(): Oracle upper-cases an unquoted name with the SIMPLE mapping, so straße is STRAßE, which this cell's full mapping turns into STRASSE.
  - forOracleNative
```
public static IdentifierRules forOracleNative()
```
    Oracle 标识符规则，as verified on Oracle 23.26 (AL32UTF8), used by EDbVendor.dbvoracle.
    - Unquoted: the simple uppercase mapping (IdentifierRules.CaseFold.UPPER_SIMPLE), case-insensitive. CREATE TABLE straße is listed in user_tables as STRAßE (6 characters); FROM "STRAßE" finds it, FROM STRASSE raises ORA-00942.
    - Quoted: kept as written (IdentifierRules.CaseFold.NONE), case-sensitive.
    SQL-LR oracle/rules-1, cell U_UPPER_SIMPLE_CI__Q_NONE_CS.
  - forDameng
```
public static IdentifierRules forDameng()
```
    Dameng (达梦) 标识符规则（与 Oracle 相同）
    Dameng follows Oracle identifier conventions:
    - Unquoted: 折叠为大写, 比较不敏感
    - Quoted: 保留原样, 比较敏感
  - forPostgreSQL
```
public static IdentifierRules forPostgreSQL()
```
    PostgreSQL / Redshift / Greenplum 标识符规则
    实际数据库行为（PostgreSQL 12+）：
    - Unquoted: 折叠为小写，比较不敏感 (CREATE TABLE MyTable → stored as mytable, MyTable=mytable=MYTABLE)
    - Quoted: 保留原样，比较敏感 (CREATE TABLE "MyTable" → stored as MyTable, "MyTable"!="mytable")
    与 Legacy TSQLEnv 兼容性：
    - columnCollationCaseSensitive = false → ⚠️ PARTIAL (legacy folded to UPPER, new folds to LOWER)
    - functionCollationCaseSensitive = true → ❌ INCOMPATIBLE (legacy preserved case, new folds to LOWER)
    - tableCollationCaseSensitive = true → ❌ INCOMPATIBLE (legacy preserved case, new folds to LOWER)
    - catalogCollationCaseSensitive = true → ❌ INCOMPATIBLE (legacy preserved case, new folds to LOWER)
    测试用例影响：
    - ✅ 新规则正确：PostgreSQL 确实将 unquoted identifiers 折叠为小写
    - ⚠️ 如果旧测试期望大写 (如 "MyTable" → "MYTABLE")，则测试会失败
    - ⚠️ 应更新测试期望为小写 (如 "MyTable" → "mytable")
    - ⚠️ 如果旧测试期望保留原始大小写，也会失败
    IdentifierRules 配置：
    - Unquoted: 折叠为小写 (IdentifierRules.CaseFold.LOWER), 比较不敏感 (IdentifierRules.CaseCompare.INSENSITIVE)
    - Quoted: 保留原样 (IdentifierRules.CaseFold.NONE), 比较敏感 (IdentifierRules.CaseCompare.SENSITIVE)
    Since 2026-10-11 this is the shape the PostgreSQL-like FORKS share (Greenplum, GaussDB, EDB, and the fallback of Informix, OpenEdge and SOQL), none verified on its own engine. EDbVendor.dbvpostgresql itself uses forPostgreSQLNative().
  - forPostgreSQLNative
```
public static IdentifierRules forPostgreSQLNative()
```
    PostgreSQL 标识符规则，as verified on PostgreSQL 16.15 with a UTF8 database, used by EDbVendor.dbvpostgresql.
    - Unquoted: only A..Z are lowered (IdentifierRules.CaseFold.LOWER_ASCII) — downcase_identifier lowers nothing else in a multibyte encoding. After CREATE TABLE "Äbc", FROM ÄBC finds it and FROM "äbc" does not.
    - Quoted: kept as written, case-sensitive.
    - Both: cut to 63 UTF-8 bytes on a whole character (truncate_identifier / pg_mbcliplen), so two names that share their first 63 bytes are one name: CREATE TABLE <63 a>x is found by FROM <63 a>y.
    SQL-LR postgresql/rules-1, cell U_LOWER_ASCII_CI__Q_NONE_CS with truncation = UTF8_BYTES 63.
  - forRedshift
```
public static IdentifierRules forRedshift()
```
    Amazon Redshift 标识符规则（默认配置，enable_case_sensitive_identifier = false）
    实际数据库行为（AWS 文档 "Names and identifiers"）： standard 与 delimited identifier 都不区分大小写，并折叠为小写存储；只有打开 enable_case_sensitive_identifier 时，delimited identifier 才保留大小写。因此 "Orders"、"ORDERS" 与 orders 是同一个对象。
    IdentifierRules 配置：
    - Unquoted: 折叠为小写 (IdentifierRules.CaseFold.LOWER), 比较不敏感 (IdentifierRules.CaseCompare.INSENSITIVE)
    - Quoted: 折叠为小写 (IdentifierRules.CaseFold.LOWER), 比较不敏感 (IdentifierRules.CaseCompare.INSENSITIVE)
  - forCouchbase
```
public static IdentifierRules forCouchbase()
```
    Couchbase N1QL 标识符规则
    实际数据库行为（Couchbase N1QL）：
    - Unquoted: 保留原样，比较敏感
    - Quoted: 保留原样，比较敏感
    与 Legacy TSQLEnv 兼容性：
    - tableCollationCaseSensitive = false → ❌ INCOMPATIBLE (legacy folded to UPPER, new preserves case)
    IdentifierRules 配置：
    - Unquoted: 保留原样 (IdentifierRules.CaseFold.NONE), 比较敏感 (IdentifierRules.CaseCompare.SENSITIVE)
    - Quoted: 保留原样 (IdentifierRules.CaseFold.NONE), 比较敏感 (IdentifierRules.CaseCompare.SENSITIVE)
  - forSQLServer
```
public static IdentifierRules forSQLServer()
```
    SQL Server / Azure SQL 标识符规则
    实际数据库行为（SQL Server 2019+）：
    - Unquoted: 保留原样，比较由 collation 决定 (CREATE TABLE MyTable → stored as MyTable)
    - Quoted: 保留原样，比较由 collation 决定 (CREATE TABLE [MyTable] → stored as MyTable)
    - 默认 collation (SQL_Latin1_General_CP1_CI_AS): 大小写不敏感 (MyTable=mytable=MYTABLE)
    - CS collation (SQL_Latin1_General_CP1_CS_AS): 大小写敏感 (MyTable!=mytable)
    与 Legacy TSQLEnv 兼容性：
    - columnCollationCaseSensitive = false → ❌ INCOMPATIBLE (legacy folded to UPPER, new preserves case)
    - functionCollationCaseSensitive = false → ❌ INCOMPATIBLE (legacy folded to UPPER, new preserves case)
    - tableCollationCaseSensitive = false → ❌ INCOMPATIBLE (legacy folded to UPPER, new preserves case)
    - catalogCollationCaseSensitive = false → ❌ INCOMPATIBLE (legacy folded to UPPER, new preserves case)
    测试用例影响：
    - ✅ 新规则正确：SQL Server 保留标识符原始大小写，使用 collation 进行比较
    - ⚠️ 如果旧测试期望 "MyTable" → "MYTABLE"，则测试会失败
    - ⚠️ 应更新测试期望为保留原样 (如 "MyTable" 保持为 "MyTable")
    - ⚠️ 这是导致 dataflow 测试 processId 变化的根本原因！
    - 📝 参考: investigation_findings_2025_10_20.md
    IdentifierRules 配置：
    - Unquoted: 不折叠 (IdentifierRules.CaseFold.NONE), 基于 collation 比较 (IdentifierRules.CaseCompare.COLLATION_BASED)
    - Quoted: 不折叠 (IdentifierRules.CaseFold.NONE), 基于 collation 比较 (IdentifierRules.CaseCompare.COLLATION_BASED)
    - 需要配合 CollatorProvider 使用，默认使用 SQL_Latin1_General_CP1_CI_AS (大小写不敏感)
    注意：SQL Server 的大小写行为完全由 collation 决定，无法简单折叠。
  - forSQLServer
```
public static IdentifierRules forSQLServer(String collation)
```
    SQL Server / Azure SQL 标识符规则（根据 collation 决定大小写比较）
    SQL Server 的大小写行为完全由 collation 决定：
    - CI collation (如 SQL_Latin1_General_CP1_CI_AS): 大小写不敏感
    - CS collation (如 SQL_Latin1_General_CP1_CS_AS): 大小写敏感
    Unquoted 和 quoted 标识符都保留原始大小写（CaseFold.NONE），比较方式由 collation 名称中的 _CI_ 或 _CS_ 决定。
    A case-sensitive collation is exact (IdentifierRules.CaseCompare.SENSITIVE), except Latin1_General_CS_AI, whose accent equivalence was measured on the engine (CollatorProvider.hasMeasuredAccentFolding(java.lang.String)): it compares through the collator (IdentifierRules.CaseCompare.COLLATION_BASED), which folds accents by the measured table and then compares exactly (verified on SQL Server 2022: under Latin1_General_CS_AI the table café is found by cafe, not by Cafe). Every other collation, a case-insensitive one or _BIN/_BIN2, compares through the collator. A _CS_AI collation that was not measured stays exact, as before.
    Parameters:
    
    collation - SQL Server collation 名称（如 "SQL_Latin1_General_CP1_CS_AS"），传 null 或空字符串使用默认（case-insensitive）
  - forMySQL
```
public static IdentifierRules forMySQL(int lowerCaseTableNames)
```
    MySQL 标识符规则（table/schema names）
    实际数据库行为（MySQL 8.0+）：
    根据 lower_case_table_names 系统变量决定：
    - 0 (Unix/Linux): 大小写敏感，保留原样 (CREATE TABLE MyTable → stored as MyTable, MyTable!=mytable)
    - 1 (Windows): 存储为小写，比较不敏感 (CREATE TABLE MyTable → stored as mytable, MyTable=mytable=MYTABLE)
    - 2 (macOS): 存储保留原样，比较不敏感 (CREATE TABLE MyTable → stored as MyTable, MyTable=mytable=MYTABLE)
    与 Legacy TSQLEnv 兼容性：
    - columnCollationCaseSensitive = false → ⚠️ PARTIAL (legacy folded to UPPER, new doesn't fold or folds to LOWER)
    - functionCollationCaseSensitive = false → ⚠️ PARTIAL (legacy folded to UPPER, new doesn't fold)
    - tableCollationCaseSensitive = false → ⚠️ PARTIAL (legacy folded to UPPER, new behavior depends on lower_case_table_names)
    - catalogCollationCaseSensitive = true → ⚠️ PARTIAL (legacy preserved case, new is insensitive)
    测试用例影响：
    - ✅ 新规则正确：MySQL 的行为确实依赖 lower_case_table_names 设置
    - ⚠️ 如果旧测试期望 "MyTable" → "MYTABLE"，则在模式 1/2 下测试会失败
    - ⚠️ 模式 0: 应期望保留原样 (如 "MyTable" 保持为 "MyTable")，区分大小写
    - ⚠️ 模式 1: 应期望小写 (如 "MyTable" → "mytable")，不区分大小写
    - ⚠️ 模式 2: 应期望保留原样 (如 "MyTable" 保持为 "MyTable")，不区分大小写
    IdentifierRules 配置：
    - 模式 0: 不折叠 (IdentifierRules.CaseFold.NONE), 敏感 (IdentifierRules.CaseCompare.SENSITIVE)
    - 模式 1: 折叠为小写 (IdentifierRules.CaseFold.LOWER), 不敏感 (IdentifierRules.CaseCompare.INSENSITIVE)
    - 模式 2: 不折叠 (IdentifierRules.CaseFold.NONE), 不敏感 (IdentifierRules.CaseCompare.INSENSITIVE)
    - Quoted: 保留原样，但也不敏感 (MySQL 特殊行为)
    Since 2026-10-11 this is the shape the MySQL-like FORKS share (OceanBase, Doris, StarRocks), none verified on its own engine. EDbVendor.dbvmysql itself uses forMySQLNative(int).
    Parameters:
    
    lowerCaseTableNames - lower_case_table_names 值（0, 1, 2）
  - forMySQLNative
```
public static IdentifierRules forMySQLNative(int lowerCaseTableNames)
```
    MySQL table / schema / table-alias names, as verified on MySQL 8.4.10, used by EDbVendor.dbvmysql.
    - lower_case_table_names = 0: stored as given, case-sensitive (unchanged).
    - 1: every name, quoted or not, is lowered with MySQL's one-to-one per-character mapping (IdentifierRules.CaseFold.LOWER_SIMPLE); quoting does not create another name. CREATE TABLE İ is stored as i, and FROM İ, FROM `İ` and FROM i all find it. The quoted branch keeps its spelling as the stored form GSP reports but compares by the same mapping (IdentifierRules.CaseCollapse.LOWER_SIMPLE).
    - 2: stored as given, compared by the same lowercase mapping.
    SQL-LR mysql/rules-1: cells U_LOWER_SIMPLE_CI__Q_LOWER_SIMPLE_CI and, for lowerCaseTableNames = 0, U_NONE_CS__Q_NONE_CS.
    Parameters:
    
    lowerCaseTableNames - lower_case_table_names 值（0, 1, 2）
  - forMySQLNativeColumn
```
public static IdentifierRules forMySQLNativeColumn()
```
    MySQL column, column-alias and index names, as verified on MySQL 8.4.10: kept as written and compared by the simple lowercase mapping (IdentifierRules.CaseCollapse.LOWER_SIMPLE), whatever lower_case_table_names is. CREATE TABLE c1(`ſ` int, s int) and c2(`ς` int, `σ` int) succeed: those are distinct columns, which Unicode case folding would merge. Index names follow the same rule (INDEX Idx then ADD INDEX idx fails with ERROR 1061 even under lower_case_table_names = 0).
  - forMySQLNativeRoutine
```
public static IdentifierRules forMySQLNativeRoutine()
```
    MySQL function, procedure and routine-parameter names, as verified on MySQL 8.4.10: kept as written; two names are the same when their simple UPPERCASE forms are equal (IdentifierRules.CaseCollapse.UPPER_SIMPLE), whatever lower_case_table_names is. CREATE FUNCTION `ı`() is called by SELECT i(), and a later CREATE FUNCTION i() fails as already existing; CREATE PROCEDURE pr(P int, p int) fails with ERROR 1330 under lower_case_table_names = 0.
  - forMySQLColumn
```
public static IdentifierRules forMySQLColumn()
```
    MySQL 列名规则（始终大小写不敏感）
    实际数据库行为（MySQL 8.0+）：
    - 列名始终大小写不敏感，不受 lower_case_table_names 影响
    - 存储时保留原样，比较时不敏感 (SELECT MyColumn → stored as MyColumn, MyColumn=mycolumn)
    与 Legacy TSQLEnv 兼容性：
    - columnCollationCaseSensitive = false → ⚠️ PARTIAL (legacy folded to UPPER, new preserves case but is INSENSITIVE)
    Since 2026-10-11 the shape of the forks only; MySQL itself uses forMySQLNativeColumn().
  - forMySQLRoutine
```
public static IdentifierRules forMySQLRoutine()
```
    MySQL 函数名规则（始终大小写不敏感）
    实际数据库行为（MySQL 8.0+）：
    - 函数名/存储过程名始终大小写不敏感
    - 存储时保留原样，比较时不敏感 (与列名相同)
    与 Legacy TSQLEnv 兼容性：
    - functionCollationCaseSensitive = false → ⚠️ PARTIAL (legacy folded to UPPER, new preserves case but is INSENSITIVE)
    Since 2026-10-11 the shape of the forks only; MySQL itself uses forMySQLNativeRoutine().
  - forBigQueryTable
```
public static IdentifierRules forBigQueryTable()
```
    BigQuery 表名规则（大小写敏感）
    实际数据库行为（BigQuery Standard SQL）：
    - Unquoted: 保留原样，比较敏感 (CREATE TABLE MyTable → stored as MyTable, MyTable!=mytable)
    - Quoted: 保留原样，比较敏感 (CREATE TABLE `MyTable` → stored as MyTable, MyTable!=mytable)
    - 表名/dataset名/project名都是大小写敏感的
    与 Legacy TSQLEnv 兼容性：
    - tableCollationCaseSensitive = false → ❌ INCOMPATIBLE (legacy folded to UPPER, new preserves case and is SENSITIVE)
    - catalogCollationCaseSensitive = false → ❌ INCOMPATIBLE (legacy folded to UPPER, new preserves case and is SENSITIVE)
    测试用例影响：
    - ✅ 新规则正确：BigQuery 表名确实是大小写敏感的
    - ⚠️ 如果旧测试期望 "MyTable" → "MYTABLE"，则测试会失败
    - ⚠️ 应更新测试期望为保留原样 (如 "MyTable" 保持为 "MyTable")
    - ⚠️ 旧代码可能错误地匹配了不同大小写的表名，新代码会正确拒绝
  - forBigQueryColumn
```
public static IdentifierRules forBigQueryColumn()
```
    BigQuery 列名规则（大小写不敏感）
    实际数据库行为（BigQuery Standard SQL）：
    - Unquoted: 保留原样，比较不敏感 (SELECT MyColumn → stored as MyColumn, MyColumn=mycolumn=MYCOLUMN)
    - Quoted: 保留原样，比较不敏感 (SELECT `MyColumn` → MyColumn=mycolumn)
    - 列名是大小写不敏感的（与表名不同）
    与 Legacy TSQLEnv 兼容性：
    - columnCollationCaseSensitive = false → ⚠️ PARTIAL (legacy folded to UPPER, new preserves case but is INSENSITIVE)
    测试用例影响：
    - ✅ 新规则正确：BigQuery 列名确实是大小写不敏感的
    - ⚠️ 如果旧测试期望 "MyColumn" → "MYCOLUMN"，则测试会失败
    - ⚠️ 应更新测试期望为保留原样 (如 "MyColumn" 保持为 "MyColumn")
    - ✅ 但比较时应忽略大小写 (MyColumn = mycolumn = MYCOLUMN)
  - forDB2
```
public static IdentifierRules forDB2()
```
    DB2 / Netezza / Exasol 标识符规则（与 Oracle 相同）
    实际数据库行为（DB2 11+）：
    - Unquoted: 折叠为大写，比较不敏感 (与 Oracle 相同)
    - Quoted: 保留原样，比较敏感
    与 Legacy TSQLEnv 兼容性：
    - DB2 tableCollationCaseSensitive = true → ❌ INCOMPATIBLE (legacy preserved case, new folds to UPPER)
    - DB2 catalogCollationCaseSensitive = true → ❌ INCOMPATIBLE (legacy preserved case, new folds to UPPER)
    - 参见 forOracle() 的详细说明
  - forSnowflake
```
public static IdentifierRules forSnowflake()
```
    Snowflake 标识符规则（与 Oracle 相同）
    实际数据库行为（Snowflake）：
    - Unquoted: 折叠为大写，比较不敏感 (与 Oracle 相同)
    - Quoted: 保留原样，比较敏感
    与 Legacy TSQLEnv 兼容性：
    - tableCollationCaseSensitive = false → ⚠️ PARTIAL (both fold to UPPER, COMPATIBLE)
    - columnCollationCaseSensitive = false → ⚠️ PARTIAL (both fold to UPPER, COMPATIBLE)
    - 参见 forOracle() 的详细说明
  - forSnowflake
```
public static IdentifierRules forSnowflake(boolean quotedIdentifiersIgnoreCase)
```
    Snowflake 标识符规则（根据 QUOTED_IDENTIFIERS_IGNORE_CASE 决定）
    Snowflake 默认行为：
    - Unquoted: 折叠为大写，比较不敏感（与 Oracle 相同）
    - Quoted: 保留原样，比较敏感
    当 QUOTED_IDENTIFIERS_IGNORE_CASE = TRUE 时：
    - Quoted 标识符也折叠为大写，比较不敏感
    Parameters:
    
    quotedIdentifiersIgnoreCase - Snowflake QUOTED_IDENTIFIERS_IGNORE_CASE 参数
  - forHANA
```
public static IdentifierRules forHANA()
```
    SAP HANA 标识符规则（与 Oracle 相同）
    实际数据库行为（SAP HANA）：
    - Unquoted: 折叠为大写，比较不敏感 (与 Oracle 相同)
    - Quoted: 保留原样，比较敏感
    与 Legacy TSQLEnv 兼容性：
    - tableCollationCaseSensitive = false → ⚠️ PARTIAL (both fold to UPPER, COMPATIBLE)
    - 参见 forOracle() 的详细说明
  - forPresto
```
public static IdentifierRules forPresto()
```
    Presto / Trino 标识符规则
    实际数据库行为（Presto/Trino）：
    - Unquoted: 折叠为小写，比较不敏感 (CREATE TABLE MyTable → stored as mytable)
    - Quoted: 保留原样，但与 unquoted 规则一致（比较时仍不敏感）
    与 Legacy TSQLEnv 兼容性：
    - tableCollationCaseSensitive = false → ⚠️ PARTIAL (legacy folded to UPPER, new folds to LOWER)
    - columnCollationCaseSensitive = false → ⚠️ PARTIAL (legacy folded to UPPER, new folds to LOWER)
    测试用例影响：
    - ✅ 新规则正确：Presto/Trino 折叠为小写，quoted 标识符与 unquoted 规则一致
    - ⚠️ 如果旧测试期望 "MyTable" → "MYTABLE"，则测试会失败
    - ⚠️ 应更新测试期望为小写 (如 "MyTable" → "mytable")
    IdentifierRules 配置：
    - Unquoted: 折叠为小写 (IdentifierRules.CaseFold.LOWER), 不敏感 (IdentifierRules.CaseCompare.INSENSITIVE)
    - Quoted: 保留原样 (IdentifierRules.CaseFold.NONE), 与 unquoted 一致 (IdentifierRules.CaseCompare.SAME_AS_UNQUOTED)
  - forVertica
```
public static IdentifierRules forVertica()
```
    Vertica 标识符规则（与 Presto 相同）
    实际数据库行为（Vertica）：
    - Unquoted: 折叠为小写，比较不敏感 (与 Presto 相同)
    - Quoted: 保留原样，但与 unquoted 规则一致
    与 Legacy TSQLEnv 兼容性：
    - tableCollationCaseSensitive = false → ⚠️ PARTIAL (legacy folded to UPPER, new folds to LOWER)
    - 参见 forPresto() 的详细说明
  - forHive
```
public static IdentifierRules forHive()
```
    Hive / SparkSQL / Impala / Databricks 标识符规则
    实际数据库行为：反引号只允许名字里出现特殊字符和保留字，不改变大小写规则，所以 `Orders`、`ORDERS` 与 orders 是同一个对象：
    - Hive (LanguageManual DDL): "Table names and column names are case insensitive"
    - Spark SQL (Identifiers): "Both regular identifiers and delimited identifiers are case-insensitive."
    - Impala (Overview of Impala Identifiers): t1 and T1 "always refer to the same table, regardless of quote characters"; names are folded to lowercase
    - Databricks (Identifiers): "Identifiers are case-insensitive when referenced."
    IdentifierRules 配置：
    - Unquoted: 折叠为小写 (IdentifierRules.CaseFold.LOWER), 比较不敏感 (IdentifierRules.CaseCompare.INSENSITIVE)
    - Quoted: 保留原样 (IdentifierRules.CaseFold.NONE), 比较不敏感 (IdentifierRules.CaseCompare.INSENSITIVE)
    Quoted 不折叠：Spark / Databricks 的列名保留大小写（元数据里的 `Amount` 显示为 Amount），只是比较时不区分；折叠会把元数据的写法改成小写。
    与 Legacy TSQLEnv 兼容性：
    - tableCollationCaseSensitive = false → ⚠️ PARTIAL (legacy folded to UPPER, new folds to LOWER)
  - forTeradata
```
public static IdentifierRules forTeradata()
```
    Teradata 标识符规则
    实际数据库行为：对象名不区分大小写，加不加双引号都一样；双引号只允许名字里出现特殊字符和保留字。所以 "ORDERS"、"Orders" 与 orders 是同一个对象：
    - SAS/ACCESS Teradata naming conventions: "A name, even when enclosed in double quotation marks, is not case sensitive. For example, CUSTOMER is the same as customer."
    - Exasol Teradata migration guide: object names in Teradata are case insensitive
    这对元数据尤其要紧：sqlflow-exporter 导出的 Teradata 名字全部带双引号（'"' || TRIM(TABLENAME) || '"'），SQL 里不带引号的引用必须能找到它们。
    IdentifierRules 配置：
    - Unquoted: 折叠为小写 (IdentifierRules.CaseFold.LOWER), 比较不敏感 (IdentifierRules.CaseCompare.INSENSITIVE)
    - Quoted: 保留原样 (IdentifierRules.CaseFold.NONE), 比较不敏感 (IdentifierRules.CaseCompare.INSENSITIVE)
    Quoted 不折叠：Teradata 按创建时的大小写存名字（元数据里的 "ORDERS" 显示为 ORDERS），只是比较时不区分。
    与 Legacy TSQLEnv 兼容性：
    - tableCollationCaseSensitive = false → ⚠️ PARTIAL (legacy folded to UPPER, new folds to LOWER)
  - forAthena
```
public static IdentifierRules forAthena()
```
    Athena 标识符规则（与 Presto 相同）
    实际数据库行为（AWS Athena）：
    - Unquoted: 折叠为小写，比较不敏感 (与 Presto 相同，基于 Trino/Presto)
    - Quoted: 保留原样，但与 unquoted 规则一致
    与 Legacy TSQLEnv 兼容性：
    - tableCollationCaseSensitive = false → ⚠️ PARTIAL (legacy folded to UPPER, new folds to LOWER)
    - 参见 forPresto() 的详细说明
  - forGaussDB
```
public static IdentifierRules forGaussDB()
```
    GaussDB 标识符规则（与 PostgreSQL 相同）
    实际数据库行为（华为 GaussDB）：
    - Unquoted: 折叠为小写，比较不敏感 (与 PostgreSQL 相同，基于 PostgreSQL)
    - Quoted: 保留原样，比较敏感
    与 Legacy TSQLEnv 兼容性：
    - tableCollationCaseSensitive = false → ⚠️ PARTIAL (legacy folded to UPPER, new folds to LOWER)
    - 参见 forPostgreSQL() 的详细说明
  - forDatabricks
```
public static IdentifierRules forDatabricks()
```
    Databricks 标识符规则（与 Hive 相同）
    实际数据库行为（Databricks "Identifiers"）： "Identifiers are case-insensitive when referenced."，反引号标识符也一样，按 UTF8_LCASE collation 比较。
    IdentifierRules 配置：见 forHive() （unquoted 与 quoted 都折叠为小写，比较不敏感）。
  - forFlink
```
public static IdentifierRules forFlink()
```
    Apache Flink SQL 标识符规则
    实际数据库行为（Flink SQL Queries Overview）："Flink SQL uses a lexical policy for identifier (table, attribute, function names) similar to Java: The case of identifiers is preserved whether or not they are quoted. After which, identifiers are matched case-sensitively." 反引号只允许名字里出现非字母数字字符，不改变大小写规则。所以 `userId` 与 userId 是同一个名字，而 userId 与 userid 是两个名字。
    IdentifierRules 配置：
    - Unquoted: 保留原样 (IdentifierRules.CaseFold.NONE), 比较敏感 (IdentifierRules.CaseCompare.SENSITIVE)
    - Quoted: 保留原样 (IdentifierRules.CaseFold.NONE), 比较敏感 (IdentifierRules.CaseCompare.SENSITIVE)
    与 Legacy TSQLEnv 兼容性：
    - tableCollationCaseSensitive = false → ❌ INCOMPATIBLE (legacy compared case-insensitively)
  - forDoris
```
public static IdentifierRules forDoris(int lowerCaseTableNames)
```
    Apache Doris 标识符规则（与 MySQL 相同）
    行为说明：
    - Doris 是 MySQL 兼容的 OLAP 数据库
    - 标识符处理遵循 MySQL 的规则
    - 表名/数据库名大小写敏感性取决于操作系统（类似 MySQL lower_case_table_names）
    - 列名始终大小写不敏感
    与 Legacy TSQLEnv 兼容性：
    - tableCollationCaseSensitive = false → ⚠️ PARTIAL
    - catalogCollationCaseSensitive = true → ✅ COMPATIBLE
    Parameters:
    
    lowerCaseTableNames - lower_case_table_names 值（0, 1, 2），默认使用 1
  - forDoris
```
public static IdentifierRules forDoris()
```
    Apache Doris 标识符规则（默认配置，相当于 lower_case_table_names=1）
    行为说明：
    - Doris 是 MySQL 兼容的 OLAP 数据库
    - 默认情况下，表名折叠为小写，比较不敏感
  - forDorisColumn
```
public static IdentifierRules forDorisColumn()
```
    Apache Doris 列名规则（与 MySQL 列名相同，始终大小写不敏感）
  - forStarrocks
```
public static IdentifierRules forStarrocks(int lowerCaseTableNames)
```
    StarRocks 标识符规则（带参数，相当于 MySQL 的 lower_case_table_names）
    行为说明：
    - StarRocks 是 Doris 的分支，MySQL 兼容的 OLAP 数据库
    - 与 Doris 和 MySQL 使用相同的标识符规则
    Parameters:
    
    lowerCaseTableNames - lower_case_table_names 值（0, 1, 2），默认使用 1
  - forStarrocks
```
public static IdentifierRules forStarrocks()
```
    StarRocks 标识符规则（默认配置，相当于 lower_case_table_names=1）
    行为说明：
    - StarRocks 是 Doris 的分支，MySQL 兼容的 OLAP 数据库
    - 默认情况下，表名折叠为小写，比较不敏感
  - forStarrocksColumn
```
public static IdentifierRules forStarrocksColumn()
```
    StarRocks 列名规则（与 MySQL 列名相同，始终大小写不敏感）
  - forSqlite
```
public static IdentifierRules forSqlite()
```
    SQLite 标识符规则
    实际数据库行为（SQLite 3.45.1 实测）：名字不区分大小写，加不加引号都一样，并保留定义时的大小写。CREATE TABLE "Orders" ("Amount" INT) 之后， SELECT amount FROM orders、SELECT "amount" FROM "orders" 都能查到，再建 "orders" 会报 table "orders" already exists。
    IdentifierRules 配置：
    - Unquoted: 折叠为小写 (IdentifierRules.CaseFold.LOWER), 比较不敏感 (IdentifierRules.CaseCompare.INSENSITIVE)
    - Quoted: 保留原样 (IdentifierRules.CaseFold.NONE), 比较不敏感 (IdentifierRules.CaseCompare.INSENSITIVE)
  - forSybase
```
public static IdentifierRules forSybase()
```
    Sybase ASE 标识符规则
    实际数据库行为（SAP IQ "Case-sensitivity of Identifiers" 对 ASE 的说明）： "In Adaptive Server Enterprise, the case-sensitivity of identifiers follows the case-sensitivity of the data"，即由服务器安装时的 sort order 决定；双引号只允许名字里出现特殊字符和保留字，不改变大小写规则。GSP 按大小写不敏感的服务器建模（见 db_collation.md §2.12，与旧 TSQLEnv 一致），所以带不带引号都不区分大小写。 binary sort order（区分大小写）的服务器请用 IdentifierProfile.builder(gudusoft.gsqlparser.EDbVendor) 配置 NONE/SENSITIVE。
    IdentifierRules 配置：
    - Unquoted: 折叠为小写 (IdentifierRules.CaseFold.LOWER), 比较不敏感 (IdentifierRules.CaseCompare.INSENSITIVE)
    - Quoted: 保留原样 (IdentifierRules.CaseFold.NONE), 比较不敏感 (IdentifierRules.CaseCompare.INSENSITIVE)
  - forSqlAnywhere
```
public static IdentifierRules forSqlAnywhere()
```
    SAP IQ / SQL Anywhere 标识符规则
    实际数据库行为：SAP IQ "Case-sensitivity of Identifiers"："SAP Sybase IQ does not support case-sensitive identifiers."；SQL Anywhere "Case Sensitivity"：SQL Anywhere does not support case sensitive identifiers。加不加引号都不区分大小写，并保留定义时的大小写。
    IdentifierRules 配置：
    - Unquoted: 折叠为小写 (IdentifierRules.CaseFold.LOWER), 比较不敏感 (IdentifierRules.CaseCompare.INSENSITIVE)
    - Quoted: 保留原样 (IdentifierRules.CaseFold.NONE), 比较不敏感 (IdentifierRules.CaseCompare.INSENSITIVE)
  - forAccess
```
public static IdentifierRules forAccess()
```
    Microsoft Access 标识符规则
    实际数据库行为：Access 的表名、字段名不区分大小写；方括号只用来引用含特殊字符或保留字的名字，不改变大小写规则，并保留定义时的大小写。
    IdentifierRules 配置：
    - Unquoted: 折叠为小写 (IdentifierRules.CaseFold.LOWER), 比较不敏感 (IdentifierRules.CaseCompare.INSENSITIVE)
    - Quoted: 保留原样 (IdentifierRules.CaseFold.NONE), 比较不敏感 (IdentifierRules.CaseCompare.INSENSITIVE)
  - forDax
```
public static IdentifierRules forDax()
```
    DAX 标识符规则
    实际行为（Microsoft Learn "DAX syntax"）："All object names are case-insensitive; for example, the names SALES and Sales would represent the same table." 单引号表名 'Sales'、方括号列名 [Amount] 也一样。
    IdentifierRules 配置：
    - Unquoted: 折叠为小写 (IdentifierRules.CaseFold.LOWER), 比较不敏感 (IdentifierRules.CaseCompare.INSENSITIVE)
    - Quoted: 保留原样 (IdentifierRules.CaseFold.NONE), 比较不敏感 (IdentifierRules.CaseCompare.INSENSITIVE)
  - forMdx
```
public static IdentifierRules forMdx()
```
    MDX 标识符规则
    实际行为：Analysis Services 默认不区分大小写（SQLBI "Letter case-sensitivity in DAX, Power BI and Analysis Services"：Power BI and Analysis Services are case-insensitive by default），方括号界定的名字 [Measures].[Sales] 与 [measures].[sales] 相同。
    IdentifierRules 配置：
    - Unquoted: 折叠为小写 (IdentifierRules.CaseFold.LOWER), 比较不敏感 (IdentifierRules.CaseCompare.INSENSITIVE)
    - Quoted: 保留原样 (IdentifierRules.CaseFold.NONE), 比较不敏感 (IdentifierRules.CaseCompare.INSENSITIVE)
  - forPowerQuery
```
public static IdentifierRules forPowerQuery()
```
    Power Query M 标识符规则
    实际行为（Microsoft Learn "Power Query M formula language"）：M 区分大小写，变量名、函数名都是（"Because the Power Query M formula language is case sensitive, comparisons between items that are identical but have different cases results in identifying the items as being different"）。#"Name" 形式只允许名字里出现空格等字符，不改变大小写规则。
    IdentifierRules 配置：
    - Unquoted: 保留原样 (IdentifierRules.CaseFold.NONE), 比较敏感 (IdentifierRules.CaseCompare.SENSITIVE)
    - Quoted: 保留原样 (IdentifierRules.CaseFold.NONE), 比较敏感 (IdentifierRules.CaseCompare.SENSITIVE)
  - forDuckDB
```
public static IdentifierRules forDuckDB()
```
    DuckDB 标识符规则
    实际数据库行为（DuckDB "Keywords and Identifiers"）："Identifiers in DuckDB are always case-insensitive, similarly to PostgreSQL. However, unlike PostgreSQL (and some other major SQL implementations), DuckDB also treats quoted identifiers as case-insensitive." 同时保留定义时的大小写。
    IdentifierRules 配置：
    - Unquoted: 折叠为小写 (IdentifierRules.CaseFold.LOWER), 比较不敏感 (IdentifierRules.CaseCompare.INSENSITIVE)
    - Quoted: 保留原样 (IdentifierRules.CaseFold.NONE), 比较不敏感 (IdentifierRules.CaseCompare.INSENSITIVE)
  - forFirebird
```
public static IdentifierRules forFirebird()
```
    Firebird 标识符规则（与 Oracle 相同）
    实际数据库行为（Firebird Language Reference, "Identifiers"）：不带引号的名字按大写存储，带引号的名字按原样存储、区分大小写。所以 "FULLNAME" 与 FULLNAME、 fullname、FullName 是同一个名字，而 "FullName" 与 FullName 不是。
    IdentifierRules 配置：
    - Unquoted: 折叠为大写 (IdentifierRules.CaseFold.UPPER), 比较不敏感 (IdentifierRules.CaseCompare.INSENSITIVE)
    - Quoted: 保留原样 (IdentifierRules.CaseFold.NONE), 比较敏感 (IdentifierRules.CaseCompare.SENSITIVE)
  - forAnsi
```
public static IdentifierRules forAnsi()
```
    ANSI / ISO SQL 标识符规则（SQL-92 起的标准，与 Oracle 相同）
    标准行为：regular identifier 不区分大小写，按大写处理（折叠为大写）； delimited identifier 保留原样、区分大小写。所以 "ORDERS" 与 orders 是同一个名字，而 "orders" 与 orders 不是。
    IdentifierRules 配置：
    - Unquoted: 折叠为大写 (IdentifierRules.CaseFold.UPPER), 比较不敏感 (IdentifierRules.CaseCompare.INSENSITIVE)
    - Quoted: 保留原样 (IdentifierRules.CaseFold.NONE), 比较敏感 (IdentifierRules.CaseCompare.SENSITIVE)
  - forGeneric
```
public static IdentifierRules forGeneric()
```
    通用规则（dbvgeneric）：没有具体方言时按 SQL 标准，见 forAnsi()
  - resolvedCell
```
public IdentifierRules resolvedCell()
```
    This cell with IdentifierRules.CaseCompare.SAME_AS_UNQUOTED resolved — the form that identifies a rule domain, so two cells that behave identically are not treated as two domains merely because one spells its quoted compare as "same as unquoted".
    
    Returns:
    
    this when nothing needs resolving, else the resolved equivalent
  - equals
```
public boolean equals(Object o)
```
    Overrides:
    
    equals in class Object
  - hashCode
```
public int hashCode()
```
    Overrides:
    
    hashCode in class Object
  - toString
```
public String toString()
```
    Overrides:
    
    toString in class Object

Class IdentifierRules

Nested Class Summary

Field Summary

Constructor Summary

Method Summary

Methods inherited from class Object

Field Detail

unquotedFold

unquotedCompare

quotedFold

quotedCompare

collapse

maxUtf8Bytes

POSTGRESQL_MAX_IDENTIFIER_BYTES

Constructor Detail

IdentifierRules

IdentifierRules

Method Detail

forOracle

forOracleNative

forDameng

forPostgreSQL

forPostgreSQLNative

forRedshift

forCouchbase

forSQLServer

forSQLServer

forMySQL

forMySQLNative

forMySQLNativeColumn

forMySQLNativeRoutine

forMySQLColumn

forMySQLRoutine

forBigQueryTable

forBigQueryColumn

forDB2

forSnowflake

forSnowflake

forHANA

forPresto

forVertica

forHive

forTeradata

forAthena

forGaussDB

forDatabricks

forFlink

forDoris

forDoris

forDorisColumn

forStarrocks

forStarrocks

forStarrocksColumn

forSqlite

forSybase

forSqlAnywhere

forAccess

forDax

forMdx

forPowerQuery

forDuckDB

forFirebird

forAnsi

forGeneric

resolvedCell

equals

hashCode

toString