package gudusoft.gsqlparser.nodes;

import gudusoft.gsqlparser.*;
import gudusoft.gsqlparser.nodes.mysql.TGroupConcatParam;
import gudusoft.gsqlparser.nodes.oracle.TListaggOverflow;
import gudusoft.gsqlparser.nodes.teradata.TDataConversionItem;
import gudusoft.gsqlparser.sqlenv.ESQLDataObjectType;
import gudusoft.gsqlparser.sqlenv.TSQLEnv;
import gudusoft.gsqlparser.sqlenv.TSQLFunction;
import gudusoft.gsqlparser.util.CollectionUtil;
import gudusoft.gsqlparser.util.SQLUtil;
import gudusoft.gsqlparser.util.TBuiltFunctionUtil;
import gudusoft.gsqlparser.util.functionChecker;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.*;


/**
 * Represents the database function, all functions are represented by this class no matter what's type of the function.
 * Maybe it's a better idea to create the specific sub-class for function with different syntax such as the built-in
 * function extract, convert, substring and others. We may implement this feature in the later version.
 *
 * For the most of functions, the arguments are a lists of {@link gudusoft.gsqlparser.nodes.TExpression}. For other
 * functions with the different syntax in arguments, please check the detailed information below.
 *
 * this class includes function name and arguments.
 * <br>There are 3 types of functions:
 * <ul>
 *     <li>Arguments is a list of expressions</li>
 *     <li>Analytic function</li>
 *     <li>Function with specific arguments, such as cast function</li>
 * </ul>
 *
 *
 *     <b>1.Arguments is a list of expressions</b>
 *     <br>
* function([expr,expr, ...])
 * <ul>
 *     <li>function name: {@link #getFunctionName()}</li>
 *     <li>args: {@link #getArgs()}</li>
 *     </ul>
 * <p>
 *
 *     <b>2.Analytic function</b>
 *     <br>
 *  Use {@link #getWindowDef()} to get over clause information.
* <p>
 *     <b>3.Function with specific arguments</b>
* <p><b>trim</b>
 * <ul>
 *     <li>type: {@link EFunctionType#trim_t}</li>
 *     <li>arg: {@link #getTrimArgument()}</li>
 * </ul>
* <p><b>cast(expr as typename)</b>,
 * <b>cast(expr as typename [,datatypeAttribute])</b>,
 * <b>cast(expr as datatypeAttribute)</b>
 * <ul>
 *     <li>type:{@link EFunctionType#cast_t}</li>
 *     <li>expr: {@link #getExpr1()}</li>
 *     <li>typename: {@link #getTypename()}, datatypeAttribute is included in {@link TTypeName} as well</li>
 * </ul>
*
*
* <p><b>convert(typename,[null|not null] expr1 [,expr2])</b>,
 * <ul>
 *     <li>type: {@link EFunctionType#convert_t}</li>
 *     <li>expr1: {@link #getExpr1()}</li>
 *     <li>expr2: {@link #getExpr2()}</li>
 *     <li>typename: {@link #getTypename()}</li>
 * </ul>
*
* <p><b>Teradata ( udf(args) RETURNS data_type )</b>, the RETURNS clause of a function with a
 * TD_ANYTYPE result; <b>TRYCAST(expr) RETURNS data_type</b> is a {@link EFunctionType#cast_t}
 * like TRYCAST(expr AS data_type)
 * <ul>
 *     <li>typename: {@link #getTypename()}, the requested result type</li>
 * </ul>
*
* <p><b>extract([time_token from expr])</b>,
 * <ul>
 *     <li>type: {@link EFunctionType#extract_t}</li>
 *     <li>expr: {@link #getExpr1()}</li>
 *     <li>time_token: {@link #getExtract_time_token()}</li>
 * </ul>
*
* <p>sql server contains function,<b>contains(in_expr, expr [,langTerm])</b>,
 * <ul>
 *     <li>type: {@link EFunctionType#contains_t}</li>
 *     <li>expr: {@link #getExpr1()}</li>
 *     <li>in_expr: {@link #getInExpr()}</li>
 * </ul>
*
*
* <p>sql server freetext,freetext(contain in expr, expr [,langTerm])</p>,
 * <ul>
 *     <li>type: {@link EFunctionType#freetext_t}</li>
 *     <li>expr: {@link #getExpr1()}</li>
 *     <li>in_expr: {@link #getInExpr()}</li>
 * </ul>
*
 *
* <p>Oracle Extract(XML): <b>extract(XMLType_instance, XPath_string[,namespace_string])</b>,
 * <ul>
 *     <li>type: {@link EFunctionType#extractxml_t}</li>
 *     <li>XMLType_instance: {@link #getXMLType_Instance()}</li>
 *     <li>XPath_string: {@link #getXPath_String()}</li>
 *     <li>namespace_string: {@link #getNamespace_String()}</li>
 * </ul>

* <p> <b>Rank(value,...)</b>,
 * <ul>
 *     <li>type: {@link EFunctionType#rank_t}</li>
 *     <li>value list {@link #getOrderByList()}</li>
 * </ul>
 *
 * <p>XMLPassingClause of XMLExists function</p>
 * <ul>
 *     <li>type: {@link EFunctionType#xmlexists_t}</li>
 *     <li>value list {@link #getPassingClause()}</li>
 * </ul>
 *
*/
public class TFunctionCall extends TParseTreeNode{

    protected TExpression filterClause;

    /**
     * spark sql filter clause, postgresql filter clause
     * 
     * <pre>
     * SELECT COUNT(*) FILTER (WHERE bid_amount_value < 10000) AS low_range_bid_count_value FROM A
     * </pre>
     * 
     * @return
     */
    public TExpression getFilterClause() {
        return filterClause;
    }

    public void setFilterClause(TWhereClause filterClause) {
        if (filterClause == null) return;
        this.filterClause = filterClause.getCondition();
    }

    public void setFilterClause(TDummy filterClause) {
        if (filterClause == null) return;
        this.setFilterClause((TWhereClause)filterClause.node1);
    }      
 

    private  TIndirection indirection;

    public void setIndirection(TIndirection indirection) {
        this.indirection = indirection;
    }

    /**
     * The expressions inside the subscripts after this call, {@code split(s, ':')[n]}: column references that
     * TSQLResolver2 and the lineage analyzer read like any other (Mantis 4817). Empty without a subscript.
     *
     * @return the subscript expressions, never null
     */
    public java.util.List<TExpression> getSubscriptExpressions() {
        if (indirection == null) return java.util.Collections.<TExpression>emptyList();
        return indirection.getSubscriptExpressions();
    }

    /**
     * databricks,  current_version().dbsql_version;
     * @return
     */
    public TIndirection getIndirection() {
        return indirection;
    }


        final static Map<EDbVendor, Map<String, Set<String>>> tableFunctionMap = new HashMap<EDbVendor, Map<String, Set<String>>>();
        static {
                tableFunctionMap.put(EDbVendor.dbvmssql, loadTableFunctions(EDbVendor.dbvmssql));
        tableFunctionMap.put(EDbVendor.dbvoracle, loadTableFunctions(EDbVendor.dbvoracle));
        }
        
        private static Map<String, Set<String>> loadTableFunctions(EDbVendor vendor) {
                Map<String, Set<String>> tableFunctionInfoMap = new HashMap<String, Set<String>>();
                try {
                        BufferedReader reader = new BufferedReader(new InputStreamReader(TFunctionCall.class.getResourceAsStream(
                                        "/gudusoft/gsqlparser/tablefunction/" + vendor.name().replace("dbv", "") + ".txt")));
                        String line;
                        while ((line = reader.readLine()) != null) {
                                String[] tableFunctionInfo = line.toUpperCase(Locale.ROOT).split("\\s*,\\s*");
                                if (tableFunctionInfo.length > 1) {
                                        tableFunctionInfoMap.put(tableFunctionInfo[0],
                                                        CollectionUtil.convertArraysToSet(tableFunctionInfo));
                                        tableFunctionInfoMap.get(tableFunctionInfo[0]).remove(tableFunctionInfo[0]);
                                }
                        }
                } catch (IOException e) {
                        e.printStackTrace();
                }
                return tableFunctionInfoMap;
        }

        private ArrayList<TDataConversionItem> dataConversionItems;

