QualifiedName (General SQL Parser Java Library Core 4.1.0.5 API)

Object
- gudusoft.gsqlparser.resolver2.model.QualifiedName

```
public class QualifiedName
extends Object
```
Represents a fully qualified name for a database object (table, view, etc.).
A qualified name can be represented in two ways:
1. As a list of parts (legacy mode) - for generic N-part names
2. As explicit catalog/schema/name (structured mode) - for table names
For table names, the structured fields provide:
- catalog (database) - The top-level container (e.g., "mydb")
- schema - The schema within the catalog (e.g., "dbo", "public")
- name - The object name itself (e.g., "users", "orders")
Usage Examples
```
 // Legacy list-based construction
 QualifiedName q1 = new QualifiedName("schema", "table");

 // Structured table name construction
 QualifiedName q2 = QualifiedName.forTable("mydb", "dbo", "users");

 // Apply defaults for unqualified names
 QualifiedName q3 = QualifiedName.forTable(null, null, "users")
     .withDefaults("mydb", "dbo");
 // Result: catalog=mydb, schema=dbo, name=users
 
```
See Also:

QualifiedNameResolver

Constructor Summary

Constructors
Constructor and Description
`QualifiedName(List<String> parts)` Create a qualified name from a list of parts (legacy mode).
`QualifiedName(String... parts)` Create a qualified name from varargs parts (legacy mode).

Method Summary

All Methods Static Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`QualifiedName`	`append(String part)` Returns a new qualified name with an additional part appended (legacy mode).
`boolean`	`equals(Object o)`
`boolean`	`equalsIgnoreCase(QualifiedName other)` Check equality ignoring case.
`static QualifiedName`	`forTable(String tableName)` Create a qualified name from just the table name.
`static QualifiedName`	`forTable(String schema, String tableName)` Create a qualified name from schema and table name.
`static QualifiedName`	`forTable(String catalog, String schema, String tableName)` Create a structured qualified name for a table.
`String`	`getCatalog()` Get the catalog (database) part.
`String`	`getFirstPart()`
`String`	`getLastPart()`
`String`	`getName()` Alias for getTableName() - returns the object name.
`String`	`getPart(int index)`
`int`	`getPartCount()`
`List<String>`	`getParts()`
`String`	`getSchema()` Get the schema part.
`String`	`getTableName()` Get the table name.
`boolean`	`hasCatalog()` Check if this qualified name has a catalog specified.
`int`	`hashCode()`
`boolean`	`hasSchema()` Check if this qualified name has a schema specified.
`boolean`	`isFullyQualified()` Check if this is a fully qualified name (all three parts in structured mode).
`boolean`	`isStructuredMode()` Check if this instance uses structured mode.
`boolean`	`matches(QualifiedName other, INameMatcher matcher)` Check if this qualified name matches another, using the given name matcher.
`boolean`	`matchesExact(QualifiedName other, INameMatcher matcher)` Check exact match (all parts must match, including nulls).
`QualifiedName`	`prepend(String part)` Returns a new qualified name with an additional part prepended (legacy mode).
`QualifiedName`	`removeFirst()` Returns a new qualified name with the first part removed (legacy mode).
`QualifiedName`	`toFullyQualified(String defaultCatalog, String defaultSchema)` Create a fully qualified name by applying defaults for all missing parts.
`String`	`toNormalizedKey()` Create a key suitable for use in maps/sets.
`String`	`toString()`
`String`	`toStringWithPlaceholders(String catalogPlaceholder, String schemaPlaceholder)` Convert to a fully qualified string representation, using placeholders for missing parts.
`QualifiedName`	`withDefaults(String defaultCatalog, String defaultSchema)` Create a new qualified name by filling in missing parts from defaults.

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

- Constructor Detail
  - QualifiedName
```
public QualifiedName(List<String> parts)
```
    Create a qualified name from a list of parts (legacy mode).
  - QualifiedName
```
public QualifiedName(String... parts)
```
    Create a qualified name from varargs parts (legacy mode).
- Method Detail
  - forTable
```
public static QualifiedName forTable(String catalog,
                                     String schema,
                                     String tableName)
```
    Create a structured qualified name for a table.
    
    Parameters:
    
    catalog - The catalog/database name (nullable)
    
    schema - The schema name (nullable)
    
    tableName - The table name (required)
    
    Returns:
    
    A new QualifiedName in structured mode
  - forTable
```
public static QualifiedName forTable(String tableName)
```
    Create a qualified name from just the table name.
  - forTable
```
public static QualifiedName forTable(String schema,
                                     String tableName)
```
    Create a qualified name from schema and table name.
  - getParts
```
public List<String> getParts()
```
  - getPartCount
