TGSqlParser (General SQL Parser Java Library Core 3.0.9.1 API)

Object
- gudusoft.gsqlparser.TGSqlParser

```
public class TGSqlParser
extends Object
```
This is the first class people start to use this SQL parser library. This class includes a lexer and a parser. The lexer is used to tokenize the input SQL, turn the input SQL text into a list of source tokens. The parser use this list source token as input, using the grammar rule of the specified database vendor to check the syntax of the input SQL and build the parse tree of this SQL if there is no syntax error in the input SQL.
Creating a SQL parser by specifing a database vendor, then set SQL script text via setSqltext(java.lang.String) method or reading the input SQL from a file via setSqlfilename(java.lang.String) method.
After that, call one of the following methods to achieve what you need:
- tokenizeSqltext(), turns the input SQL into a sequence of token which is the basic lexis element of SQL syntax. Token is categorized as keyword, identifier, number, operator, whitespace and other types. All source tokens can be fetched via the getSourcetokenlist() method
- getrawsqlstatements(), separates the SQL statements in the input SQL script without doing syntax check, use the getSqlstatements() method to get a list of SQL statements which is the sub-class of TCustomSqlStatement, get SQL statement type via the TCustomSqlStatement.sqlstatementtype field, and string representation of each SQL statement via the TParseTreeNode.toString() method. All source tokens in this SQL statement is available by using TCustomSqlStatement.sourcetokenlist filed. Since no parse tree is built by calling this method, no further detailed information about the SQL statement is available.
- parse(), Check syntax of the input SQL, doing some kind of semantic analysis without connecting to a real database. This method will do a in-depth analysis of the input SQL such as building the link between table and columns. The parse tree of the input SQL is available after calling this method.
The parser checks the syntax of those SQL statements one by one. If syntax error is found in a SQL statement, an error will be logged, no parse tree will be built for this SQL statement, the error message can be fetched using the getErrormessage() method.
The syntax error in one SQL statement doesn't prevent the parser continue to check the syntax of the next SQL statement. After checking syntax of all SQL statements, use the getErrorCount() method to get the total number of errors.
A syntax error in a SQL stored procedure will cease this parser to check syntax of the rest SQL statements in this stored procedure.
Format SQL script can be done after calling parse(). int ret = sqlparser.parse(); if (ret == 0){ GFmtOpt option = GFmtOptFactory.newInstance(); String result = FormatterFactory.pp(sqlparser, option); System.out.println(result); }else{ System.out.println(sqlparser.getErrormessage()); }
After paring SQL script, all parse tree nodes are available for use, some of use cases are:
- Table/column impact analysis
- SQL rewriting
- SQL translate between different databases
- SQL migration analysis
- Help to anti SQL injection
- More use cases
Typically, SQL parse tree nodes generated by this SQL Parser were closely related to SQL elements defined in database vendor's SQL reference book. here is a brief summary of some most used SQL elements and corresponding classes defined in this SQL parser.
- SQL identifier: TObjectName
- SQL literal: TConstant
- SQL datatype: TTypeName
- SQL function: TFunctionCall
- SQL constraint: TConstraint
- SQL expression/condition: TExpression
- SQL select list item: TResultColumn
- More: gudusoft.gsqlparser.nodes
Some major SQL statements:
- Select: TSelectSqlStatement
- Delete: TDeleteSqlStatement
- Insert: TInsertSqlStatement
- Update: TUpdateSqlStatement
- Create table: TCreateTableSqlStatement
- More: gudusoft.gsqlparser.stmt
Stored procedure
- Create function: TDb2CreateFunction, TMssqlCreateProcedure, TMySQLCreateFunction, TPlsqlCreateFunction
- Create procedure: TDb2CreateProcedure, TMssqlCreateProcedure, TMySQLCreateProcedure, TPlsqlCreateProcedure
- Create trigger: TCreateTriggerStmt, TPlsqlCreateTrigger
- Create package: TPlsqlCreatePackage
For all available SQL parse tree node classes, please check the API reference.