    public void setDataConversionItems(ArrayList<TDataConversionItem> dataConversionItems) {
        this.dataConversionItems = dataConversionItems;
    }

    public ArrayList<TDataConversionItem> getDataConversionItems() {
        return dataConversionItems;
    }

    private TListaggOverflow listaggOverflow;

    public void setListaggOverflow(TListaggOverflow listaggOverflow) {
        this.listaggOverflow = listaggOverflow;
    }

    public TListaggOverflow getListaggOverflow() {
        return listaggOverflow;
    }

    public void setFirstArgAsDateTimePart(int pos){
            if (this.getArgs() == null) return;
            if (this.getArgs().size()<=pos) return;
            TExpression expression = this.getArgs().getExpression(pos);
            if (expression.getObjectOperand() != null){
                expression.getObjectOperand().setDbObjectType(EDbObjectType.date_time_part);
        }
    }
        public int isColumnInThisTableFunction(TSQLEnv sqlEnv, EDbVendor dbVendor, TObjectName pColumn) {
                int ret = TBaseType.COLUMN_IN_TABEL_FUNCTION_NOTSURE;
                String functionNameKey = this.getFunctionName().toString().toUpperCase(Locale.ROOT);
                functionNameKey = functionNameKey.substring(functionNameKey.lastIndexOf('.') + 1);
                Map<String, Set<String>> tableFunctionInfoMap = tableFunctionMap.get(dbVendor);
                if (tableFunctionInfoMap != null && tableFunctionInfoMap.containsKey(functionNameKey)) {
                        if (tableFunctionInfoMap.get(functionNameKey).contains(SQLUtil.getIdentifierNormalName(dbVendor, pColumn.getColumnNameOnly(), ESQLDataObjectType.dotColumn).toUpperCase(Locale.ROOT))) {
                                ret = TBaseType.COLUMN_IN_TABEL_FUNCTION_YES;
                        } else {
                                ret = TBaseType.COLUMN_IN_TABEL_FUNCTION_NO;
                        }
                }
                else if(this.functionType == EFunctionType.udf_t && sqlEnv!=null){
                        TSQLFunction functionDef = sqlEnv.searchFunction(this.getFunctionName().toString());
                        if (functionDef == null) {
                                // A function the catalog does not know has columns nobody knows either (Mantis 4797).
                                ret = TBaseType.COLUMN_IN_TABEL_FUNCTION_NOTSURE;
                        }
                        else if(functionDef.searchColumnInReturnTable(pColumn.getColumnNameOnly())){
                                ret = TBaseType.COLUMN_IN_TABEL_FUNCTION_YES;
                        }
                        else {
                                ret = TBaseType.COLUMN_IN_TABEL_FUNCTION_NO;
                        }
                }
                else {
                        ret = TBaseType.COLUMN_IN_TABEL_FUNCTION_NOTSURE;
                }

                return ret;
        }

         protected TWithinGroup withinGroup;

    public void setWithinGroup(TWithinGroup withinGroup) {
        this.withinGroup = withinGroup;
    }

    public TWithinGroup getWithinGroup() {
        return withinGroup;
    }

    public void setIntervalUnit(String intervalUnit) {
        this.intervalUnit = intervalUnit;
    }

    public String getIntervalUnit() {
        return intervalUnit;

    }

    private String intervalUnit;

    private  TExpression stringExpr;

    public void setStringExpr(TExpression stringExpr) {
        this.stringExpr = stringExpr;
    }

    /**
     * DB2 listagg function
     * @return the first argument of the listagg function
     */
    public TExpression getStringExpr() {
        return stringExpr;
    }

    private TExpression separatorExpr;

    public void setSeparatorExpr(TExpression separatorExpr) {
        this.separatorExpr = separatorExpr;
    }

    /**
     * DB2 listagg function.
     * @return the second argument of the listagg function.
     */
    public TExpression getSeparatorExpr() {

        return separatorExpr;
    }

    private TExpression searchCondition;

    /**
     * contains search condition. or freetext_string in freetext predicate
     *
     * @param searchCondition contains search condition.
     */
    public void setSearchCondition(TExpression searchCondition) {
        this.searchCondition = searchCondition;
    }

    /**
     * contains search condition. It usually a string constant or a variable.
     * SQL Server contains predicate.
     * <pre>
     * CONTAINS (
     * {
     * column_name | ( column_list )
     * | *
     * | PROPERTY ( { column_name }, 'property_name' )
     * }
     * , '&lt;contains_search_condition&gt;'
     * [ , LANGUAGE language_term ]
     * )
     *</pre>
     *
     * Or freetext_string in freetext predicate
     * <pre>
     *     FREETEXT ( { column_name | (column_list) | * }
     *     , 'freetext_string' [ , LANGUAGE language_term ] )
     * </pre>
     *
     * @return contains search condition
     */
    public TExpression getSearchCondition() {

        return searchCondition;
    }

    private TExpression columnNameOrListExpression;

    /**
     * set column name or column list of SQL Server contains predicate or freetext predicate
     *
     * @param columnNameOrListExpression column name or column list
     * @see #getColumnNameOrListExpression
     */
    public void setColumnNameOrListExpression(TExpression columnNameOrListExpression) {
        this.columnNameOrListExpression = columnNameOrListExpression;
    }

    /**
     * get column name or column list in SQL Server contains predicate.
     * <pre>
     * CONTAINS (
     * {
     * column_name | ( column_list )
     * | *
     * | PROPERTY ( { column_name }, 'property_name' )
     * }
     * , '&lt;contains_search_condition&gt;'
     * [ , LANGUAGE language_term ]
     * )
     *</pre>
     * Or column name or column list in freetext predicate
     * <pre>
     *     FREETEXT ( { column_name | (column_list) | * }
     *     , 'freetext_string' [ , LANGUAGE language_term ] )
     * </pre>
     *
     * If this expression represents a column name, then the type of this expression is {@link gudusoft.gsqlparser.EExpressionType#simple_object_name_t},
     * if this expression represents a column list, then the type of this expression is {@link gudusoft.gsqlparser.EExpressionType#list_t},
     *
     *
     * @return column name or column list
     */
    public TExpression getColumnNameOrListExpression() {

        return columnNameOrListExpression;
    }

    private TExpression startExpression;
    private TExpression lengthExpression;

    /**
     * set a start expression that specifies the position within {@link #getSourceExpression} that is to be the first
     * string unit of the result in substring function.
     * <pre>
     *     substring(sourceExpression from startExpression [for lengthExpression])
     *     substring(sourceExpression , startExpression [, lengthExpression])
     * </pre>
     *
     * @param startExpression an expression that specifies the position within {@link #getSourceExpression}
     * that is to be the first string unit of the result in substring function
     * @see #getStartExpression
     */
    public void setStartExpression(TExpression startExpression) {
        this.startExpression = startExpression;
    }

    /**
     * set the length expression in substring function.
     * <pre>
     *     substring(sourceExpression from startExpression [for lengthExpression])
     *     substring(sourceExpression , startExpression [, lengthExpression])
     * </pre>
     *
     * @param lengthExpression the length expression in substring function.
     * @see #getLengthExpression
     */
    public void setLengthExpression(TExpression lengthExpression) {
        this.lengthExpression = lengthExpression;
    }

    /**
     * A start expression that specifies the position within {@link #getSourceExpression} that is to be the first
     * string unit of the result in substring function.
     * <p>substring</p>
     * <pre>
     *     substring(sourceExpression from startExpression [for lengthExpression])
     *     substring(sourceExpression , startExpression [, lengthExpression])
     * </pre>
     *
     * @return an expression that specifies the position within {@link #getSourceExpression} that is to be the first
     * string unit of the result.
     */
    public TExpression getStartExpression() {

        return startExpression;
    }

    /**
     * The length of the {@link #getSourceExpression} string unit to be returned in substring function.
     * <p>substring</p>
     * <pre>
     *     substring(sourceExpression from startExpression [for lengthExpression])
     *     substring(sourceExpression , startExpression [, lengthExpression])
     * </pre>
     *
     * @return the length of the string unit to be returned.
     */
    public TExpression getLengthExpression() {
        return lengthExpression;
    }

    private TExpression sourceExpression;

