SubqueryNamespace (General SQL Parser Java Library Core 4.1.5.3 API)

Object
- gudusoft.gsqlparser.resolver2.namespace.AbstractNamespace
- - gudusoft.gsqlparser.resolver2.namespace.SubqueryNamespace

All Implemented Interfaces:

INamespace
```
public class SubqueryNamespace
extends AbstractNamespace
```
Namespace representing a subquery. Provides columns from the subquery's SELECT list. Example: FROM (SELECT id, name FROM users) AS t ^^^^^^^^^^^^^^^^^^^^^^^^ SubqueryNamespace exposes columns: id, name

Field Summary
- Fields inherited from class gudusoft.gsqlparser.resolver2.namespace.AbstractNamespace
  columnSources, columnSourcesWithRefs, guessColumnStrategy, nameMatcher, node, referenceTraceabilityEnabled, validated

Constructor Summary

Constructors
Constructor and Description
`SubqueryNamespace(TSelectSqlStatement subquery, String alias)`
`SubqueryNamespace(TSelectSqlStatement subquery, String alias, INameMatcher nameMatcher)`
`SubqueryNamespace(TSelectSqlStatement subquery, String alias, INameMatcher nameMatcher, boolean fromTableFunction)`

Method Summary

All Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`boolean`	`addInferredColumn(String columnName, double confidence, String evidence)` Add an inferred column to this namespace.
`protected void`	`doValidate()` Subclasses override this to perform actual validation logic.
`List<TTable>`	`getAllFinalTables()` Get all final physical tables this namespace depends on.
`String`	`getDisplayName()` Get a display name for this namespace (for debugging/error messages)
`TTable`	`getFinalTable()` Get the final physical table this namespace represents.
`Set<String>`	`getInferredColumns()` Get all columns that were inferred (not from SELECT list directly).
`MetadataState`	`getMetadataState()` Slice S4 (plan §5.5): a derived subquery's projection is authoritative once validated AND at least one named (non-star) column exists.
`TSelectSqlStatement`	`getSelectStatement()` Get the underlying SELECT statement for this namespace.
`TTable`	`getSourceTable()` Get the TTable that this namespace is associated with.
`TSQLEnv`	`getSqlEnv()` Get the TSQLEnv used for metadata lookup.
`TResultColumn`	`getStarColumn()` Get the first star column (TResultColumn) from this subquery's SELECT list.
`TSelectSqlStatement`	`getSubquery()`
`boolean`	`hasAmbiguousStar()` Check if this subquery has an unqualified star with multiple tables.
`ColumnLevel`	`hasAuthoritativeOutputColumn(String columnName)` Binding-diagnostic view of the derived-table output schema.
`ColumnLevel`	`hasColumn(String columnName)` Check if a column exists in this namespace.
`boolean`	`hasStarColumn()` Check if this namespace contains a star column (SELECT *).
`boolean`	`isFromTableFunction()` Returns true if this namespace was created from a TABLE function's subquery.
`ColumnSource`	`resolveColumn(String columnName)` Resolve a column name to its source.
`ColumnSource`	`resolveColumnInFromScope(String columnName)` Resolve a column in the FROM scope (child namespaces).
`void`	`setSourceTable(TTable sourceTable)` Set the TTable that wraps this subquery.
`void`	`setSqlEnv(TSQLEnv sqlEnv)` Set the TSQLEnv for metadata lookup.
`boolean`	`supportsDynamicInference()` Check if this namespace supports dynamic column inference.
`String`	`toString()`

Methods inherited from class gudusoft.gsqlparser.resolver2.namespace.AbstractNamespace
addColumnSource, addColumnSource, containsColumnByMatcher, containsColumnNameByMatcher, enableReferenceTraceability, ensureValidated, getAllColumnSources, getAllUniqueColumns, getColumnReferences, getColumnSourceWithReferences, getGuessColumnStrategy, getNameMatcher, getNode, isReferenceTraceabilityEnabled, isValidated, setGuessColumnStrategy, validate

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

Methods inherited from interface gudusoft.gsqlparser.resolver2.namespace.INamespace
resolveColumnPath

- Constructor Detail
  - SubqueryNamespace
```
public SubqueryNamespace(TSelectSqlStatement subquery,
                         String alias,
                         INameMatcher nameMatcher)
```
  - SubqueryNamespace