Field Summary

Fields
Modifier and Type	Field and Description
`static EDbVendor`	`currentDBVendor`
`TSourceTokenList`	`sourcetokenlist` Tokens generated by lexer from the input SQL script.
`String`	`sqlfilename` The input SQL will be read from this file If field is specified, then `sqltext` will be ignored.
`TStatementList`	`sqlstatements` SQL statements generated by this parser from the input SQL script.
`String`	`sqltext` The input SQL Text.

Constructor Summary

Constructors
Constructor and Description

TGSqlParser(EDbVendor pdbvendor)
Class constructor, create a new instance of the parser by setting the database vendor

Constructors
Constructor and Description
`TGSqlParser(EDbVendor pdbvendor)` Class constructor, create a new instance of the parser by setting the database vendor

Method Summary

All Methods Static Methods Instance Methods Concrete Methods Deprecated Methods
Modifier and Type	Method and Description
`int`	`checkSyntax()` check syntax of the input SQL.
`void`	`freeParseTable()` Not used.
`EDbVendor`	`getDbVendor()` The database vendor specified when creating this parser.
`static EDbVendor`	`getDBVendorByName(String dbVendorName)` Turn the string name of database to dbvendor access: EDbVendor.dbvccess ansi: EDbVendor.dbvansi bigquery: EDbVendor.dbvbigquery couchbase: EDbVendor.dbvcouchbase dax: EDbVendor.dbvdax db2: EDbVendor.dbvdb2 firebird: EDbVendor.dbvfirebird generic: EDbVendor.dbvgeneric greenplum: EDbVendor.dbvgreenplum hana: EDbVendor.dbvhana hive: EDbVendor.dbvhive impala: EDbVendor.dbvimpala informix: EDbVendor.dbvinformix mdx: EDbVendor.dbvmdx mssql or sqlserver: EDbVendor.dbvmssql mysql: EDbVendor.dbvmysql netezza: EDbVendor.dbvnetezza odbc: EDbVendor.dbvodbc openedge: EDbVendor.dbvopenedge oracle: EDbVendor.dbvoracle postgresql or postgres: EDbVendor.dbvpostgresql redshift: EDbVendor.dbvredshift snowflake: EDbVendor.dbvsnowflake sybase: EDbVendor.dbvsybase teradata: EDbVendor.dbvteradata vertica: EDbVendor.dbvvertica
`int`	`getErrorCount()` The total number of syntax errors founded in the input SQL script.
`String`	`getErrormessage()` The text of error message generated by iterating all items in `getSyntaxErrors()`.
`TCustomLexer`	`getFlexer()` The lexer which is used to tokenize the input SQL.
`Stack<gudusoft.gsqlparser.compiler.TFrame>`	`getFrameStack()`
`long`	`getInterpreterTime()` Get accumulated time spent in interpreter in milliseconds
`static String`	`getLicenseMessage()` Not used.
`static String`	`getLicenseType()` Not used.
`static String`	`getMachineId()` Not used.
`IMetaDatabase`	`getMetaDatabase()` Deprecated. As of v2.0.3.1, please use `getSqlEnv()` instead a new instance of the class which implements the `IMetaDatabase` interface
`long`	`getParsingTime()` Get accumulated time spent parsing in milliseconds
`int`	`getrawsqlstatements()` separates the SQL statements in the input SQL script without doing syntax check.
`long`	`getRawSqlStatementsTime()` Get accumulated time spent getting raw SQL statements in milliseconds
`long`	`getSemanticAnalysisTime()` Get accumulated time spent on semantic analysis in milliseconds
`TSourceTokenList`	`getSourcetokenlist()` A sequence of source tokens created by the lexer after tokenize the input SQL
`String`	`getSqlCharset()`
`TSQLEnv`	`getSqlEnv()` SQL environment includes the database metadata such as procedure, function, trigger, table and etc.
`String`	`getSqlfilename()` The input SQL filename.
`InputStream`	`getSqlInputStream()` the InputStream from which SQL will be read
`TStatementList`	`getSqlstatements()` A list of SQL statements created by the parser.
`String`	`getSqltext()` The SQL text that being processed.
`ArrayList<TSyntaxError>`	`getSyntaxErrors()` The array of syntax error generated by the parser during checking the syntax of the input SQL, element of this list is type of `TSyntaxError`
`String`	`getTimeStatistics()` Returns time statistics as a formatted string
`long`	`getTotalTime()` Get total accumulated time spent in all steps
`static String`	`getUserName()` Not used.
`boolean`	`isTimeLoggingEnabled()` Check if time logging is enabled
`int`	`parse()` Check syntax of the input SQL, doing some kind of semantic analysis without connecting to a real database.
`static TConstant`	`parseConstant(EDbVendor dbVendor, String newConstant)`
`TConstant`	`parseConstant(String newConstant)` Create an constant object from the parameter: newConstant
`static TExpression`	`parseExpression(EDbVendor dbVendor, String expr)`
`TExpression`	`parseExpression(String expr)` Create an expression object from the parameter: expr
`static TFunctionCall`	`parseFunctionCall(EDbVendor dbVendor, String newFunction)`
`TFunctionCall`	`parseFunctionCall(String newFunction)` Create a function object from the parameter: newFunction
`static TObjectName`	`parseObjectName(EDbVendor dbVendor, String newObjectName)`
`TObjectName`	`parseObjectName(String newObjectName)` Create a database objectName from the parameter: newObjectName
`static TSelectSqlStatement`	`parseSubquery(EDbVendor dbVendor, String subquery)`
`TSelectSqlStatement`	`parseSubquery(String subquery)` Create a select statement object from the parameter: subquery
`void`	`resetTimeCounters()` Reset all accumulated time counters to zero
`void`	`setEnablePartialParsing(boolean enablePartialParsing)` Deprecated. As of v1.4.3.4 enable GSP to parse the rest of sql statements inside stored procedure when a SQL statement in the stored procedure cannot be parsed Available to parse sybase stored procedure currently.
`void`	`setEnableTimeLogging(boolean enable)` Enable or disable time logging for parser steps
`void`	`setFrameStack(Stack<gudusoft.gsqlparser.compiler.TFrame> frameStack)`
`void`	`setMetaDatabase(IMetaDatabase metaDatabase)` Deprecated. As of v2.0.3.1, please use `getSqlEnv()` instead set an instance of a class which implement the interface: `IMetaDatabase`. The parser will call `IMetaDatabase.checkColumn(java.lang.String, java.lang.String, java.lang.String, java.lang.String, java.lang.String)` method when it needs to know whether a column is belonged to a table. The class that implements the interface: `IMetaDatabase` usually fetch the metadata from the database by connecting to a database instance. If the class is not provided, the parser has to guess the relationship between a un-qualified column and table in the input SQL which may lead to a un-determined result between the column and table.
`void`	`setOnlyNeedRawParseTree(boolean onlyNeedRawParseTree)`
`void`	`setSinglePLBlock(boolean singlePLBlock)`
`void`	`setSqlCharset(String sqlCharset)`
`void`	`setSqlEnv(TSQLEnv sqlEnv)`
`void`	`setSqlfilename(String sqlfilename)` set the filename from which the input SQL will be read.
`void`	`setSqlInputStream(InputStream sqlInputStream)` set the InputStream from which SQL will be read.
`void`	`setSqlStatementHandle(ISQLStatementHandle sqlStatementHandle)`
`void`	`setSqltext(String sqltext)` set the input SQL text, If `sqlfilename` is specified before this method, the parser will using the SQL text in this field instead of read SQL from `sqlfilename`.
`void`	`setTeradataUtilityType(TeradataUtilityType teradataUtilityType)`
`void`	`setTokenHandle(ITokenHandle tokenHandle)` Set an event handler which will be fired when a new source token is created by the lexer during tokenize the input SQL.
`void`	`setTokenListHandle(ITokenListHandle tokenListHandle)`
`void`	`tokenizeSqltext()` turns the input SQL into a sequence of token which is the basic lexis element of SQL syntax.
`int`	`validate()`

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