    /**
     * set an expression that specifies the string from which the result is derived in substring function.
     * <pre>
     *     substring(sourceExpression from startExpression [for lengthExpression])
     *     substring(sourceExpression , startExpression [, lengthExpression])
     * </pre>
     *
     * @param sourceExpression An expression that specifies the string from which the result is derived
     * @see #getSourceExpression
     */
    public void setSourceExpression(TExpression sourceExpression) {
        this.sourceExpression = sourceExpression;
    }

    /**
     * An expression that specifies the string from which the result is derived in substring function.
     * <p>substring: DB2</p>
     * <pre>
     *     substring(sourceExpression from startExpression [for lengthExpression])
     *     substring(sourceExpression , startExpression [, lengthExpression])
     * </pre>
     *
     * @return An expression that specifies the string from which the result is derived
     */
    public TExpression getSourceExpression() {

        return sourceExpression;
    }

    private TExpression typeExpression;

    /**
     * a structured type expression in DB2 subtype-treatment: treat.
     *
     * @param typeExpression a structured type expression
     * @see #getTypeExpression
     */
    public void setTypeExpression(TExpression typeExpression) {
        this.typeExpression = typeExpression;
    }

    /**
     * A structured type expression in subtype-treatment.
     * <p>treat function: DB2, Greenplum</p>
     *
     * @return a structured type expression
     */
    public TExpression getTypeExpression() {

        return typeExpression;
    }

    private TExpression castOperand;

    /**
     * cast specification, set the first operand in the cast specification
     *
     * @param castOperand set the first operand in the cast specification
     * @see #getCastOperand
     */
    public void setCastOperand(TExpression castOperand) {
        this.castOperand = castOperand;
    }

    /**
     * The first operand in the cast specification.
     * <p>cast specification: DB2, Greenplum,SQL Server; try_cast function of SQL Server</p>
     *
     * @return The first operand in the cast specification
     */
    public TExpression getCastOperand() {

        return castOperand;
    }

    private TExpression dateExpression;

    /**
     * set date, time or timestamp expression in extract/extend function.
     *
     * @param dateExpression date, time or timestamp expression
     * @see #getDateExpression
     */
    public void setDateExpression(TExpression dateExpression) {
        this.dateExpression = dateExpression;
    }

    /**
     * date, time or timestamp expression in extract function of DB2, Greenplum.
     * <p>
     *     datetime or date value expression in extend function of informix.
     * </p>
     *
     * @return date, time or timestamp expression
     */
    public TExpression getDateExpression() {
        return dateExpression;
    }

    private TExpressionCallTarget callTarget;

    /**
     * set expressionCallTarget
     *
     * @param callTarget expression call target
     * @see #getCallTarget
     */
    public void setCallTarget(TExpressionCallTarget callTarget) {
        this.callTarget = callTarget;
    }

    /**
     * get an xml type column, parameter, variable or subquery.
     * <pre>
     *     DECLARE @myDoc xml
     *      DECLARE @ProdID int
     *      SET @myDoc = '&lt;Root&gt;
     *     &lt;ProductDescription ProductID="1" ProductName="Road Bike"&gt;
     *     &lt;Features&gt;
     *     &lt;Warranty&gt;1 year parts and labor &lt;/Warranty&gt;
     *     &lt;Maintenance&gt;3 year parts and labor extended maintenance is available &lt;/Maintenance&gt;
     *     &lt;/Features&gt;
     *     &lt;/ProductDescription&gt;
     *     &lt;/Root&gt;'
     *     SET @ProdID =  @myDoc.value('(/Root/ProductDescription/@ProductID)[1]', 'int' )
     *     SELECT @ProdID
     * </pre>
     *
     * the value returned by this method represents <code>@myDoc</code> before the value() function.
     *
     * SQL Server value() Method performs an XQuery against the XML and returns a value of SQL type.
     * <p></p>
     * You typically use this method to extract a value from an XML instance stored in an xml type
     * column, parameter, or variable.
     *
     * @return expressionCallTarget that represents an xml type column, parameter, variable or subquery
     */
    public TExpressionCallTarget getCallTarget() {

        return callTarget;
    }

    private TGroupConcatParam groupConcatParam;

    public void setGroupConcatParam(TGroupConcatParam groupConcatParam) {
        this.groupConcatParam = groupConcatParam;
    }

    public TGroupConcatParam getGroupConcatParam() {

        return groupConcatParam;
    }

    public static boolean isBuiltIn(String pName, EDbVendor pDBVendor){
        List<String> avVersions = functionChecker.getAvailableDbVersions(pDBVendor);
        if (avVersions == null || avVersions.isEmpty()) {
            return false;
        }
        return functionChecker.isBuiltInFunction(pName,pDBVendor,avVersions.get(avVersions.size()-1));
    }

    private boolean isCheckedBuiltIn = false;
    private boolean isBuiltIn = false;

    public boolean isBuiltIn(EDbVendor pDBVendor) {
        if (isCheckedBuiltIn) return isBuiltIn;
        List<String> avVersions = functionChecker.getAvailableDbVersions(pDBVendor);
        if (avVersions == null || avVersions.isEmpty()) {
            isBuiltIn = false;
        } else {
            isBuiltIn = functionChecker.isBuiltInFunction(this.functionName.toString(),pDBVendor,avVersions.get(avVersions.size()-1));
        }
        isCheckedBuiltIn = true;
        return isBuiltIn;
    }

    private TXMLPassingClause passingClause;

    public void setPassingClause(TXMLPassingClause passingClause) {
        this.passingClause = passingClause;
    }

    /**
     *  XMLPassingClause of XMLExists function
     * @return XMLPassingClause of XMLExists function
     */
    public TXMLPassingClause getPassingClause() {
        return passingClause;
    }

    private EAggregateType aggregateType = EAggregateType.none;

    /**
     * set <code>ALL | DISTINCT | UNIQUE</code> keywords used in an aggregate function.
     *
     * @param aggregateType
     * @see #getAggregateType
     */
    public void setAggregateType(EAggregateType aggregateType) {
        this.aggregateType = aggregateType;
    }

    /**
     * get <code>ALL | DISTINCT | UNIQUE</code> keywords used in an aggregate function.
     * An aggregate function performs a calculation on a set of values, and returns a single value.
     *
     * @return aggregate type, one of those values:  none,all,distinct,unique
     */
    public EAggregateType getAggregateType() {

        return aggregateType;
    }

    private  TOrderByItemList orderByList;

    public void setOrderByList(TOrderByItemList orderByList) {
        this.orderByList = orderByList;
    }

    /**
     * arguments in rank(value,...) function.
     * @return a list of {@link TOrderByItem} in function: rank, csum
     */
    public TOrderByItemList getOrderByList() {

        return orderByList;
    }

    private  TOrderBy sortClause;

    public void setSortClause(TOrderBy sortClause) {
        this.sortClause = sortClause;
    }

    /**
     * ORDER BY inside the argument list of an aggregate, such as
     * {@code LIST(x, ',' ORDER BY y)} (SQL Anywhere, Sybase IQ) or {@code string_agg(x, ',' ORDER BY y)}.
     * Its keys are resolved like the arguments of the call, not with the select-list alias rule of a
     * statement ORDER BY.
     * @return the ORDER BY clause, or null when the function has none
     */
    public TOrderBy getSortClause() {

        return sortClause;
    }

    /**
     * Over clause of analytic function
     * @return over clause
     */
    public TWindowDef getWindowDef() {
        return windowDef;
    }

    public void setWindowDef(TWindowDef windowDef) {

        this.windowDef = windowDef;
    }

    public void setFunctionOptionsWithDummy(TDummy dummy){
        if (dummy == null) return;
        if (dummy.node2 != null){
            setWindowDef((TWindowDef)dummy.node2 );
        }
        if (dummy.node3 != null){
            setWithinGroup((TWithinGroup) dummy.node3);
        }
    }

     protected TWindowDef windowDef;

//    public void setWindowSpecification(TWindowDef windowSpecification) {
//        this.windowSpecification = windowSpecification;
//    }

    /**
     * @deprecated As of v1.8.6.0, replaced by {@link #windowDef}
     */
    private TWindowSpecification windowSpecification;

    private TDatatypeAttribute datatypeAttribute = null;

    public TWindowSpecification getWindowSpecification() {
        return windowSpecification;
    }