```
public SubqueryNamespace(TSelectSqlStatement subquery,
                         String alias,
                         INameMatcher nameMatcher,
                         boolean fromTableFunction)
```
  - SubqueryNamespace
```
public SubqueryNamespace(TSelectSqlStatement subquery,
                         String alias)
```
- Method Detail
  - isFromTableFunction
```
public boolean isFromTableFunction()
```
    Returns true if this namespace was created from a TABLE function's subquery.
  - setSourceTable
```
public void setSourceTable(TTable sourceTable)
```
    Set the TTable that wraps this subquery. Used by ScopeBuilder for legacy sync support.
    
    Parameters:
    
    sourceTable - the TTable that contains this subquery
  - getSourceTable
```
public TTable getSourceTable()
```
    Description copied from interface: INamespace
    
    Get the TTable that this namespace is associated with. Used for legacy sync to set TObjectName.sourceTable. For TableNamespace: returns the table itself For SubqueryNamespace: returns the TTable wrapping the subquery For CTENamespace: returns the CTE referencing table For others: returns null
    
    Returns:
    
    The source TTable, or null if not applicable
  - setSqlEnv
```
public void setSqlEnv(TSQLEnv sqlEnv)
```
    Set the TSQLEnv for metadata lookup. Used when resolving star columns to find which columns exist in underlying tables.
    
    Parameters:
    
    sqlEnv - the SQL environment containing table metadata
  - getSqlEnv
```
public TSQLEnv getSqlEnv()
```
    Get the TSQLEnv used for metadata lookup.
    
    Returns:
    
    the SQL environment, or null if not set
  - getDisplayName
```
public String getDisplayName()
```
    Description copied from interface: INamespace
    
    Get a display name for this namespace (for debugging/error messages)
  - getFinalTable
```
public TTable getFinalTable()
```
    Description copied from interface: INamespace
    
    Get the final physical table this namespace represents. For tables: returns the table itself For subqueries/CTEs: recursively traces back to physical table(s)
    
    Returns:
    
    Physical table, or null if not determinable
  - getAllFinalTables
```
public List<TTable> getAllFinalTables()
```
    Description copied from interface: INamespace
    
    Get all final physical tables this namespace depends on. For simple table namespace: returns single table For subquery/CTE: returns all tables in the query tree
    
    Specified by:
    
    getAllFinalTables in interface INamespace
    
    Overrides:
    
    getAllFinalTables in class AbstractNamespace
    
    Returns:
    
    List of all physical tables
  - doValidate
```
protected void doValidate()
```
    Description copied from class: AbstractNamespace
    
    Subclasses override this to perform actual validation logic.
    
    Specified by:
    
    doValidate in class AbstractNamespace
  - hasColumn
```
public ColumnLevel hasColumn(String columnName)
```
    Description copied from interface: INamespace
    
    Check if a column exists in this namespace. Returns a three-level answer: EXISTS, MAYBE, NOT_EXISTS
    
    Specified by:
    
    hasColumn in interface INamespace
    
    Overrides:
    
    hasColumn in class AbstractNamespace
    
    Parameters:
    
    columnName - Column name to check
    
    Returns:
    
    Column existence level
  - getSubquery
```
public TSelectSqlStatement getSubquery()
```
  - getSelectStatement
```
public TSelectSqlStatement getSelectStatement()
```
    Description copied from interface: INamespace
    
    Get the underlying SELECT statement for this namespace. For CTENamespace: returns the CTE's subquery For SubqueryNamespace: returns the subquery For TableNamespace: returns null
    
    Returns:
    
    the SELECT statement, or null if not applicable
  - hasStarColumn
```
public boolean hasStarColumn()
```
    Description copied from interface: INamespace
    
    Check if this namespace contains a star column (SELECT *). Used to identify namespaces that may need star column inference.
    
    Returns:
    
    true if the namespace has SELECT *, false otherwise
  - getMetadataState
```
public MetadataState getMetadataState()
```
    Slice S4 (plan §5.5): a derived subquery's projection is authoritative once validated AND at least one named (non-star) column exists. A subquery whose only projection is SELECT * is reported as METADATA_UNAVAILABLE here — S10 refines this when the underlying tables' star expansion fully resolves into named columns.
    
    Returns:
    
    the metadata state; never null
  - hasAuthoritativeOutputColumn