- Field Detail
  - currentDBVendor
```
public static EDbVendor currentDBVendor
```
  - sqltext
```
public String sqltext
```
    The input SQL Text. If sqlfilename is specified, then this field will be ignored.
  - sqlfilename
```
public String sqlfilename
```
    The input SQL will be read from this file If field is specified, then sqltext will be ignored. This must be the full path to the file, relative path doesn't work.
  - sourcetokenlist
```
public TSourceTokenList sourcetokenlist
```
    Tokens generated by lexer from the input SQL script. Tokens are always available even if there are syntax errors in input the SQL script.
  - sqlstatements
```
public TStatementList sqlstatements
```
    SQL statements generated by this parser from the input SQL script. statements are always available even if there are syntax errors in input SQL script. if there is no syntax error in a statement, you can access the parse tree of the statement to fetch more information such as tables, columns, etc.
- Constructor Detail
  - TGSqlParser
```
public TGSqlParser(EDbVendor pdbvendor)
```
    Class constructor, create a new instance of the parser by setting the database vendor
    
    Parameters:
    
    pdbvendor - the database vendor whose grammar rule will be used to validate the syntax of the input SQL
- Method Detail
  - setSqlCharset
```
public void setSqlCharset(String sqlCharset)
```
  - getSqlCharset
