FqlToSqlConverter (P2J - Progress 4GL to Java Conversion and Runtime)

java.lang.Object
- com.goldencode.p2j.persist.orm.FqlToSqlConverter

```
public class FqlToSqlConverter
extends java.lang.Object
```
This class handles conversion of FQL statements into SQL using a specified Dialect. The implementation targets the correctness and performance, so a minimum number of walks on the parsed tree must be executed. TRPL is obviously, excluded.

Nested Class Summary

Nested Classes
Modifier and Type	Class and Description
`private static class`	`FqlToSqlConverter.CompositeDmoInfo` The immutable structure for a composite table.
`private static class`	`FqlToSqlConverter.ContainsRewriteData` Auxiliary date used for CONTAINS UDF call re-writing
`private static class`	`FqlToSqlConverter.FieldInfo` Field info holder
`private static class`	`FqlToSqlConverter.Weight` An immutable structure which contains weight column data.

Field Summary

Fields
Modifier and Type	Field and Description
`private java.lang.String`	`_checkErrorFn` The name of the checkError UDF with prepended dot
`private java.util.ArrayDeque<java.util.HashMap<java.lang.String,DmoMeta>>`	`aliases` The aliases (table names) currently used in this statement.
`private java.util.function.Supplier<java.lang.String>`	`argRef` Supplier of bind parameter placeholder
`private static char`	`ASTERISK` The ASTERISK literal used in aggregate SQL functions.
`private boolean`	`bindParam2SessionVar` Flags that query bind parameters should be mapped to session variables
`private java.util.function.BiConsumer<java.lang.String,java.lang.String>`	`collectAliases` Collector for SELECT fields' aliases
`private java.util.function.BiConsumer<java.lang.String,java.lang.String>`	`collectFields` Collector for SELECT fields' names
`private int`	`columnUid` Counter for making column aliases unique.
`private int`	`complexSubscript` The number of subscript with substitution parameter, like `[?]`.
`private boolean`	`containsErrorHandling` Flag indicating that the query contains error handling
`private java.util.ArrayList<FqlToSqlConverter.ContainsRewriteData>`	`containsRewriteData` Re-write data for CONTAINS operators
`private FqlToSqlConverter.ContainsRewriteData`	`cte4order` CTE used for implicit ordering imposed by CONTAINS
`private int`	`cteNo` generator for the CTE suffix
`private int`	`currentContains` index of currently processed CONTAINS
`private Database`	`db` The database
`private Dialect`	`dialect` The dialect used to construct the SQL statement.
`private boolean`	`forceNoAlias` Flag identifying to alias will be emitted for properties.
`private boolean`	`generateUniqueSqlColumnNames` If this flag is `true`, the selected columns are named.
`private boolean`	`lazyMode` Flag for selecting results in a lazy manner.
`private boolean`	`lockTableRead` Flag indicating that the query reads from _Lock VST
`private static CentralLogger`	`LOG` Logger
`private int`	`maxResults` The maximum numbers of results in a query.
`private int`	`nargs` positional parameters found so far
`private java.util.concurrent.atomic.AtomicInteger`	`nbind` Number of bind parameters.
`private int`	`nCteArgs` number of CTE parameters
`private int`	`nestedInContains` level of nested function calls for the CONTAINS first argument
`private static java.lang.String`	`NO_ALIAS` Constant for a virtual alias when none is specified (used in case of single table statements).
`private int`	`paramCount` The number of SQL parameters encountered during parsing.
`private int[]`	`paraPerm` Parameters permutation.
`private static java.lang.String`	`PK` Name of the primary key column.
`private Query.QueryParams`	`queryParams` Query parameters.
`private boolean`	`queryWasRewritten` Flags the a query was re-written during conversion to SQL
`private DataRelation`	`relation` The recursive DATA-RELATION the query is to FILL for
`private java.util.List<java.lang.String>`	`rowAliases` List of the row fields/ aliases
`private java.util.ArrayList<RowStructure>`	`rowStructure` The structure of the result to be returned.
`private java.lang.StringBuilder`	`sb` The `StringBuilder` used to construct the SQL statement.
`private java.lang.StringBuilder`	`sbProp` The `StringBuilder` used to construct an optional single property name, if not `null`.
`private java.lang.String`	`schema` The schema of the database.
`private java.util.Map<java.lang.String,java.lang.String>`	`selectAliases` SELECT fields' aliases by legacy name
`private java.util.Map<java.lang.String,java.lang.String>`	`selectFields` SELECT fields' names by legacy name
`private java.util.List<FQLPreprocessor.SessionAttr>`	`sessionAttrs` Mutable session attributes' values used in the query
`private java.util.Map<java.lang.String,java.lang.String>`	`sqlTableAliasMap` The aliases used in SQL queries.
`private int`	`startOffset` The offset of the record to start a result with.
`private boolean`	`userTableStatRead` Flag indicating that the query reads from _UserTableStat VST
`private boolean`	`useSqlTableAlias` If this flag is `true` the SQL names will be used for table aliases, otherwise the FQL named received in FQL string will be used.
`private boolean`	`useWordTables` 'use word tables' flag
`private java.lang.StringBuilder`	`weigths` Holder for 'weights' used for implicit ordering imposed by CONTAINS

Constructor Summary