    /**
     * Not used.
     *
     * @param datatypeAttribute datatype attribute
     */
    public void setDatatypeAttribute(TDatatypeAttribute datatypeAttribute) {
        this.datatypeAttribute = datatypeAttribute;
    }

    /**
     * Not used.
     *
     * @return datatype attribute
     */
    public TDatatypeAttribute getDatatypeAttribute() {

        return datatypeAttribute;
    }

    /**
     * one of the YEAR/MONTH/DAY, HOUR/MINUTE/SECOND keywords in extract function
     *
     * @return one of the YEAR/MONTH/DAY, HOUR/MINUTE/SECOND keywords in extract function
     */
    public TSourceToken getExtract_time_token() {
        return extract_time_token;
    }


    /**
     * set one of the YEAR/MONTH/DAY, HOUR/MINUTE/SECOND keyword in extract function
     *
     * @param extract_time_token one of the YEAR/MONTH/DAY, HOUR/MINUTE/SECOND token
     */
    public void setExtract_time_token(TSourceToken extract_time_token) {
        this.extract_time_token = extract_time_token;
    }


    private TDummy dummy = null;

    /**
     * Set value for temporary use only
     *
     * @param dummy a temporary value from parse tree
     */
    public void setDummy(TDummy dummy) {
        this.dummy = dummy;
    }

    /**
     * Not used
     *
     * @return a temporary value
     */
    public TDummy getDummy() {

        return dummy;
    }

    public void setInExpr(TInExpr inExpr) {
        this.inExpr = inExpr;
    }

    public TInExpr getInExpr() {

        return inExpr;
    }

    private TInExpr inExpr = null; //sql server, used in fntContains, fntFreetext

    public void setExtractXMLArg(TExpressionList exprList){
       if (exprList.size() > 1){
           this.XMLType_Instance = exprList.getExpression(0);
           this.XPath_String = exprList.getExpression(1);
       }

       if (exprList.size() > 2){
           this.Namespace_String = exprList.getExpression(2);
       }

       functionType = EFunctionType.extractxml_t;

    }
    private TExpression XMLType_Instance = null;

    public TExpression getNamespace_String() {
        return Namespace_String;
    }

    public TExpression getXPath_String() {

        return XPath_String;
    }

    public TExpression getXMLType_Instance() {

        return XMLType_Instance;
    }

    private TExpression XPath_String = null;
    private TExpression Namespace_String = null;


    private TObjectNameList matchColumns = null;

    /**
     * column list in match function of MySQL
     * @return
     */
    public TObjectNameList getMatchColumns() {
        return matchColumns;
    }

    /**
     * against expr in match function of MySQL
     * <pre>
     *     MATCH (col1,col2,...) AGAINST (expr [search_modifier])
     * </pre>
     *
     * @return expression after against keyword
     */
    public TExpression getAgainstExpr() {

        return againstExpr;
    }

    private TExpression againstExpr = null;

    public void setMatchColumns(TObjectNameList matchColumns) {
        this.matchColumns = matchColumns;
    }

    /**
     * against expr in match function of MySQL
     * <pre>
     *     MATCH (col1,col2,...) AGAINST (expr [search_modifier])
     * </pre>
     * @param againstExpr expression after against keyword
     */
    public void setAgainstExpr(TExpression againstExpr) {

        this.againstExpr = againstExpr;
    }

    private TTypeName typename = null;

    public void setTypename(TTypeName typename) {
        this.typename = typename;
    }

    public TTypeName getTypename() {

        return typename;
    }

    private TExpression parameter;

    public void setParameter(TExpression parameter) {
        this.parameter = parameter;
    }

    public void setStyle(TExpression style) {
        this.style = style;
    }

    /**
     * parameter in function:convert(datetype,parameter,style)
     * @return
     */
    public TExpression getParameter() {

        return parameter;
    }

    /**
     * style in function:convert(datetype,parameter,style)
     * @return
     */
    public TExpression getStyle() {
        return style;
    }

    private TExpression style;

    private TSourceToken extract_time_token = null;

     TExpression expr1 = null; //teradata position function, sql server: convert; oracle convert,translate  , mysql substring
     TExpression expr2 = null; //teradata: position,substring function,, sql server: convert; oracle convert, mysql substring
     TExpression expr3 = null; //teradata: substring function, for n, mysql substring

     protected EFunctionType functionType = EFunctionType.udf_t;

    /**
     * The function type as the parser set it. Unlike {@link #getFunctionType()}, it never looks an unknown type up:
     * that lookup renders the function name and caches a built-in check on this node, so a caller that must not
     * change the tree (the SQL-LR producer's classifier) reads this instead. The lookup only ever answers
     * {@code contains_t}, {@code builtin_t} or {@code unknown_t}, so for every other type the two agree.
     *
     * @return the parsed function type
     * @since 4.2.17
     */
    public EFunctionType getParsedFunctionType() {
        return functionType;
    }

    public EFunctionType getFunctionType() {
        if (functionType != EFunctionType.unknown_t){
            return functionType;
        }else if (getFunctionName().toString().toLowerCase(Locale.ROOT).equalsIgnoreCase("contains")){
            return EFunctionType.contains_t;
        }else if (isBuiltIn(this.dbvendor)){
            return  EFunctionType.builtin_t;
        }else{
            return functionType;
        }
    }

    public boolean hasParenthesis() {
        // 只有一个token，肯定不包含括号
        if ((this.getStartToken() != null) && (this.getEndToken() != null) && (this.getStartToken() == this.getEndToken())) return false;
        if (isOracleBuiltinFunction(this.dbvendor, this.getFunctionName().toString())) {
            return false;
        }

        //
        // 补充其他没有括号的情况
        //

        return true;
    }

    private boolean isOracleBuiltinFunction(EDbVendor dbvendor, String functionName) {
        if (dbvendor != EDbVendor.dbvoracle) return false;

        return functionName.equalsIgnoreCase("sysdate")
                || functionName.equalsIgnoreCase("user")
                || functionName.equalsIgnoreCase("SYSTIMESTAMP")
                || functionName.equalsIgnoreCase("CURRENT_DATE")
                || functionName.equalsIgnoreCase("CURRENT_TIMESTAMP")
                ;

    }

    TColumnDefinitionList fieldDefs;
    TResultColumnList fieldValues;

    public TColumnDefinitionList getFieldDefs() {
        return fieldDefs;
    }

    public TResultColumnList getFieldValues() {
        return fieldValues;
    }


    public TObjectName getFunctionName() {
        return functionName;
    }

    protected TObjectName functionName;

    public TExpression Trim_Expr = null;
    public TExpression Trim_From_Expr = null;


    public void setTrimArgument(TTrimArgument trimArgument) {
        this.trimArgument = trimArgument;
    }

    public TTrimArgument getTrimArgument() {

        return trimArgument;
    }

    TTrimArgument trimArgument = null;


    public void setExpr1(TExpression expr1) {
        this.expr1 = expr1;
    }

    public void setExpr2(TExpression expr2) {
        this.expr2 = expr2;
    }

    private TTypeName asDatatype;

    /**
     *  datatype defined in Oracle function: <code> XMLSERIALIZE(value_expr as datatype)</code>
     *
     * @param asDatatype datatype defined in Oracle function: <code> XMLSERIALIZE(value_expr as datatype)</code>
     */
    public void setAsDatatype(TTypeName asDatatype) {
        this.asDatatype = asDatatype;
    }

    private TResultColumnList XMLForestValueList;

    public void setXMLForestValueList(TResultColumnList XMLForestValueList) {
        this.XMLForestValueList = XMLForestValueList;
    }

    private TExpression XMLElementNameExpr;

    public void setXMLElementNameExpr(TExpression XMLElementNameExpr) {
        this.XMLElementNameExpr = XMLElementNameExpr;
    }

    /**
     * XMLElement name/evalname expr
     * @return XMLElement name/evalname expr
     */
    public TExpression getXMLElementNameExpr() {
        return XMLElementNameExpr;

    }

    private TXMLAttributesClause XMLAttributesClause;

    public void setXMLAttributesClause(TXMLAttributesClause XMLAttributesClause) {
        this.XMLAttributesClause = XMLAttributesClause;
    }

    public void setXmlPassingClause(TXMLPassingClause xmlPassingClause) {
        this.xmlPassingClause = xmlPassingClause;
    }

    public TXMLPassingClause getXmlPassingClause() {
        return xmlPassingClause;
    }