```
public String getSqlCharset()
```
  - getDBVendorByName
```
public static EDbVendor getDBVendorByName(String dbVendorName)
```
    Turn the string name of database to dbvendor
    - access: EDbVendor.dbvccess
    - ansi: EDbVendor.dbvansi
    - bigquery: EDbVendor.dbvbigquery
    - couchbase: EDbVendor.dbvcouchbase
    - dax: EDbVendor.dbvdax
    - db2: EDbVendor.dbvdb2
    - firebird: EDbVendor.dbvfirebird
    - generic: EDbVendor.dbvgeneric
    - greenplum: EDbVendor.dbvgreenplum
    - hana: EDbVendor.dbvhana
    - hive: EDbVendor.dbvhive
    - impala: EDbVendor.dbvimpala
    - informix: EDbVendor.dbvinformix
    - mdx: EDbVendor.dbvmdx
    - mssql or sqlserver: EDbVendor.dbvmssql
    - mysql: EDbVendor.dbvmysql
    - netezza: EDbVendor.dbvnetezza
    - odbc: EDbVendor.dbvodbc
    - openedge: EDbVendor.dbvopenedge
    - oracle: EDbVendor.dbvoracle
    - postgresql or postgres: EDbVendor.dbvpostgresql
    - redshift: EDbVendor.dbvredshift
    - snowflake: EDbVendor.dbvsnowflake
    - sybase: EDbVendor.dbvsybase
    - teradata: EDbVendor.dbvteradata
    - vertica: EDbVendor.dbvvertica
    Parameters:
    
    dbVendorName -
    
    Returns:
    
    dbvendor
  - getFrameStack
```
public Stack<gudusoft.gsqlparser.compiler.TFrame> getFrameStack()
```
  - setFrameStack
```
public void setFrameStack(Stack<gudusoft.gsqlparser.compiler.TFrame> frameStack)
```
  - getSourcetokenlist
```
public TSourceTokenList getSourcetokenlist()
```
    A sequence of source tokens created by the lexer after tokenize the input SQL
    
    Returns:
    
    a sequence of source tokens
  - getSqlstatements