```
public int getPartCount()
```
  - getPart
```
public String getPart(int index)
```
  - getFirstPart
```
public String getFirstPart()
```
  - getLastPart
```
public String getLastPart()
```
  - getCatalog
```
public String getCatalog()
```
    Get the catalog (database) part. Only meaningful in structured mode.
  - getSchema
```
public String getSchema()
```
    Get the schema part. Only meaningful in structured mode.
  - getTableName
```
public String getTableName()
```
    Get the table name. In structured mode, returns the explicit table name. In legacy mode, returns the last part.
  - getName
```
public String getName()
```
    Alias for getTableName() - returns the object name.
  - isStructuredMode
```
public boolean isStructuredMode()
```
    Check if this instance uses structured mode.
  - hasCatalog
```
public boolean hasCatalog()
```
    Check if this qualified name has a catalog specified.
  - hasSchema
```
public boolean hasSchema()
```
    Check if this qualified name has a schema specified.
  - isFullyQualified
```
public boolean isFullyQualified()
```
    Check if this is a fully qualified name (all three parts in structured mode).
  - removeFirst
```
public QualifiedName removeFirst()
```
    Returns a new qualified name with the first part removed (legacy mode).
  - prepend
```
public QualifiedName prepend(String part)
```
    Returns a new qualified name with an additional part prepended (legacy mode).
  - append
```
public QualifiedName append(String part)
```
    Returns a new qualified name with an additional part appended (legacy mode).
  - withDefaults
```
public QualifiedName withDefaults(String defaultCatalog,
                                  String defaultSchema)
```
    Create a new qualified name by filling in missing parts from defaults.
    This does NOT override existing parts - it only fills in nulls. Only works in structured mode.
    
    Parameters:
    
    defaultCatalog - The default catalog to use if this.catalog is null
    
    defaultSchema - The default schema to use if this.schema is null
    
    Returns:
    
    A new qualified name with defaults applied
  - toFullyQualified
```
public QualifiedName toFullyQualified(String defaultCatalog,
                                      String defaultSchema)
```
    Create a fully qualified name by applying defaults for all missing parts.
    
    Parameters:
    
    defaultCatalog - The default catalog
    
    defaultSchema - The default schema
    
    Returns:
    
    A fully qualified name (all three parts set)
  - matches
```
public boolean matches(QualifiedName other,
                       INameMatcher matcher)
```
    Check if this qualified name matches another, using the given name matcher.
    Matching rules:
    - Object names must always match
    - If both have schemas, they must match
    - If both have catalogs, they must match
    - Missing parts (null) are treated as wildcards
    Parameters:
    
    other - The other qualified name to compare
    
    matcher - The name matcher for comparison (handles case sensitivity)
    
    Returns:
    
    true if the names match according to the rules
  - matchesExact
```
public boolean matchesExact(QualifiedName other,
                            INameMatcher matcher)
```
    Check exact match (all parts must match, including nulls).
  - toNormalizedKey
```
public String toNormalizedKey()
```
    Create a key suitable for use in maps/sets.
    The key is lowercase and includes all three parts separated by null characters to ensure uniqueness.
  - toString
```
public String toString()
```
    Overrides:
    
    toString in class Object
  - toStringWithPlaceholders
```
public String toStringWithPlaceholders(String catalogPlaceholder,
                                       String schemaPlaceholder)
```
    Convert to a fully qualified string representation, using placeholders for missing parts.
    
    Parameters:
    
    catalogPlaceholder - Placeholder for missing catalog (e.g., "*" or "?")
    
    schemaPlaceholder - Placeholder for missing schema
    
    Returns:
    
    String like "*.*.name" or "catalog.*.name"
  - equals
```
public boolean equals(Object o)
```
    Overrides:
    
    equals in class Object
  - hashCode
```
public int hashCode()
```
    Overrides:
    
    hashCode in class Object
  - equalsIgnoreCase
```
public boolean equalsIgnoreCase(QualifiedName other)
```
    Check equality ignoring case.
    
    Parameters:
    
    other - The other qualified name
    
    Returns:
    
    true if all parts match (ignoring case)

Class QualifiedName

Usage Examples

Constructor Summary

Method Summary

Methods inherited from class Object

Constructor Detail

QualifiedName

QualifiedName

Method Detail

forTable

forTable

forTable

getParts

getPartCount

getPart

getFirstPart

getLastPart

getCatalog

getSchema

getTableName

getName

isStructuredMode

hasCatalog

hasSchema

isFullyQualified

removeFirst

prepend

append

withDefaults

toFullyQualified

matches

matchesExact

toNormalizedKey

toString

toStringWithPlaceholders

equals

hashCode

equalsIgnoreCase