    TXMLPassingClause xmlPassingClause;


    private TResultColumnList XMLElementValueExprList;

    public void setXMLElementValueExprList(TResultColumnList XMLElementValueExprList) {
        this.XMLElementValueExprList = XMLElementValueExprList;
    }

    /**
     * XMLElement ( value_expr [,XML_attribute_clause] [,value expr list] )
     * @return XMLElement value expr list
     */
    public TResultColumnList getXMLElementValueExprList() {

        return XMLElementValueExprList;
    }

    /**
     * XMLAttribute clause in xmlelement function
     * @return XMLAttribute clause in xmlelement function
     */
    public TXMLAttributesClause getXMLAttributesClause() {

        return XMLAttributesClause;
    }

    /**
     * XMLFOREST (value_expr [as aliasName], ... )
     * @return XMLFOREST value list
     */
    public TResultColumnList getXMLForestValueList() {

        return XMLForestValueList;
    }

    /**
     * get datatype defined in Oracle XMLSERIALIZE(value_expr as datatype)
     *
     * @return datatype defined in oracle XMLSERIALIZE function
     */
    public TTypeName getAsDatatype() {

        return asDatatype;
    }

    /**
     * paramter of following functions
     * <br>teradata: position function,
     * <br>sql server: convert;
     * <br>oracle: convert,translate,cast,oracle XMLSERIALIZE(value_expr), oracle XMLROOT (value_expr)
     * <br>mysql: substring
     * @return
     */
    public TExpression getExpr1() {

        return expr1;
    }

    public TExpression getExpr2() {
        return expr2;
    }

    public void setExpr3(TExpression expr3) {
        this.expr3 = expr3;
    }

    public TExpression getExpr3() {

        return expr3;
    }


    public void setExprList(TExpressionList exprList) {
        this.exprList = exprList;
    }

    /**
     * return TExpressionList instead of TGroupingExpressionItemList after v1.4.3.3
     * @return    expr list
     */
    public TExpressionList getExprList() {

        return exprList;
    }

    private TExpressionList exprList = null;//teradata case_n, range_n


    protected TExpressionList Args = null;

    public void setArgs(TExpressionList args) {
        Args = args;
    }


    public void init(Object arg1){
        functionName = (TObjectName)arg1;
        if (functionName.getDbObjectType() == EDbObjectType.unknown){
            functionName.setObjectType(TObjectName.ttobjFunctionName);
        }
    }

    public void init(Object arg1,Object arg2){
        if (arg1 instanceof EFunctionType){
            functionType  = (EFunctionType)arg1;
            init(arg2);
        }
        else if (arg1 instanceof TObjectName){
            functionType  = (EFunctionType)arg2;
            init(arg1);
        }
        switch (functionType){
            case xmlmethod_t:
                if (functionName.getMethodToken().tokencode == TBaseType.rrw_xml_nodes){
                    functionType = EFunctionType.xmlnodes_t;
                }else if (functionName.getMethodToken().tokencode == TBaseType.rrw_xml_query){
                    functionType = EFunctionType.xml_sqlserver_query_t;
                }else if (functionName.getMethodToken().tokencode == TBaseType.rrw_xml_value){
                    functionType = EFunctionType.xmlvalue_t;
                }else if (functionName.getMethodToken().tokencode == TBaseType.rrw_xml_exist){
                    functionType = EFunctionType.xmlexists_t;
                }else if (functionName.getMethodToken().tokencode == TBaseType.rrw_xml_modify){
                    functionType = EFunctionType.xmlmodify_t;
                }
                break;
            case oracle_dbms_package_t:
                this.isBuiltIn = true;
                break;
            default:
                break;
        }
    }

    public void init(Object arg1,Object arg2,Object arg3){
        init(arg1,arg2);
        // For struct_t functions, store the field values (TResultColumnList)
        if (arg3 instanceof TResultColumnList) {
            if (this.functionType == EFunctionType.struct_t) {
                this.fieldValues = (TResultColumnList) arg3;
            }
        }
    }

    public void init(Object arg1,Object arg2,Object arg3,Object arg4){
        init(arg1,arg2,arg3);
        // For struct_t functions, store the field values (TResultColumnList)
        if (arg4 instanceof TResultColumnList) {
            if (this.functionType == EFunctionType.struct_t) {
                this.fieldValues = (TResultColumnList) arg4;
            }
        }
    }


    public void setAnalyticFunction(TAnalyticFunction analyticFunction) {
        this.analyticFunction = analyticFunction;
    }

    /**
     * get the list of parameters defined in this function
     *
     * @return the list of parameter
     */
    public TExpressionList getArgs() {
        return Args;
    }

     protected TAnalyticFunction analyticFunction;