```
public TStatementList getSqlstatements()
```
    A list of SQL statements created by the parser. If this list is created after calling the getrawsqlstatements() method, the syntax of each SQL statement is not checked and the parse tree of each statement is not created. If the parse() method is called to build this SQL statement list, then every thing is ready.
    
    Returns:
    
    a list of SQL statement
  - setSqltext
```
public void setSqltext(String sqltext)
```
    set the input SQL text, If sqlfilename is specified before this method, the parser will using the SQL text in this field instead of read SQL from sqlfilename.
    
    Parameters:
    
    sqltext - the input SQL text
  - getSqltext
```
public String getSqltext()
```
    The SQL text that being processed.
    
    Returns:
    
    the SQL text that being processed
  - setSqlfilename
```
public void setSqlfilename(String sqlfilename)
```
    set the filename from which the input SQL will be read.
    
    Parameters:
    
    sqlfilename - the SQL file name from which the input SQL will be read
  - getSqlfilename
```
public String getSqlfilename()
```
    The input SQL filename. This parser can process the unicode encoded SQL file.
    
    Returns:
    
    the input SQL filename
  - setSqlInputStream
```
public void setSqlInputStream(InputStream sqlInputStream)
```
    set the InputStream from which SQL will be read. If this method is called, sqlfilename and sqltext will be ignored.
    
    Parameters:
    
    sqlInputStream - the InputStream from which SQL will be read
  - getSqlInputStream
```
public InputStream getSqlInputStream()
```
    the InputStream from which SQL will be read
    
    Returns:
    
    the InputStream from which SQL will be read
  - getSyntaxErrors
```
public ArrayList<TSyntaxError> getSyntaxErrors()
```
    The array of syntax error generated by the parser during checking the syntax of the input SQL, element of this list is type of TSyntaxError
    
    Returns:
    
    the array of errors
  - getDbVendor
```
public EDbVendor getDbVendor()
```
    The database vendor specified when creating this parser. The grammar rule of this database vendor will be used to validate the syntax of the input SQL.
    
    Returns:
    
    the database vendor
  - setEnablePartialParsing
```
public void setEnablePartialParsing(boolean enablePartialParsing)
```
    Deprecated. As of v1.4.3.4 enable GSP to parse the rest of sql statements inside stored procedure when a SQL statement in the stored procedure cannot be parsed
    Available to parse sybase stored procedure currently.
    
    Parameters:
    
    enablePartialParsing - set true to enable this partial parsing, default is false
  - getUserName
```
public static String getUserName()
```
    Not used.
    
    Returns:
    
    the user name
  - getMachineId
```
public static String getMachineId()
```
    Not used.
    
    Returns:
    
    the machine id
  - getLicenseMessage
```
public static String getLicenseMessage()
```
    Not used.
    
    Returns:
    
    the license message
  - getLicenseType
```
public static String getLicenseType()
```
    Not used.
    
    Returns:
    
    trial license or developer license or distribution license
  - getFlexer
```
public TCustomLexer getFlexer()
```
    The lexer which is used to tokenize the input SQL.
    
    Returns:
    
    the lexer
  - setSqlStatementHandle
```
public void setSqlStatementHandle(ISQLStatementHandle sqlStatementHandle)
```
  - setTokenHandle
```
public void setTokenHandle(ITokenHandle tokenHandle)
```
    Set an event handler which will be fired when a new source token is created by the lexer during tokenize the input SQL.
    
    Parameters:
    
    tokenHandle - the event handler to process the new created source token
  - setTokenListHandle
```
public void setTokenListHandle(ITokenListHandle tokenListHandle)
```
  - setMetaDatabase