```
public ColumnLevel hasAuthoritativeOutputColumn(String columnName)
```
    Binding-diagnostic view of the derived-table output schema.
    This deliberately avoids the legacy resolution fallbacks in resolveColumn(String). Binding diagnostics need the SQL-visible derived projection: named SELECT-list columns and already inferred star output columns are visible; hidden base-table columns are not. When the projection includes a star and the requested column is not already known, the output is not fully authoritative, so callers must not report a missing-output error.
  - getStarColumn
```
public TResultColumn getStarColumn()
```
    Get the first star column (TResultColumn) from this subquery's SELECT list. Used to track the definition node for columns inferred from the star.
    
    Returns:
    
    The star column, or null if no star column exists
  - hasAmbiguousStar
```
public boolean hasAmbiguousStar()
```
    Check if this subquery has an unqualified star with multiple tables. In this case, columns are ambiguous and should NOT be auto-resolved. Example: SELECT * FROM table_a, table_c -- ambiguous, columns could come from either table SELECT ta.* FROM table_a ta, table_c tc -- NOT ambiguous, star is qualified SELECT * FROM table_a JOIN table_c ON ... -- ambiguous, columns from both tables Uses getRelations() and TJoinExpr to properly count tables in JOINs.
  - supportsDynamicInference
```
public boolean supportsDynamicInference()
```
    Description copied from interface: INamespace
    
    Check if this namespace supports dynamic column inference. DynamicStarSource and similar namespaces return true.
    
    Returns:
    
    true if this namespace can have columns added dynamically
  - addInferredColumn
```
public boolean addInferredColumn(String columnName,
                                 double confidence,
                                 String evidence)
```
    Description copied from interface: INamespace
    
    Add an inferred column to this namespace. Used by star column push-down to add columns discovered from outer queries.
    
    Parameters:
    
    columnName - the column name to add
    
    confidence - the confidence score (0.0 to 1.0)
    
    evidence - description of why this column was inferred
    
    Returns:
    
    true if the column was added, false if already exists
  - getInferredColumns
```
public Set<String> getInferredColumns()
```
    Description copied from interface: INamespace
    
    Get all columns that were inferred (not from SELECT list directly). These are columns discovered through star column push-down.
    
    Returns:
    
    set of inferred column names, empty if none
  - resolveColumn
```
public ColumnSource resolveColumn(String columnName)
```
    Description copied from interface: INamespace
    
    Resolve a column name to its source.
    
    Specified by:
    
    resolveColumn in interface INamespace
    
    Overrides:
    
    resolveColumn in class AbstractNamespace
    
    Parameters:
    
    columnName - Column name to resolve
    
    Returns:
    
    ColumnSource if found, null otherwise
  - resolveColumnInFromScope
```
public ColumnSource resolveColumnInFromScope(String columnName)
```
    Resolve a column in the FROM scope (child namespaces). This finds where a column originates from in the FROM clause tables/subqueries.
    Unlike resolveColumn() which returns columns from THIS subquery's SELECT list, this method looks into the FROM clause to find the underlying definition.
    
    IMPORTANT: For TableNamespace, this only returns columns that exist in actual metadata (from DDL or SQLEnv). It does NOT use inferred columns. This is critical for multi-table star resolution where we need to know which table actually has the column based on metadata, not inference.
    
    Parameters:
    
    columnName - The column name to find
    
    Returns:
    
    ColumnSource from the FROM clause, or null if not found
  - toString
```
public String toString()
```
    Overrides:
    
    toString in class AbstractNamespace

Class SubqueryNamespace

Field Summary

Fields inherited from class gudusoft.gsqlparser.resolver2.namespace.AbstractNamespace

Constructor Summary

Method Summary

Methods inherited from class gudusoft.gsqlparser.resolver2.namespace.AbstractNamespace

Methods inherited from class Object

Methods inherited from interface gudusoft.gsqlparser.resolver2.namespace.INamespace

Constructor Detail

SubqueryNamespace

SubqueryNamespace

SubqueryNamespace

Method Detail

isFromTableFunction

setSourceTable

getSourceTable

setSqlEnv

getSqlEnv

getDisplayName

getFinalTable

getAllFinalTables

doValidate

hasColumn

getSubquery

getSelectStatement

hasStarColumn

getMetadataState

hasAuthoritativeOutputColumn

getStarColumn

hasAmbiguousStar

supportsDynamicInference

addInferredColumn

getInferredColumns

resolveColumn

resolveColumnInFromScope

toString