    public void doParse(TCustomSqlStatement psql, ESqlClause plocation){
        this.dbvendor = psql.dbvendor;
        switch(functionType){
            case unknown_t:
            case chr_t:
            case udf_t:
            case builtin_t:
            case listagg_t:
            case year_t:
            case generate_date_array_t:
                if (callTarget != null){
                    callTarget.doParse(psql,plocation);
                }
                if (Args != null){
                    // Use TBuiltFunctionUtil to determine which argument positions contain keywords
                    // This supports datepart keywords like QUARTER, MONTH, YEAR, etc. across all databases.
                    // It is the only list: the old resolver and resolver2 read the same properties files, so a
                    // function a vendor does not have (Redshift has no DATENAME) is not marked here either.
                    Set<Integer> keywordPositions = null;
                    if (functionName != null) {
                        keywordPositions = TBuiltFunctionUtil.argumentsIncludeKeyword(
                            psql.dbvendor, functionName.toString());
                    }
                    markColumnOnlyArgument(psql);

                    for(int i=0;i<Args.size();i++){
                        // Check if this argument position is marked as a keyword position (1-based in properties)
                        boolean isKeywordPosition = (keywordPositions != null && keywordPositions.contains(i + 1));

                        if (isKeywordPosition) {
                            // Mark this argument as date_time_part so it's not treated as column reference
                            setFirstArgAsDateTimePart(i);
                            continue;
                        }
                        Args.getExpression(i).doParse(psql,plocation);
                    }
                }

                if (psql.dbvendor == EDbVendor.dbvmssql){
                    // check OGC function of sql server
//                    System.out.println("func:"+functionName.toString());
                    if (isSQLServerOGCMethod(functionName.getObjectToken())){
                        if (functionName.getSchemaToken() != null){
                            functionName.getSchemaToken().setDbObjType(TObjectName.ttobjColumn);
                            if (functionName.getDatabaseToken() != null){
                                functionName.getDatabaseToken().setDbObjType(TObjectName.ttobjTable);
                            }

                            TObjectName objectName = new TObjectName();
                            objectName.init(functionName.getDatabaseToken(),functionName.getSchemaToken());
                            objectName.setGsqlparser(psql.getGsqlparser()); // this will make toString work correctly
                            psql.linkColumnReferenceToTable(objectName,plocation);
                            psql.linkColumnToTable(objectName,plocation);
                        }
                    }else if (isSQLServerFunctionsONXMLColumn()) {


//                        if (functionName.getSchemaToken() != null) {
//                            functionName.getSchemaToken().setDbObjType(TObjectName.ttobjColumn);
//                            functionName.setPartToken(functionName.getSchemaToken());
//                            functionName.setSchemaToken(null);
//                            if (functionName.getDatabaseToken() != null) {
//                                functionName.getDatabaseToken().setDbObjType(TObjectName.ttobjTable);
//                                functionName.setObjectToken(functionName.getDatabaseToken());
//                            }
//
//                            TObjectName objectName = new TObjectName();
//                            objectName.init(functionName.getObjectToken(), functionName.getPartToken());
//                            objectName.setGsqlparser(psql.getGsqlparser()); // this will make toString work correctly
//                            psql.linkColumnReferenceToTable(objectName, plocation);
//                            psql.linkColumnToTable(objectName, plocation);
//                        }

                    }
                } else if (psql.dbvendor == EDbVendor.dbvoracle){
                    if (plocation == ESqlClause.spAssignValue){
                        if (functionName.getNumberOfPart() == 3){
                            // schema1.pkg1.GETCUSTOMERNAME(2)
                            functionName.setPackageToken(functionName.getSchemaToken());
                            functionName.setSchemaToken(functionName.getDatabaseToken());
                            functionName.setServerToken(null);
                        }
                    }
                } else if (psql.dbvendor == EDbVendor.dbvteradata){
                    // Handle NPath function - extract ON clause tables for data lineage
                    if (functionName != null && functionName.toString().equalsIgnoreCase("NPath")){
                        analyzeTeradataNPathOnClause(psql, plocation);
                    }
                }
                break;
            case trim_t:
                if (this.trimArgument != null){
                this.trimArgument.doParse(psql,plocation);
                }

                break;
            case cast_t:
                if (this.expr1 != null){
                    this.expr1.doParse(psql,plocation);
                }else{
                    this.getArgs().getExpression(0).doParse(psql,plocation);
                }

                break;
            case convert_t:
                if (this.typename != null) this.typename.doParse(psql,plocation);
                this.parameter.doParse(psql,plocation);
                if (this.style != null)
                { //sql server
                    this.style.doParse(psql,plocation);
                }
                break;
            case extract_t:
                if (this.expr1 != null){
                    this.expr1.doParse(psql,plocation);
                }
                break;
            case treat_t:
                this.expr1.doParse(psql,plocation);
                break;
            case contains_t:
                //this.inExpr.doParse(psql,plocation);

                this.expr1.doParse(psql,plocation);
                this.expr2.doParse(psql,plocation);
                break;
            case freetext_t:
                //inExpr.doParse(psql,plocation);
                this.expr1.doParse(psql,plocation);
                this.expr2.doParse(psql,plocation);
                break;
            case case_n_t:
                this.getArgs().doParse(psql, plocation);
                break;
//            case range_n_t:
//                this.expr1.doParse(psql,plocation);
//                for(TRangeNFunctionItem rangeItem : rangeNFunctionItems){
//                    rangeItem.doParse(psql,plocation);
//                }
//                break;
            case position_t:
                expr1.doParse(psql,plocation);
                expr2.doParse(psql,plocation);
                break;
            case substring_t:
                if (Args != null)
                    for(int i=0;i<Args.size();i++){
                        Args.getExpression(i).doParse(psql,plocation);
                    }
                if (expr1 != null) expr1.doParse(psql,plocation);
                if (expr2 != null) expr2.doParse(psql,plocation);
                if (expr3 != null){
                    expr3.doParse(psql,plocation);
                }
                break;
            case xmlquery_t:
                if (xmlPassingClause != null){
                    xmlPassingClause.doParse(psql,plocation);
                }
                break;
            case xmlcast_t:
                if (typeExpression != null){
                    typeExpression.doParse(psql,plocation);
                }
                break;
            case match_against_t:
                for(int i=0;i<this.getMatchColumns().size();i++){
                    psql.linkColumnReferenceToTable(this.getMatchColumns().getObjectName(i),plocation);
                    psql.linkColumnToTable(this.getMatchColumns().getObjectName(i),plocation);
                }
                this.getAgainstExpr().doParse(psql,plocation);
                break;
            case adddate_t:
            case date_add_t:
            case subdate_t:
            case date_sub_t:
            case timestampadd_t:
            case timestampdiff_t:
                expr1.doParse(psql,plocation);
                expr2.doParse(psql,plocation);
                break;
            case xmlserialize_t:
                if (expr1 != null){
                    expr1.doParse(psql,plocation);
                }else if (typeExpression != null){
                    typeExpression.doParse(psql,plocation);
                }
                break;
            case xmlroot_t:
                expr1.doParse(psql,plocation);
                break;
            case xmlforest_t:
                XMLForestValueList.doParse(psql, plocation);
                break;
            case xmlelement_t:
                if (XMLElementNameExpr.getExpressionType() == EExpressionType.simple_object_name_t){
                    XMLElementNameExpr.getObjectOperand().setDbObjectType(EDbObjectType.xmlElement);
                }
                XMLElementNameExpr.doParse(psql,ESqlClause.xmlElementName);
                if (XMLAttributesClause != null)
                  XMLAttributesClause.doParse(psql,plocation);
                if (XMLElementValueExprList != null)
                    XMLElementValueExprList.doParse(psql,plocation);
                break;
            case translate_t:
                expr1.doParse(psql,plocation);
                if (expr2 != null)  expr2.doParse(psql,plocation);
                if (expr3 != null)  expr3.doParse(psql,plocation);
                break;
            case group_concat_t:
                groupConcatParam.doParse(psql,plocation);
                break;
            case quantile_t:
                this.orderByList.doParse(psql,plocation);
                break;
            case csum_t:
                this.getOrderByList().doParse(psql,plocation);
                break;
            case rank_t:
                if (this.getOrderByList() != null){
                    this.getOrderByList().doParse(psql,plocation);
                }

                break;
            case xmlexists_t:
            case xmlmodify_t:
            case xmlnodes_t:
            case xmlvalue_t:
            case xml_sqlserver_query_t:
                if (callTarget != null){
                    callTarget.doParse(psql,plocation);
                }
                if ((functionName.getObjectToken() != null)&&(functionName.getPartToken() != null)){
                    TObjectName objectName = new TObjectName();
                    objectName.init(functionName.getObjectToken(), functionName.getPartToken());
                    objectName.setGsqlparser(psql.getGsqlparser()); // this will make toString work correctly
                    psql.linkColumnReferenceToTable(objectName, plocation);
                    psql.linkColumnToTable(objectName, plocation);
                }
                break;
            case xmlagg_t:
                for(int i=0;i<Args.size();i++){
                    Args.getExpression(i).doParse(psql,plocation);
                }
                break;
            case if_t:
                expr1.doParse(psql,plocation);
                expr2.doParse(psql,plocation);
                expr3.doParse(psql,plocation);
                break;
            case array_t: // bigquery array (subquery)
                this.getArgs().getExpression(0).doParse(psql,plocation);
                break;
            case array_agg_t:
                this.getArgs().getExpression(0).doParse(psql,plocation);
                break;
            case string_agg_t:
                this.getArgs().getExpression(0).doParse(psql,plocation);
                if (getOrderByList() != null){
                    getOrderByList().doParse(psql,plocation);
                }
                break;
            default:
                if (getArgs() != null){
                    for(int i=0;i<getArgs().size();i++){
                        Args.getExpression(i).doParse(psql,plocation);
                    }
                }
                break;
        }

        // ORDER BY inside the argument list, as in LIST(x, ',' ORDER BY y), string_agg(x, ',' ORDER BY y) or
        // XMLAGG(x ORDER BY y). Its keys are linked like the arguments, not through TOrderBy.doParse: that
        // one applies the rules of a statement ORDER BY, where an unqualified key may name a select-list alias.
        if (sortClause != null){
            TOrderByItemList sortItems = sortClause.getItems();
            for(int i=0;i<sortItems.size();i++){
                TExpression sortKey = sortItems.getOrderByItem(i).getSortKey();
                if (sortKey != null){
                    sortKey.doParse(psql,plocation);
                }
            }
        }

        if (withinGroup != null){
            withinGroup.doParse(psql,plocation);
        }
        if (analyticFunction != null){
            analyticFunction.doParse(psql,plocation);
        }

        if (filterClause != null){
            filterClause.doParse(psql,plocation);
        }

        if (windowDef != null){
            windowDef.doParse(psql,plocation);
        }
    }


    /**
     * @deprecated As of v1.8.6.3, use {@link #getWindowDef()} instead
     * window clause in window function.
     * @return a value of {@link TAnalyticFunction}
     * @see TAnalyticFunction
     */
    public TAnalyticFunction getAnalyticFunction() {
        return analyticFunction;
    }

    public void accept(TParseTreeVisitor v){
        v.preVisit(this);
        v.postVisit(this);
    }