```
public void setMetaDatabase(IMetaDatabase metaDatabase)
```
    Deprecated. As of v2.0.3.1, please use getSqlEnv() instead set an instance of a class which implement the interface: IMetaDatabase. The parser will call IMetaDatabase.checkColumn(java.lang.String, java.lang.String, java.lang.String, java.lang.String, java.lang.String) method when it needs to know whether a column is belonged to a table.
    The class that implements the interface: IMetaDatabase usually fetch the metadata from the database by connecting to a database instance.
    If the class is not provided, the parser has to guess the relationship between a un-qualified column and table in the input SQL which may lead to a un-determined result between the column and table.
    
    Parameters:
    
    metaDatabase - a new instance of the class which implements the IMetaDatabase interface
    
    See Also:
    
    IMetaDatabase
  - getMetaDatabase
```
public IMetaDatabase getMetaDatabase()
```
    Deprecated. As of v2.0.3.1, please use getSqlEnv() instead a new instance of the class which implements the IMetaDatabase interface
    
    Returns:
    
    a new instance of the class which implements the IMetaDatabase interface
    
    See Also:
    
    setMetaDatabase(gudusoft.gsqlparser.IMetaDatabase)
  - freeParseTable
```
public void freeParseTable()
```
    Not used.
  - parseSubquery
```
public TSelectSqlStatement parseSubquery(String subquery)
```
    Create a select statement object from the parameter: subquery
    
    Parameters:
    
    subquery - a plain text select statement which need to be converted to a TSelectSqlStatement object
    
    Returns:
    
    a select statement object, return null if the input select string is syntax invalid.
  - parseSubquery
```
public static TSelectSqlStatement parseSubquery(EDbVendor dbVendor,
                                                String subquery)
```
  - parseExpression
```
public TExpression parseExpression(String expr)
```
    Create an expression object from the parameter: expr
    
    Parameters:
    
    expr - a plain text expression which will be converted to TExpression object
    
    Returns:
    
    an expression object, return null if the input expression string is not syntax valid.
  - parseExpression
```
public static TExpression parseExpression(EDbVendor dbVendor,
                                          String expr)
```
  - parseFunctionCall
```
public TFunctionCall parseFunctionCall(String newFunction)
```
    Create a function object from the parameter: newFunction
    
    Parameters:
    
    newFunction - a plain text function which will be converted to TFunctionCall object
    
    Returns:
    
    a function object, or return null if the input string is not a valid function call.
  - parseFunctionCall
```
public static TFunctionCall parseFunctionCall(EDbVendor dbVendor,
                                              String newFunction)
```
  - parseObjectName
```
public TObjectName parseObjectName(String newObjectName)
```
    Create a database objectName from the parameter: newObjectName
    
    Parameters:
    
    newObjectName - a plain text objectName which will be converted to TObjectName object
    
    Returns:
    
    a database objectName object, return null is the input string is not a valid objectName.
  - parseObjectName
```
public static TObjectName parseObjectName(EDbVendor dbVendor,
                                          String newObjectName)
```
    Parameters:
    
    dbVendor -
    
    newObjectName -
    
    Returns:
  - parseConstant
```
public TConstant parseConstant(String newConstant)
```
    Create an constant object from the parameter: newConstant
    
    Parameters:
    
    newConstant - a plian text constant which will be converted to TConstant object
    
    Returns:
    
    new constant object, returns null if the input is not a valid constant string.
  - parseConstant
```
public static TConstant parseConstant(EDbVendor dbVendor,
                                      String newConstant)
```
  - getErrorCount
```
public int getErrorCount()
```
    The total number of syntax errors founded in the input SQL script.
    Only the first syntax error in a SQL statement is counted if there are more than one syntax errors in a single SQL statement.
    In a SQL script, only the first syntax error in each SQL statement is counted.
    
    Returns:
    
    The total number of syntax errors founded in the input SQL script. Returns 0 if no syntax error is founded.
  - getErrormessage
```
public String getErrormessage()
```
    The text of error message generated by iterating all items in getSyntaxErrors(). User may generate error message in their own format by iterating all items in getSyntaxErrors().
    
    Returns:
    
    error message
  - checkSyntax