Constructors
Modifier	Constructor and Description
`private`	`FqlToSqlConverter(Dialect dialect, Database db, Query.QueryParams queryParams, boolean useSqlTableAlias)` The constructor is private.

Method Summary

All Methods Static Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`private void`	`appendColAlias(java.lang.String base)` Appends a unique column alias to the sql statement.
`private void`	`appendColAlias(java.lang.String base, boolean addToRowAliases)` Appends a unique column alias to the sql statement.
`boolean`	`bindParam2SessionVar()` Check if the query bind parameters should be mapped to session variables.
`private boolean`	`canUseWildcard(DmoMeta dmoMeta)` Check if we can simply use an `alias.*` syntax instead of listing all SQL fields.
`private void`	`collectNormalizedExtentsAliases(FQLAst node, java.util.Map<java.lang.String,DmoMeta> aliasesMap, java.util.Map<java.lang.String,java.lang.String> innerJoins, java.util.function.BiConsumer<FQLAst,java.util.List<FQLAst>> staticSubscriptConstraints, java.util.function.BiConsumer<FQLAst,java.util.List<FQLAst>> dynamicSubscriptConstraints)` Collects into `aliasesMap` all occurrences of aliases with normalized accesses to extents fields (that is, using bracket `[` notation).
`private void`	`collectTableAliases(FQLAst node, java.util.Map<java.lang.String,DmoMeta> aliases)` Collects the list of aliases declared in a FQL `FROM` or `JOIN`.
`boolean`	`containsErrorHandling()` Checks if the query contains error handling.
`private void`	`containsWithUdf(FqlToSqlConverter.ContainsRewriteData crwd)` Re-write CONTAINS using UDF.
`private void`	`containsWithUdfAndCTE(FqlToSqlConverter.ContainsRewriteData crwd)` Re-write CONTAINS using UDF if corresponding word index is used for sorting
`private void`	`containsWithWordTable(FqlToSqlConverter.ContainsRewriteData crwd)` Re-write CONTAINS using word tables.
`private void`	`containsWithWordTableAndCTE(FqlToSqlConverter.ContainsRewriteData crwd)` Re-write CONTAINS using word tables and CTE.
`private void`	`expandAlias(DmoMeta dmoMeta, java.lang.String alias, boolean first)` Expands the alias into all its properties in a SELECT clause.
`private java.lang.String`	`generateCteName(java.lang.String base, java.util.Set<java.lang.String> tbls)` Generate the alias for the common table expression for CONTAINS re-writing.
`private void`	`generateExpression(FQLAst node)` Recursively walks a FQL predicate and generates the SQL one.
`private java.lang.String`	`generateFrom(FQLAst node, java.util.Map<java.lang.String,java.lang.String> innerJoins)` Generates the list of source tables where the records are to be fetched (ie `FROM` and any type of `JOIN` part.
`private void`	`generateJoin(FQLAst joinNode, java.lang.String rightAlias, DmoMeta rightDmo)` Generates the JOIN part of the query statement.
`private void`	`generateLazyMode()` Add the keyword "lazy" to the end of the SQL.
`private void`	`generateOnClause(FQLAst onClause)` Generates the on clause for a join.
`private void`	`generateOrderBy(FQLAst order)` Generates the `ORDER BY` part of the query.
`private boolean`	`generateOrderByComponent(FQLAst node)` Generates am order-by component.
`private void`	`generatePaging()` Analyzes the `maxResults` and `startOffset` values and constructs the paging clauses.
`private boolean`	`generateProperty(FQLAst node, boolean forceCsPrefix, boolean qualified)` Converts a FQL property to a SQL field name.
`private boolean`	`generateProperty(FQLAst node, boolean forceCsPrefix, boolean qualified, FqlToSqlConverter.FieldInfo fieldInfo)` Converts a FQL property to a SQL field name.
`private boolean`	`generateProperty(FQLAst node, boolean forceCsPrefix, boolean qualified, FqlToSqlConverter.FieldInfo fieldInfo, java.util.Map.Entry<java.lang.String,Property>[] propertyBuffer)` Converts a FQL property to a SQL field name.
`private void`	`generateSet(FQLAst set)` Generate the `SET` phrase for the `UPDATE` statement.
`private void`	`generateSingle(FQLAst single)` Convert the SINGLE FQL token to a dialect-based `LIMIT 1` expression.
`private void`	`generateWhere(FQLAst where, java.util.Map<java.lang.String,java.lang.String> extIdxConstraints)` Generated the `WHERE` predicate of the SQL query.
`static FqlToSqlConverter`	`getInstance(Dialect dialect, Database db)` Builder method for create an instance of this class.
`static FqlToSqlConverter`	`getInstance(Dialect dialect, Database db, Query.QueryParams queryParams)` Builder method for create an instance of this class.
`int`	`getLastConversionParamCount()` Returns the number of parameters in the last converted statement.
`int[]`	`getParameterPermutation()` Obtain the parameter permutation for the converted SQL.
`private DmoMeta`	`getScopedDmoInfo(java.lang.String aliasStr)` Search for a specific alias in the stack of scoped aliases declared by current statement.
`private java.lang.String`	`getSqlColumnAlias(Property property)` Computes an unique SQL name for a field/column.
`private java.lang.String`	`getSqlTableAliasName(java.lang.String alias)` Obtain the SQL table alias for a FQL alias.
`private boolean`	`isBinaryOperator(Aast ast)` Convenience method to detect whether an AST represents a binary operator, based on its token type.
`private boolean`	`isCaseInsensitiveField(FQLAst alias)` Checks whether this is case-insensitive character field.
`boolean`	`isLockTableRead()` Check if the query reads _Lock VST.
`boolean`	`isQueryWasRewritten()` Check if the query was re-written
`boolean`	`isUserTableStatRead()` Check if the query reads _UserTableStat VST.
`static void`	`main(java.lang.String[] args)` Test program.
`private static java.lang.String`	`op(LogicalExpressionConverter.Term token, java.util.List<java.lang.String> args)` Generate a SQL condition ('=' or 'LIKE') for an operation on the CNF.
`private void`	`preprocess(FQLAst root)` TODO: replace upper(rtrim(alias.ch-property)) with alias.__ich-property and rtrim(alias.ch-property) with alias.__sch-property if the dialect requires so (H2) and only if the property is part of an indexed.
`private void`	`processDelete(FQLAst stmt)` Converts a `DELETE` FQL statement into the SQL language.
`private void`	`processSelect(FQLAst stmt)` Converts a `SELECT` FQL statement into the SQL language.
`private void`	`processStatement(FQLAst root, FQLAst[] lastProcessedAst)` Converts any FQL statement into the SQL language.
`private void`	`processUpdate(FQLAst stmt)` Converts a `UPDATE` FQL statement into the SQL language.
`private void`	`rewrite4SecondPass(java.lang.String masterAlias, java.lang.String rCteName, java.lang.String baseCteName, int selectStart, int fromStart, int fromEnd)` Generate second pass query for recursive DATA-RELATION FILL support.
`private void`	`rewriteNoAliasPropertyNodes(java.lang.String alias, FQLAst where)` Rewrite `FQLParserTokenTypes.PROPERTY` ASTs so that they are parented by an `ALIAS` AST.
`private void`	`rewriteSelectDynamicSubscripts(FQLAst whereNode, java.util.List<FQLAst> dynamicSubscripts)` Rewrite the dynamic subscripts in a SELECT's WHERE clause, so that the field's index is matched before testing the field's value, to preserve substitution argument order.
`private void`	`rewriteSubscriptsAsSubselect(FQLAst node, java.util.List<FQLAst> subscripts)` For DELETE and UPDATE statements which reference extent fields in the WHERE clause, these need to be rewritten via subselects.
`java.util.List<FQLPreprocessor.SessionAttr>`	`sessionAttrs()` Get list of mutable session attributes' values used in the query.
`private void`	`setFieldProperty(FqlToSqlConverter.ContainsRewriteData crwd)` Set field property for CONTAINS.
`java.lang.String`	`toSQL(java.lang.String fql, int maxResults, int startOffset, java.util.ArrayList<RowStructure> rowStructure, DataRelation relation, boolean lazyMode)` Converts a `FQL` statement into its SQL representation.
`private static void`	`toUpper(boolean wrap, java.lang.StringBuilder sb, java.lang.Runnable op)` Conditionally wrap operation on a StringBuilder with upper() call.
`private static void`	`warn(java.lang.String msg, FQLAst node)` Logging utility method.

Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

- Field Detail
  - LOG
```
private static final CentralLogger LOG
```
    Logger
  - PK
```
private static final java.lang.String PK
```
    Name of the primary key column.
  - NO_ALIAS
```
private static final java.lang.String NO_ALIAS
```
    Constant for a virtual alias when none is specified (used in case of single table statements).
    
    See Also:
    
    Constant Field Values
  - ASTERISK
```
private static final char ASTERISK
```
    The ASTERISK literal used in aggregate SQL functions.
    
    See Also:
    
    Constant Field Values
  - dialect
```
private final Dialect dialect
```
    The dialect used to construct the SQL statement.
  - db
```
private final Database db
```
    The database
  - schema
```
private final java.lang.String schema
```
    The schema of the database. This is used to unambiguate short-names entities.
  - sb
```
private java.lang.StringBuilder sb
```
    The StringBuilder used to construct the SQL statement.
  - sbProp
```
private java.lang.StringBuilder sbProp
```
    The StringBuilder used to construct an optional single property name, if not null. Ignored otherwise.
  - columnUid
```
private int columnUid
```
    Counter for making column aliases unique.
  - aliases
```
private final java.util.ArrayDeque<java.util.HashMap<java.lang.String,DmoMeta>> aliases
```
    The aliases (table names) currently used in this statement. Each level represents additional aliases added at each nested select. We need to exclude them when their scope ends.
  - sqlTableAliasMap
```
private final java.util.Map<java.lang.String,java.lang.String> sqlTableAliasMap
```
    The aliases used in SQL queries.
  - useSqlTableAlias
```
private final boolean useSqlTableAlias
```
    If this flag is true the SQL names will be used for table aliases, otherwise the FQL named received in FQL string will be used.
  - generateUniqueSqlColumnNames
```
private final boolean generateUniqueSqlColumnNames
```
    If this flag is true, the selected columns are named. An unique name is computed for each column.
  - maxResults
```
private int maxResults
```
    The maximum numbers of results in a query. Used for paging results.
  - lazyMode
```
private boolean lazyMode
```
    Flag for selecting results in a lazy manner. Used in Select statements.
  - startOffset
```
private int startOffset
```
    The offset of the record to start a result with. Used for paging results.
  - paramCount
```
private int paramCount
```
    The number of SQL parameters encountered during parsing.
  - rowStructure
```
private java.util.ArrayList<RowStructure> rowStructure
```
    The structure of the result to be returned. For each record returned, the number of fields is stored in order to facilitate the re-hydration of the result back to Records. This is a by-product of the query statement conversion.
  - complexSubscript
```
private int complexSubscript
```
    The number of subscript with substitution parameter, like [?].
  - forceNoAlias
```
private boolean forceNoAlias
```
    Flag identifying to alias will be emitted for properties. Required by the UPDATE statement.
  - queryParams
```
private final Query.QueryParams queryParams
```
    Query parameters.
  - paraPerm
```
private int[] paraPerm
```
    Parameters permutation.
  - queryWasRewritten
```
private boolean queryWasRewritten
```
    Flags the a query was re-written during conversion to SQL
  - userTableStatRead
```
private boolean userTableStatRead
```
    Flag indicating that the query reads from _UserTableStat VST
  - lockTableRead
```
private boolean lockTableRead
```
    Flag indicating that the query reads from _Lock VST
  - containsRewriteData
```
private final java.util.ArrayList<FqlToSqlConverter.ContainsRewriteData> containsRewriteData
```
    Re-write data for CONTAINS operators
  - nestedInContains
```
private int nestedInContains
```
    level of nested function calls for the CONTAINS first argument
  - currentContains
```
private int currentContains
```
    index of currently processed CONTAINS
  - nargs
```
private int nargs
```
    positional parameters found so far
  - nCteArgs
```
private int nCteArgs
```
    number of CTE parameters
  - cteNo
```
private int cteNo
```
    generator for the CTE suffix
  - cte4order
```
private FqlToSqlConverter.ContainsRewriteData cte4order
```
    CTE used for implicit ordering imposed by CONTAINS
  - weigths
```
private final java.lang.StringBuilder weigths
```
    Holder for 'weights' used for implicit ordering imposed by CONTAINS
  - useWordTables
```
private final boolean useWordTables
```
    'use word tables' flag
  - rowAliases
```
private final java.util.List<java.lang.String> rowAliases
```
    List of the row fields/ aliases
  - relation
```
private DataRelation relation
```
    The recursive DATA-RELATION the query is to FILL for
  - selectAliases
```
private java.util.Map<java.lang.String,java.lang.String> selectAliases
```
    SELECT fields' aliases by legacy name
  - selectFields
```
private java.util.Map<java.lang.String,java.lang.String> selectFields
```
    SELECT fields' names by legacy name
  - collectAliases
```
private java.util.function.BiConsumer<java.lang.String,java.lang.String> collectAliases
```
    Collector for SELECT fields' aliases
  - collectFields
```
private java.util.function.BiConsumer<java.lang.String,java.lang.String> collectFields
```
    Collector for SELECT fields' names
  - bindParam2SessionVar
```
private boolean bindParam2SessionVar
```
    Flags that query bind parameters should be mapped to session variables
  - nbind
```
private final java.util.concurrent.atomic.AtomicInteger nbind
```
    Number of bind parameters.
  - argRef
```
private java.util.function.Supplier<java.lang.String> argRef
```
    Supplier of bind parameter placeholder
  - sessionAttrs
```
private final java.util.List<FQLPreprocessor.SessionAttr> sessionAttrs
```
    Mutable session attributes' values used in the query
  - _checkErrorFn
```
private final java.lang.String _checkErrorFn
```
    The name of the checkError UDF with prepended dot
  - containsErrorHandling
```
private boolean containsErrorHandling
```
    Flag indicating that the query contains error handling
- Constructor Detail
  - FqlToSqlConverter
```
private FqlToSqlConverter(Dialect dialect,
                          Database db,
                          Query.QueryParams queryParams,
                          boolean useSqlTableAlias)
```
    The constructor is private. To create an instance of this class, use the getInstance builder method.
    
    Parameters:
    
    dialect - The SQL dialect to be used when generating SQL statements.
    
    db - The database.
    
    queryParams - queryParameters;
    
    useSqlTableAlias - When true, the SQL names will be used for table aliases, otherwise the FQL named received in FQL string will be kept.
- Method Detail
  - getInstance
```
public static FqlToSqlConverter getInstance(Dialect dialect,
                                            Database db)
```
    Builder method for create an instance of this class.
    
    Parameters:
    
    dialect - The SQL dialect to be used when generating SQL statements.
    
    db - The database.
    
    Returns:
    
    an instance of this class
  - getInstance
```
public static FqlToSqlConverter getInstance(Dialect dialect,
                                            Database db,
                                            Query.QueryParams queryParams)
```
    Builder method for create an instance of this class.
    
    Parameters:
    
    dialect - The SQL dialect to be used when generating SQL statements.
    
    db - The database.
    
    queryParams - The query parameters.
    
    Returns:
    
    an instance of this class
  - isQueryWasRewritten
```
public boolean isQueryWasRewritten()
```
    Check if the query was re-written
    
    Returns:
    
    true if the query was re-written
  - bindParam2SessionVar
```
public boolean bindParam2SessionVar()
```
    Check if the query bind parameters should be mapped to session variables.
    
    Returns:
    
    true if the query parameters should be mapped to session variables.
  - sessionAttrs
```
public java.util.List<FQLPreprocessor.SessionAttr> sessionAttrs()
```
    Get list of mutable session attributes' values used in the query.
    
    Returns:
    
    List of mutable session attributes' values used in the query.
  - containsErrorHandling
```
public boolean containsErrorHandling()
```
    Checks if the query contains error handling.
    
    Returns:
    
    true if the query contains error handling.
  - isUserTableStatRead
```
public boolean isUserTableStatRead()
```
    Check if the query reads _UserTableStat VST.
    
    Returns:
    
    true if the query reads _UserTableStat VST.
  - isLockTableRead
```
public boolean isLockTableRead()
```
    Check if the query reads _Lock VST.
    
    Returns:
    
    true if the query reads _Lock VST.
  - containsWithWordTableAndCTE
```
private void containsWithWordTableAndCTE(FqlToSqlConverter.ContainsRewriteData crwd)
```
    Re-write CONTAINS using word tables and CTE.
    
    Parameters:
    
    crwd - Structure holding the re-write data to be processed.
  - containsWithWordTable
```
private void containsWithWordTable(FqlToSqlConverter.ContainsRewriteData crwd)
```
    Re-write CONTAINS using word tables.
    
    Parameters:
    
    crwd - Structure holding the re-write data to be processed.
  - setFieldProperty
```
private void setFieldProperty(FqlToSqlConverter.ContainsRewriteData crwd)
```
    Set field property for CONTAINS.
    
    Parameters:
    
    crwd - Structure holding the re-write data to be processed.
  - containsWithUdf
```
private void containsWithUdf(FqlToSqlConverter.ContainsRewriteData crwd)
```
    Re-write CONTAINS using UDF.
    
    Parameters:
    
    crwd - Structure holding the re-write data to be processed.
  - containsWithUdfAndCTE
```
private void containsWithUdfAndCTE(FqlToSqlConverter.ContainsRewriteData crwd)
```
    Re-write CONTAINS using UDF if corresponding word index is used for sorting
    
    Parameters:
    
    crwd - Structure holding the re-write data to be processed.
  - toSQL
```
public java.lang.String toSQL(java.lang.String fql,
                              int maxResults,
                              int startOffset,
                              java.util.ArrayList<RowStructure> rowStructure,
                              DataRelation relation,
                              boolean lazyMode)
```
    Converts a FQL statement into its SQL representation.
    
    Parameters:
    
    fql - A valid FQL statement.
    
    maxResults - The maximum numbers of results to be returned.
    
    startOffset - The start offset. Together with maxResults this parameter helps to implement paging of a bigger the result set.
    
    rowStructure - (Acts as an output parameter). If not null, at return, the map will contain the list of entities returned and the number of fields coded in the generated SELECT statement for each of them.
    
    relation - The recursive DATA-RELATION the query is to FILL for.
    
    lazyMode - Should the returned SQL execute the statement in a lazy manner? true if the answer is yes, false otherwise.
    
    Returns:
    
    The SQL representation of the fql.
  - getParameterPermutation
```
public int[] getParameterPermutation()
```
    Obtain the parameter permutation for the converted SQL.
    
    Returns:
    
    The parameter permutation function, if any detected.
  - getLastConversionParamCount
```
public int getLastConversionParamCount()
```
    Returns the number of parameters in the last converted statement.
    
    Returns:
    
    The number of parameters (that is SUBST and POSITIONAL nodes) encountered while processing the last successfully converted FQL statement.
  - preprocess
```
private void preprocess(FQLAst root)
```
    TODO: replace upper(rtrim(alias.ch-property)) with alias.__ich-property and rtrim(alias.ch-property) with alias.__sch-property if the dialect requires so (H2) and only if the property is part of an indexed. WARNING: this should not be done here, see the DatabaseManager.getIgnoreCase usage - the computed column should be emitted explicitly. Does a quick preprocess of the AST tree after the initial parsing. The following transformations are executed:
    - "index(PROPERTY)" is converted to "[ALIAS].list__index [PROPERTY]";
    - "alias.property [PROPERTY]" is converted to "alias [ALIAS].property [PROPERTY]";
    - simplify some (sub-)expressions by dropping the extra LPARENS;
    - simplify [(a = b) = true] to [a = b]
    - counts the parameters in paramCount field;
    - for full-path DMOs, make sure the interface is registered with DmoMetadataManager
    - TO be added as encountered ...
    Parameters:
    
    root - The root of the AST tree of a statement.
  - processStatement
```
private void processStatement(FQLAst root,
                              FQLAst[] lastProcessedAst)
```
    Converts any FQL statement into the SQL language. The output is directly appended to sb.
    
    Parameters:
    
    root - The root of the FQLAst statement.
    
    lastProcessedAst - Output parameter: the last processed Ast. Allow a caller to know where the SUBSELECT ends.
  - processUpdate
```
private void processUpdate(FQLAst stmt)
```
    Converts a UPDATE FQL statement into the SQL language. The output is directly appended to sb.
    
    Parameters:
    
    stmt - The UPDATE FQL statement to be converted.
  - generateSet
```
private void generateSet(FQLAst set)
```
    Generate the SET phrase for the UPDATE statement.
    
    Parameters:
    
    set - The AST for the SET phrase.
  - processDelete
```
private void processDelete(FQLAst stmt)
```
    Converts a DELETE FQL statement into the SQL language. The output is directly appended to sb.
    
    Parameters:
    
    stmt - The UPDATE FQL statement to be converted.
  - rewriteNoAliasPropertyNodes
```
private void rewriteNoAliasPropertyNodes(java.lang.String alias,
                                         FQLAst where)
```
    Rewrite FQLParserTokenTypes.PROPERTY ASTs so that they are parented by an ALIAS AST.
    
    Parameters:
    
    alias - The alias to add to all unqualified properties.
    
    where - The WHERE AST.
  - rewriteSubscriptsAsSubselect
```
private void rewriteSubscriptsAsSubselect(FQLAst node,
                                          java.util.List<FQLAst> subscripts)
```
    For DELETE and UPDATE statements which reference extent fields in the WHERE clause, these need to be rewritten via subselects. The subselect is inlined as a STRING AST, which will be emitted directly by generateExpression(com.goldencode.p2j.persist.orm.FQLAst).
    
    Parameters:
    
    node - The root WHERE node.
    
    subscripts - The list of subscript properties which need to be rewritten.
  - processSelect
```
private void processSelect(FQLAst stmt)
```
    Converts a SELECT FQL statement into the SQL language. The output is directly appended to sb.
    
    Parameters:
    
    stmt - The SELECT FQL statement to be converted.
  - rewrite4SecondPass
```
private void rewrite4SecondPass(java.lang.String masterAlias,
                                java.lang.String rCteName,
                                java.lang.String baseCteName,
                                int selectStart,
                                int fromStart,
                                int fromEnd)
```
    Generate second pass query for recursive DATA-RELATION FILL support.
    
    Parameters:
    
    masterAlias - Alias for the master source table
    
    rCteName - Recursive CTE name
    
    baseCteName - Base CTE name
    
    selectStart - Base SELECT start position
    
    fromStart - Base FROM start position
    
    fromEnd - Base FROM end position
  - generateCteName
```
private java.lang.String generateCteName(java.lang.String base,
                                         java.util.Set<java.lang.String> tbls)
```
    Generate the alias for the common table expression for CONTAINS re-writing.
    
    Parameters:
    
    base - The base of the name
    
    tbls - Set of already used table names/aliases.
    
    Returns:
    
    The generated alias.
  - canUseWildcard
```
private boolean canUseWildcard(DmoMeta dmoMeta)
```
    Check if we can simply use an alias.* syntax instead of listing all SQL fields.
    
    Parameters:
    
    dmoMeta - The meta of the table to be considered for wildcard field selection.
    
    Returns:
    
    true if we can emit an wildcard syntax for field selection.
  - expandAlias
```
private void expandAlias(DmoMeta dmoMeta,
                         java.lang.String alias,
                         boolean first)
```
    Expands the alias into all its properties in a SELECT clause.
    
    Parameters:
    
    dmoMeta - The node meta-data for the node to be expanded.
    
    alias - The node alias (text of the node) to be expanded.
    
    first - true if this is the first expanded node.
  - generatePaging
```
private void generatePaging()
```
    Analyzes the maxResults and startOffset values and constructs the paging clauses.
    Note: MSSQL dialect (SELECT TOP n) not supported at this time.
  - generateLazyMode
```
private void generateLazyMode()
```
    Add the keyword "lazy" to the end of the SQL. This works only when there is a Select statement that is intended to be executed in a lazy manner.
  - generateOrderBy
```
private void generateOrderBy(FQLAst order)
```
    Generates the ORDER BY part of the query. The output is directly appended to sb.
    
    Parameters:
    
    order - The FQL ORDER BY node.
  - generateOrderByComponent
```
private boolean generateOrderByComponent(FQLAst node)
```
    Generates am order-by component. Usually this is equivalent of converting a normal property, but for some dialects (PostgreSQL), some SQL functions are allowed to be used. This method will be called recursively in order to support nested function calls.
    Note: only a one-argument functions are supported (like upper and rtrim used for character fields). If more complex expressions are needed the more generic generateExpression() should be used instead.
    
    Parameters:
    
    node - The root node for this expression.
    
    Returns:
    
    true if this is the '_multiplex' or PK column.
  - generateSingle
```
private void generateSingle(FQLAst single)
```
    Convert the SINGLE FQL token to a dialect-based LIMIT 1 expression.
    
    Parameters:
    
    single - The SINGLE AST. May be null.
  - isCaseInsensitiveField
```
private boolean isCaseInsensitiveField(FQLAst alias)
```
    Checks whether this is case-insensitive character field.
    
    Parameters:
    
    alias - The alias node. This represents the table this property belongs to. Normally it should have a single child, with the name of the PROPERTY.
    
    Returns:
    
    true if this property is detected as a case-insensitive character field.
  - generateProperty
```
private boolean generateProperty(FQLAst node,
                                 boolean forceCsPrefix,
                                 boolean qualified)
```
    Converts a FQL property to a SQL field name. The output is directly appended to sb.
    
    Parameters:
    
    node - The alias or property node. If the former, this represents the table this property belongs to. Normally it should have a single child, with the name of the PROPERTY. If the latter, this represents an unqualified property name (and a single-table statement is assumed).
    
    forceCsPrefix - If true, the dialect specific case-sensitive prefix will be injected.
    
    qualified - true if property is qualified by an alias; false if node represents an unqualified property name.
    
    Returns:
    
    true if this is the '_multiplex' or PK column.
  - generateProperty
```
private boolean generateProperty(FQLAst node,
                                 boolean forceCsPrefix,
                                 boolean qualified,
                                 FqlToSqlConverter.FieldInfo fieldInfo)
```
    Converts a FQL property to a SQL field name. The output is directly appended to sb.
    
    Parameters:
    
    node - The alias or property node. If the former, this represents the table this property belongs to. Normally it should have a single child, with the name of the PROPERTY. If the latter, this represents an unqualified property name (and a single-table statement is assumed).
    
    forceCsPrefix - If true, the dialect specific case-sensitive prefix will be injected.
    
    qualified - true if property is qualified by an alias; false if node represents an unqualified property name.
    
    fieldInfo - Auxiliary structure holding table names and alias
    
    Returns:
    
    true if this is the '_multiplex' or PK column.
  - generateProperty
```
private boolean generateProperty(FQLAst node,
                                 boolean forceCsPrefix,
                                 boolean qualified,
                                 FqlToSqlConverter.FieldInfo fieldInfo,
                                 java.util.Map.Entry<java.lang.String,Property>[] propertyBuffer)
```
    Converts a FQL property to a SQL field name. The output is directly appended to sb.
    
    Parameters:
    
    node - The alias or property node. If the former, this represents the table this property belongs to. Normally it should have a single child, with the name of the PROPERTY. If the latter, this represents an unqualified property name (and a single-table statement is assumed).
    
    forceCsPrefix - If true, the dialect specific case-sensitive prefix will be injected.
    
    qualified - true if property is qualified by an alias; false if node represents an unqualified property name.
    
    fieldInfo - Auxiliary structure holding table names and alias
    
    propertyBuffer - Collects an unqualified property name
    
    Returns:
    
    true if this is the '_multiplex' or PK column.
  - getScopedDmoInfo
```
private DmoMeta getScopedDmoInfo(java.lang.String aliasStr)
```
    Search for a specific alias in the stack of scoped aliases declared by current statement.
    
    Parameters:
    
    aliasStr - The name of the alias to be found.
    
    Returns:
    
    The DmoMeta structure for the specified alias.
  - generateWhere
```
private void generateWhere(FQLAst where,
                           java.util.Map<java.lang.String,java.lang.String> extIdxConstraints)
```
    Generated the WHERE predicate of the SQL query. Walks each FQL node and converts it into a SQL representation which is appended to the sb.
    
    Parameters:
    
    where - The WHERE node of the FQL query.
    
    extIdxConstraints - The set of extra constraints required by extent indexes. For the specified aliases, a new constraint for the list__index is injected.
  - generateExpression
```
private void generateExpression(FQLAst node)
```
    Recursively walks a FQL predicate and generates the SQL one. The output is directly appended to sb.
    
    Parameters:
    
    node - The root node for a FQL predicate to be processed.
  - isBinaryOperator
```
private boolean isBinaryOperator(Aast ast)
```
    Convenience method to detect whether an AST represents a binary operator, based on its token type.
    
    Parameters:
    
    ast - AST node to test.
    
    Returns:
    
    true if the AST's token type indicates a binary operator, otherwise false is returned.
  - generateFrom
```
private java.lang.String generateFrom(FQLAst node,
                                      java.util.Map<java.lang.String,java.lang.String> innerJoins)
```
    Generates the list of source tables where the records are to be fetched (ie FROM and any type of JOIN part. For the first occurrence FROM keyword is used, for the subsequent, the appropriate JOIN is generated.
    
    Parameters:
    
    node - A FQLAst node which contains the node/s.
    
    innerJoins - A map with inner aliases to be joined.
    
    Returns:
    
    the alias of the master table of the query
  - generateJoin
```
private void generateJoin(FQLAst joinNode,
                          java.lang.String rightAlias,
                          DmoMeta rightDmo)
```
    Generates the JOIN part of the query statement.
    
    Parameters:
    
    joinNode - The FQLAst node which has the FQL JOIN data.
    
    rightAlias - The right alias.
    
    rightDmo - The DMO info for the right table.
  - generateOnClause
```
private void generateOnClause(FQLAst onClause)
```
    Generates the on clause for a join.
    
    Parameters:
    
    onClause - The node from where we start to generate the "on" clause.
  - collectNormalizedExtentsAliases
```
private void collectNormalizedExtentsAliases(FQLAst node,
                                             java.util.Map<java.lang.String,DmoMeta> aliasesMap,
                                             java.util.Map<java.lang.String,java.lang.String> innerJoins,
                                             java.util.function.BiConsumer<FQLAst,java.util.List<FQLAst>> staticSubscriptConstraints,
                                             java.util.function.BiConsumer<FQLAst,java.util.List<FQLAst>> dynamicSubscriptConstraints)
```
    Collects into aliasesMap all occurrences of aliases with normalized accesses to extents fields (that is, using bracket [ notation).
    Important: only the normalized tables that are already in the map are processed. If other normalized extent fields are encountered, they are skipped as they will be processed at the moment their main alias is collected (as part of a subselect, most likely).
    
    Parameters:
    
    node - The root node to start from (the WHERE or ORDER node).
    
    aliasesMap - The Map where the new aliases will be stored.
    
    innerJoins - The map where to save the inner join information.
    
    staticSubscriptConstraints - The consumer to be applied for static subscript fields.
    
    dynamicSubscriptConstraints - The consumer to be applied for dynamic subscript fields.
  - rewriteSelectDynamicSubscripts
```
private void rewriteSelectDynamicSubscripts(FQLAst whereNode,
                                            java.util.List<FQLAst> dynamicSubscripts)
```
    Rewrite the dynamic subscripts in a SELECT's WHERE clause, so that the field's index is matched before testing the field's value, to preserve substitution argument order.
    
    Parameters:
    
    whereNode - The parent WHERE node.
    
    dynamicSubscripts - The list of ALIAS ASTs which use dynamic subscripts.
  - collectTableAliases
```
private void collectTableAliases(FQLAst node,
                                 java.util.Map<java.lang.String,DmoMeta> aliases)
```
    Collects the list of aliases declared in a FQL FROM or JOIN. For each encountered alias, a DmoMeta structure is added. It will be used later to convert the table name and properties to SQL values.
    
    Parameters:
    
    node - The node which contains the declarations of aliases for this query.
  - getSqlTableAliasName
```
private java.lang.String getSqlTableAliasName(java.lang.String alias)
```
    Obtain the SQL table alias for a FQL alias.
    
    Parameters:
    
    alias - The FQL alias for a table.
    
    Returns:
    
    The SQL table alias. If not found or SQL aliases are not enabled, the FQL alias is returned.
  - getSqlColumnAlias
```
private java.lang.String getSqlColumnAlias(Property property)
```
    Computes an unique SQL name for a field/column.
    
    Parameters:
    
    property - The property that represent the field to be returned by a SELECT statement.
    
    Returns:
    
    An unique identifier for this column.
  - appendColAlias
```
private void appendColAlias(java.lang.String base)
```
    Appends a unique column alias to the sql statement.
    
    Parameters:
    
    base - The base prefix used to build the alias.
  - appendColAlias
```
private void appendColAlias(java.lang.String base,
                            boolean addToRowAliases)
```
    Appends a unique column alias to the sql statement.
    
    Parameters:
    
    base - The base prefix used to build the alias.
    
    addToRowAliases - If we should add the alias to the rowAliases list when converting a statement with contains.
  - warn
```
private static void warn(java.lang.String msg,
                         FQLAst node)
```
    Logging utility method. Writes a warning message and the node/location of the issue encountered.
    
    Parameters:
    
    msg - The message to be printed.
    
    node - The node that caused the issue (may be null).
  - op
```
private static java.lang.String op(LogicalExpressionConverter.Term token,
                                   java.util.List<java.lang.String> args)
```
    Generate a SQL condition ('=' or 'LIKE') for an operation on the CNF.
    
    Parameters:
    
    token - CNF token
    
    args - holder for the generated query parameters
    
    Returns:
    
    a SQL condition ('=' or 'LIKE') for an operation on the CNF
  - toUpper
```
private static void toUpper(boolean wrap,
                            java.lang.StringBuilder sb,
                            java.lang.Runnable op)
```
    Conditionally wrap operation on a StringBuilder with upper() call.
    
    Parameters:
    
    wrap - Flag indicating that wrapping is required.
    
    sb - The output StringBuilder instance.
    
    op - Operation to be wrapped.
  - main
```
public static void main(java.lang.String[] args)
```
    Test program.
    
    Parameters:
    
    args - The command line arguments.

Class FqlToSqlConverter

Nested Class Summary

Field Summary

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Field Detail

LOG

PK

NO_ALIAS

ASTERISK

dialect

db

schema

sb

sbProp

columnUid

aliases

sqlTableAliasMap

useSqlTableAlias

generateUniqueSqlColumnNames

maxResults

lazyMode

startOffset

paramCount

rowStructure

complexSubscript

forceNoAlias

queryParams

paraPerm

queryWasRewritten

userTableStatRead

lockTableRead

containsRewriteData

nestedInContains

currentContains

nargs

nCteArgs

cteNo

cte4order

weigths

useWordTables

rowAliases

relation

selectAliases

selectFields

collectAliases

collectFields

bindParam2SessionVar

nbind

argRef

sessionAttrs

_checkErrorFn

containsErrorHandling

Constructor Detail

FqlToSqlConverter

Method Detail

getInstance

getInstance

isQueryWasRewritten

bindParam2SessionVar

sessionAttrs

containsErrorHandling

isUserTableStatRead

isLockTableRead

containsWithWordTableAndCTE

containsWithWordTable

setFieldProperty

containsWithUdf

containsWithUdfAndCTE

toSQL

getParameterPermutation

getLastConversionParamCount

preprocess

processStatement

processUpdate

generateSet

processDelete

rewriteNoAliasPropertyNodes

rewriteSubscriptsAsSubselect