    public void acceptChildren(TParseTreeVisitor v){
        v.preVisit(this);
        // SQL Server method chain T.c.query('.').value('.', 'int') (MantisBT 4897): the call target is the
        // inner method call, and it is the only node that names the column, so walk it. The other call
        // targets (a column, a variable, a subquery) are not walked, as before.
        if ((callTarget != null) && (callTarget.getExpr() != null)
                && (callTarget.getExpr().getExpressionType() == EExpressionType.function_t)){
            callTarget.acceptChildren(v);
        }
        functionName.acceptChildren(v);
        switch(functionType){
            case unknown_t:
                if (Args != null){
                    Args.acceptChildren(v);
                }
                break;
            case udf_t:
                if (Args != null){
                    Args.acceptChildren(v);
                }
                if (analyticFunction != null){
                    analyticFunction.acceptChildren(v);
                }
                break;
            case trim_t:
                if (this.trimArgument != null){
                    this.trimArgument.acceptChildren(v);
                }

                break;
            case cast_t:
                if (this.expr1 != null) {
                    this.expr1.acceptChildren(v);
                }else{
                    this.getArgs().getExpression(0).acceptChildren(v);
                }

                break;
            case convert_t:
                if (this.typename != null) this.typename.acceptChildren(v);
                if (this.parameter != null) this.parameter.acceptChildren(v);
                if (this.style != null) this.style.acceptChildren(v);
//                this.expr1.acceptChildren(v);
//                if (this.expr2 != null)
//                { //sql server
//                    this.expr2.acceptChildren(v);
//                }
                break;
            case extract_t:
                if (this.expr1 != null){
                    this.expr1.acceptChildren(v);
                }
                break;
            case treat_t:
                this.expr1.acceptChildren(v);
                break;
            case contains_t:
                //this.inExpr.acceptChildren(v);

                this.expr1.acceptChildren(v);
                this.expr2.acceptChildren(v);
                break;
            case freetext_t:
                //inExpr.acceptChildren(v);
                this.expr1.acceptChildren(v);
                this.expr2.acceptChildren(v);
                break;
            case case_n_t:
                this.getArgs().acceptChildren(v);
                break;
//            case range_n_t:
//                this.expr1.acceptChildren(v);
//                for(TRangeNFunctionItem item:rangeNFunctionItems){
//                    item.acceptChildren(v);
//                }
//
//                break;
            case position_t:
                expr1.acceptChildren(v);
                expr2.acceptChildren(v);
                break;
            case substring_t:
                if (Args != null){
                    Args.acceptChildren(v);
                }
                if (expr1 != null) expr1.acceptChildren(v);
                if (expr2 != null) expr2.acceptChildren(v);
                if (expr3 != null){
                    expr3.acceptChildren(v);
                }
                break;
            case xmlquery_t:
                break;
            case xmlcast_t:
                break;
            case match_against_t:
                //for(int i=0;i<this.getMatchColumns().size();i++){
                //    psql.linkColumnReferenceToTable(this.getMatchColumns().getObjectName(i),plocation);
                //}
                this.getAgainstExpr().acceptChildren(v);
                break;
            case adddate_t:
            case date_add_t:
            case subdate_t:
            case date_sub_t:
            case timestampadd_t:
            case timestampdiff_t:
                expr1.acceptChildren(v);
                expr2.acceptChildren(v);
                break;
            default:
                if (Args != null){
                    Args.acceptChildren(v);
                }
                break;
        }

        if (analyticFunction != null){
            analyticFunction.acceptChildren(v);
        }

        if (filterClause != null){
            filterClause.acceptChildren(v);
        }

        if (windowDef != null){
            windowDef.acceptChildren(v);
        }

        v.postVisit(this);
    }

     boolean isSQLServerFunctionsONXMLColumn(){
//        return ((st.tokencode == TBaseType.rrw_xml_exist)
//                ||(st.tokencode == TBaseType.rrw_xml_query)
//                ||(st.tokencode == TBaseType.rrw_xml_modify)
//                ||(st.tokencode == TBaseType.rrw_xml_nodes)
//                ||(st.tokencode == TBaseType.rrw_xml_value)
//                );
        return ((this.functionType == EFunctionType.xmlmodify_t)
                ||(this.functionType == EFunctionType.xmlvalue_t)
                ||(this.functionType == EFunctionType.xmlnodes_t)
                ||(this.functionType == EFunctionType.xmlexists_t)
                ||(this.functionType == EFunctionType.xmlquery_t)
        );
    }

    /**
     * MySQL {@code VALUES(col)} and {@code DEFAULT(col)} take a column's name, so a variable of that name is never
     * read there, though MySQL reads a variable before a column elsewhere (Mantis 4797).
     */
    private void markColumnOnlyArgument(TCustomSqlStatement psql){
        if ((!psql.isMySQLDialect()) || (functionName == null) || (functionName.getNumberOfPart() != 1)) return;
        if ((Args == null) || (Args.size() != 1)) return;
        String name = functionName.toString();
        if (!("VALUES".equalsIgnoreCase(name) // non-identifier-compare: built-in function keyword
                || "DEFAULT".equalsIgnoreCase(name))) return; // non-identifier-compare: built-in function keyword
        TExpression arg = Args.getExpression(0);
        if ((arg != null) && (arg.getExpressionType() == EExpressionType.simple_object_name_t)
                && (arg.getObjectOperand() != null)){
            arg.getObjectOperand().setColumnOnly(true);
        }
    }

     boolean isSQLServerOGCMethod(TSourceToken st){
        return ((st.tokencode == TBaseType.rrw_starea)
                ||(st.tokencode == TBaseType.rrw_stasbinary)
                ||(st.tokencode == TBaseType.rrw_stastext)
                ||(st.tokencode == TBaseType.rrw_stbuffer)
                ||(st.tokencode == TBaseType.rrw_stdimension)
                ||(st.tokencode == TBaseType.rrw_stdisjoint)
                ||(st.tokencode == TBaseType.rrw_stdistance)
                ||(st.tokencode == TBaseType.rrw_stendpoint)
                ||(st.tokencode == TBaseType.rrw_stgeometryn)
                ||(st.tokencode == TBaseType.rrw_stgeometrytype)
                ||(st.tokencode == TBaseType.rrw_stintersection)
                ||(st.tokencode == TBaseType.rrw_stintersects)
                ||(st.tokencode == TBaseType.rrw_stisclosed)
                ||(st.tokencode == TBaseType.rrw_stisempty)
                ||(st.tokencode == TBaseType.rrw_stlength)
                ||(st.tokencode == TBaseType.rrw_stnumgeometries)
                ||(st.tokencode == TBaseType.rrw_stnumpoints)
                ||(st.tokencode == TBaseType.rrw_stpointn)
                ||(st.tokencode == TBaseType.rrw_stsrid)
                ||(st.tokencode == TBaseType.rrw_ststartpoint)
                ||(st.tokencode == TBaseType.rrw_stunion)
                );
    }

    /**
     * @deprecated As of v1.4.3.0, replaced by {@link #functionType}
     */
    private int funcType = fntUdf;

    /**
     * @deprecated As of v1.4.3.0
     */
    public void setFuncType(int funcType) {
        this.funcType = funcType;

    }

    /**
     * @deprecated As of v1.4.3.0, replaced by {@link #getFunctionType()}.
     */
    public int getFuncType() {

        return funcType;
    }

    /**
     * @deprecated As of v1.4.3.0, replaced by {@link EFunctionType#udf_t}
     */
    public final static int fntUdf = 0;

    /**
     * @deprecated As of v1.4.3.0, replaced by {@link EFunctionType#trim_t}
     */
    public final static int fntTrim = 1;

    /**
     * @deprecated As of v1.4.3.0, replaced by {@link EFunctionType#cast_t}
     */
    public final static int fntCast = 2;

    /**
     * @deprecated As of v1.4.3.0, replaced by {@link EFunctionType#convert_t}
     */
    public final static int fntConvert = 3;

    /**
     * @deprecated As of v1.4.3.0, replaced by {@link EFunctionType#extract_t}
     */
    public final static int fntExtract = 4;

    /**
     * @deprecated As of v1.4.3.0, replaced by {@link EFunctionType#treat_t}
     */
    public final static int fntTreat = 5;

    /**
     * @deprecated As of v1.4.3.0, replaced by {@link EFunctionType#contains_t}
     */
    public final static int fntContains = 6;

    /**
     * @deprecated As of v1.4.3.0, replaced by {@link EFunctionType#freetext_t}
     */
    public final static int fntFreetext = 7; //

    /**
     * @deprecated As of v1.4.3.0, replaced by {@link EFunctionType#case_n_t}
     */
    public final static int fntCaseN = 10; //teradata

    /**
     * @deprecated As of v1.4.3.0, replaced by {@link EFunctionType#range_n_t}
     */
    public final static int fntRangeN = 11; //teradata