```
public int checkSyntax()
```
    check syntax of the input SQL. This method works exactly the same as parse() method.
    
    Returns:
    
    0 means parse SQL script successfully, otherwise, use getErrorCount(), getErrormessage() to get detailed error information.
    
    See Also:
    
    parse()
  - parse
```
public int parse()
```
    Check syntax of the input SQL, doing some kind of semantic analysis without connecting to a real database.
    This method will do a in-depth analysis of the input SQL such as building the link between table and columns. The parse tree of the input SQL is available after calling this method. The parser checks the syntax of those SQL statements one by one. If syntax error is found in a SQL statement, an error will be logged, no parse tree will be built for this SQL statement, the error message can be fetched using the getErrormessage() method.
    The syntax error in one SQL statement doesn't prevent the parser continue to check the syntax of the next SQL statement. After checking syntax of all SQL statements, use the getErrorCount() method to get the total number of errors.
    A syntax error in a SQL stored procedure will cease this parser to check syntax of the rest SQL statements in this stored procedure.
    
    Returns:
    
    0 means parse SQL script successfully, otherwise, use getErrorCount(), getErrormessage() to get detailed error information.
    
    See Also:
    
    getSyntaxErrors()
  - validate
```
public int validate()
```
  - setSinglePLBlock
```
public void setSinglePLBlock(boolean singlePLBlock)
```
  - getrawsqlstatements
```
public int getrawsqlstatements()
```
    separates the SQL statements in the input SQL script without doing syntax check.
    Use the getSqlstatements() method to get the list of SQL statements. The SQL statement object is the instance of the sub-class of TCustomSqlStatement, get SQL statement type via the TCustomSqlStatement.sqlstatementtype field, get string representation of each SQL statement via the TParseTreeNode.toString() method.
    All source tokens in this SQL statement is available by using TCustomSqlStatement.sourcetokenlist filed. Since no parse tree is built by calling this method, no further detailed information about the SQL statement is available.
    
    Returns:
    
    0 if get SQL statements successfully
  - tokenizeSqltext
```
public void tokenizeSqltext()
```
    turns the input SQL into a sequence of token which is the basic lexis element of SQL syntax. Token is categorized as keyword, identifier, number, operator, whitespace and other types. All source tokens can be fetched via the getSourcetokenlist() method.
  - getSqlEnv
```
public TSQLEnv getSqlEnv()
```
    SQL environment includes the database metadata such as procedure, function, trigger, table and etc. In order to link column to table correctly without connecting to database, we need to provide a class which implements TSQLEnv to TGSqlParser. this class tells TGSqlParser the relationship between column and table.
    Take this SQL for example:
```
 SELECT Quantity,b.Time,c.Description
 FROM
 (SELECT ID2,Time FROM bTab) b
 INNER JOIN aTab a on a.ID=b.ID
 INNER JOIN cTab c on a.ID=c.ID
 
```
    General SQL Parser can build relationship between column: ID2 and table: bTable correctly without metadata information from database because there is only one table in from clause. But it can't judge column: Quantity belong to table: aTab or cTab, since no table alias was prefixed to column: Quantity. If no metadata provided, General SQL Parser will link column: Quantity to the first valid table (here it is aTab)
    If we create a class TRealDatabaseSQLEnv implements TSQLEnv,then setSqlEnv(TSQLEnv), General SQL Parser can take this advantage to create a correct relationship between column and tables.