    /**
     * @deprecated As of v1.4.3.0, replaced by {@link EFunctionType#position_t}
     */
    public final static int fntPosition = 12; //teradata
    /**
     * @deprecated As of v1.4.3.0, replaced by {@link EFunctionType#substring_t}
     */
    public final static int fntSubstring = 13; //teradata
    /**
     * @deprecated As of v1.4.3.0, replaced by {@link EFunctionType#translate_t}
     */
    public final static int fntTranslate = 14; //teradata ,oracle
    /**
     * @deprecated As of v1.4.3.0, replaced by {@link EFunctionType#translate_chk_t}
     */
    public final static int fntTranslateCHK = 15; //teradata
    /**
     * @deprecated As of v1.4.3.0, replaced by {@link EFunctionType#csum_t}
     */
    public final static int fntCSUM = 16; //teradata
    /**
     * @deprecated As of v1.4.3.0, replaced by {@link EFunctionType#rank_t}
     */
    public final static int fntRank = 17; //teradata
    /**
     * @deprecated As of v1.4.3.0, replaced by {@link EFunctionType#xmlquery_t}
     */
    public final static int fntXmlQuery= 18; //oracle

    /**
     * @deprecated As of v1.4.3.0, replaced by {@link EFunctionType#substring_t}
     */
    public final static int fntSubString  = 31;//mysql
    /**
     * @deprecated As of v1.4.3.0, replaced by {@link EFunctionType#adddate_t}
     */
    public final static int fntAddDate  = 32;//mysql
    /**
     * @deprecated As of v1.4.3.0, replaced by {@link EFunctionType#date_add_t}
     */
    public final static int fntDateAdd  = 33;//mysql
    /**
     * @deprecated As of v1.4.3.0, replaced by {@link EFunctionType#subdate_t}
     */
    public final static int fntSubDate  = 34;//mysql
    /**
     * @deprecated As of v1.4.3.0, replaced by {@link EFunctionType#date_sub_t}
     */
    public final static int fntDateSub  = 35;//mysql
    /**
     * @deprecated As of v1.4.3.0, replaced by {@link EFunctionType#timestampadd_t}
     */
    public final static int fntTimestampAdd  = 36;//mysql
    /**
     * @deprecated As of v1.4.3.0, replaced by {@link EFunctionType#timestampdiff_t}
     */
    public final static int fntTimestampDiff  = 37;//mysql
    /**
     * @deprecated As of v1.4.3.0, replaced by {@link EFunctionType#group_concat_t}
     */
    public final static int fntGroupConcat  = 38;//mysql
    /**
     * @deprecated As of v1.4.3.0, replaced by {@link EFunctionType#match_against_t}
     */
    public final static int fntMatchAgainst  = 39;//mysql

    /**
     * @deprecated As of v1.4.3.0, replaced by {@link EFunctionType#extract_t}
     */
    public final static int fntExtractXML  = 50;//oracle


    /**
     * @deprecated As of v1.4.3.0, replaced by {@link EFunctionType#ogc_t}
     */
    public final static int fntOGC  = 60;

    public void setCheckedBuiltIn(boolean isCheckedBuiltIn) {
        this.isCheckedBuiltIn = isCheckedBuiltIn;
    }

    public void setBuiltIn(boolean isBuiltIn) {
        this.isBuiltIn = isBuiltIn;
    }

    public void setXMLType_Instance(TExpression XMLType_Instance) {
        this.XMLType_Instance = XMLType_Instance;
    }

    public void setXPath_String(TExpression XPath_String) {
        this.XPath_String = XPath_String;
    }

    public void setNamespace_String(TExpression namespace_String) {
        Namespace_String = namespace_String;
    }

    public void setFunctionType(EFunctionType functionType) {
        this.functionType = functionType;
    }

    public void setFunctionName(TObjectName functionName) {
        this.functionName = functionName;
    }

    public void setTrim_Expr(TExpression trim_Expr) {
        Trim_Expr = trim_Expr;
    }

    public void setTrim_From_Expr(TExpression trim_From_Expr) {
        Trim_From_Expr = trim_From_Expr;
    }

    /**
     * Extracts and analyzes tables from Teradata NPath function's ON clause.
     * The NPath function syntax is: NPath(ON table_or_subquery PARTITION BY ... USING ...)
     * This method parses the ON clause to extract table references for data lineage.
     */
    private void analyzeTeradataNPathOnClause(TCustomSqlStatement psql, ESqlClause plocation) {
        String funcText = this.toString();
        if (funcText == null || funcText.isEmpty()) {
            return;
        }

        // Find the ON clause
        String upperFuncText = funcText.toUpperCase(Locale.ROOT);
        int onIndex = upperFuncText.indexOf(" ON ");
        if (onIndex < 0) {
            onIndex = upperFuncText.indexOf("(ON ");
            if (onIndex >= 0) {
                onIndex++; // Skip the opening parenthesis
            }
        }
        if (onIndex < 0) {
            return;
        }

        // Extract text after ON
        String afterOn = funcText.substring(onIndex + 4).trim();
        if (afterOn.isEmpty()) {
            return;
        }

        try {
            if (afterOn.startsWith("(")) {
                // It's a subquery - find matching closing parenthesis
                int depth = 0;
                int endPos = -1;
                for (int i = 0; i < afterOn.length(); i++) {
                    char c = afterOn.charAt(i);
                    if (c == '(') depth++;
                    else if (c == ')') {
                        depth--;
                        if (depth == 0) {
                            endPos = i + 1;
                            break;
                        }
                    }
                }
                if (endPos > 0) {
                    String subqueryText = afterOn.substring(0, endPos);
                    // Parse the subquery to extract tables
                    TGSqlParser subParser = new TGSqlParser(EDbVendor.dbvteradata);
                    subParser.sqltext = "SELECT * FROM " + subqueryText + " __npath_on";
                    if (subParser.parse() == 0 && subParser.sqlstatements.size() > 0) {
                        gudusoft.gsqlparser.stmt.TSelectSqlStatement subSelect =
                            (gudusoft.gsqlparser.stmt.TSelectSqlStatement) subParser.sqlstatements.get(0);
                        if (subSelect.tables != null && subSelect.tables.size() > 0) {
                            TTable onTable = subSelect.tables.getTable(0);
                            // If it has a subquery, analyze its tables
                            if (onTable.getSubquery() != null) {
                                for (int i = 0; i < onTable.getSubquery().tables.size(); i++) {
                                    TTable sourceTable = onTable.getSubquery().tables.getTable(i);
                                    addNPathSourceTable(sourceTable, psql);
                                }
                            }
                        }
                    }
                }
            } else {
                // It's a direct table reference - extract until whitespace or special char
                StringBuilder tableName = new StringBuilder();
                for (int i = 0; i < afterOn.length(); i++) {
                    char c = afterOn.charAt(i);
                    if (Character.isWhitespace(c) || c == ')' || c == ',') {
                        break;
                    }
                    tableName.append(c);
                }
                if (tableName.length() > 0) {
                    // Parse the table reference
                    TGSqlParser subParser = new TGSqlParser(EDbVendor.dbvteradata);
                    subParser.sqltext = "SELECT * FROM " + tableName.toString() + " __npath_on";
                    if (subParser.parse() == 0 && subParser.sqlstatements.size() > 0) {
                        gudusoft.gsqlparser.stmt.TSelectSqlStatement subSelect =
                            (gudusoft.gsqlparser.stmt.TSelectSqlStatement) subParser.sqlstatements.get(0);
                        if (subSelect.tables != null && subSelect.tables.size() > 0) {
                            TTable sourceTable = subSelect.tables.getTable(0);
                            addNPathSourceTable(sourceTable, psql);
                        }
                    }
                }
            }
        } catch (Exception e) {
            // Silently ignore parsing errors - the main query still works
        }
    }

    /**
     * Adds a source table from NPath ON clause to the current statement's table list.
     */
    private void addNPathSourceTable(TTable sourceTable, TCustomSqlStatement psql) {
        if (sourceTable == null || psql == null) {
            return;
        }
        // Mark the table as coming from NPath ON clause
        sourceTable.setNPathOnClauseTable(true);
        // Add to the statement's table list
        if (psql.tables == null) {
            psql.tables = new TTableList();
        }
        psql.tables.addTable(sourceTable);
    }

}