```
 class TSQLServerEnv extends TSQLEnv{

        public TSQLServerEnv(){
                super(EDbVendor.dbvmssql);
                initSQLEnv();
        }

    @Override
    public void initSQLEnv() {

                // add a new database: master
                TSQLCatalog sqlCatalog = createSQLCatalog("master");
                // add a new schema: dbo
                TSQLSchema sqlSchema = sqlCatalog.createSchema("dbo");
                //add a new table: aTab
                TSQLTable aTab = sqlSchema.createTable("aTab");
                aTab.addColumn("Quantity1");

                //add a new table: bTab
                TSQLTable bTab = sqlSchema.createTable("bTab");
                bTab.addColumn("Quantity2");

                //add a new table: cTab
                TSQLTable cTab = sqlSchema.createTable("cTab");
                cTab.addColumn("Quantity");

    }
 }
 
```
    Returns:
    
    SQL environment
  - setOnlyNeedRawParseTree
```
public void setOnlyNeedRawParseTree(boolean onlyNeedRawParseTree)
```
  - setSqlEnv
```
public void setSqlEnv(TSQLEnv sqlEnv)
```
  - setEnableTimeLogging
```
public void setEnableTimeLogging(boolean enable)
```
    Enable or disable time logging for parser steps
    
    Parameters:
    
    enable - true to enable time logging, false to disable
  - isTimeLoggingEnabled
```
public boolean isTimeLoggingEnabled()
```
    Check if time logging is enabled
    
    Returns:
    
    true if time logging is enabled, false otherwise
  - resetTimeCounters
```
public void resetTimeCounters()
```
    Reset all accumulated time counters to zero
  - getRawSqlStatementsTime
```
public long getRawSqlStatementsTime()
```
    Get accumulated time spent getting raw SQL statements in milliseconds
    
    Returns:
    
    time in milliseconds
  - getParsingTime
```
public long getParsingTime()
```
    Get accumulated time spent parsing in milliseconds
    
    Returns:
    
    time in milliseconds
  - getSemanticAnalysisTime
```
public long getSemanticAnalysisTime()
```
    Get accumulated time spent on semantic analysis in milliseconds
    
    Returns:
    
    time in milliseconds
  - getInterpreterTime
```
public long getInterpreterTime()
```
    Get accumulated time spent in interpreter in milliseconds
    
    Returns:
    
    time in milliseconds
  - getTotalTime
```
public long getTotalTime()
```
    Get total accumulated time spent in all steps
    
    Returns:
    
    total time in milliseconds
  - getTimeStatistics
```
public String getTimeStatistics()
```
    Returns time statistics as a formatted string
    
    Returns:
    
    formatted string with time statistics
  - setTeradataUtilityType
```
public void setTeradataUtilityType(TeradataUtilityType teradataUtilityType)
```

Class TGSqlParser

Field Summary

Constructor Summary

Method Summary

Methods inherited from class Object

Field Detail

currentDBVendor

sqltext

sqlfilename

sourcetokenlist

sqlstatements

Constructor Detail

TGSqlParser

Method Detail

setSqlCharset

getSqlCharset

getDBVendorByName

getFrameStack

setFrameStack

getSourcetokenlist

getSqlstatements

setSqltext

getSqltext

setSqlfilename

getSqlfilename

setSqlInputStream

getSqlInputStream

getSyntaxErrors

getDbVendor

setEnablePartialParsing

getUserName

getMachineId

getLicenseMessage

getLicenseType

getFlexer

setSqlStatementHandle

setTokenHandle

setTokenListHandle

setMetaDatabase

getMetaDatabase

freeParseTable

parseSubquery

parseSubquery

parseExpression

parseExpression

parseFunctionCall

parseFunctionCall

parseObjectName

parseObjectName

parseConstant

parseConstant

getErrorCount

getErrormessage

checkSyntax

parse

validate

setSinglePLBlock

getrawsqlstatements

tokenizeSqltext

getSqlEnv

setOnlyNeedRawParseTree

setSqlEnv

setEnableTimeLogging

isTimeLoggingEnabled

resetTimeCounters

getRawSqlStatementsTime

getParsingTime

getSemanticAnalysisTime

getInterpreterTime

getTotalTime

getTimeStatistics

setTeradataUtilityType