001package gudusoft.gsqlparser.nodes;
002
003import gudusoft.gsqlparser.*;
004import gudusoft.gsqlparser.nodes.couchbase.TUpdateFor;
005import gudusoft.gsqlparser.nodes.teradata.TDataConversion;
006import gudusoft.gsqlparser.nodes.teradata.TDataConversionItem;
007import gudusoft.gsqlparser.sqlenv.IdentifierService;
008import gudusoft.gsqlparser.sqlenv.TSQLEnv;
009
010import java.util.ArrayList;
011
012import static gudusoft.gsqlparser.sqlenv.ESQLDataObjectType.dotColumn;
013
014/**
015* This class represents select_list item in select statement, lets you specify the columns you want to retrieve from the table.
016 *<p>Syntax:
017 * <blockquote><pre>
018 * query_name|[schema.]{table|view|materialized_view}|expr [ [AS] alias]</pre>
019 * </blockquote>
020 *
021 * 
022 *<p>or, set column values in update_set_clause.
023 *<p>Syntax:
024 *<p><blockquote>column = expr|(subquery) </blockquote>
025 *
026 * <p>or, values clause in insert statement was represented by {@link TResultColumnList}.
027 *<p>Syntax:
028 *<p><blockquote><pre>(expr,expr) </pre></blockquote>
029 *
030*/
031public class TResultColumn extends TNodeWithAliasClause implements Comparable{
032
033
034    // sparksql: select explode(str_to_map(regexp_replace(regexp_replace(regexp_replace(lower(t.input), '', ''), '',''), '', ''), '', '')) as (`key`, `value`) from B t1
035    // select t.a1, t.a2, stack(2, 'T', t.a1, t.a2, t.a3/t.a4, t.a5/t.a6,   'T+0', t.a7, t.a8, t.a9/t.a10, t.a11/t.a12) as (b1, b2, b3, b4, b5)  from db1.table1 t
036    // explode and stack functions are used to convert array or map into rows and create new column names
037    private ArrayList<TObjectName> aliasNameList = null;
038
039    public ArrayList<TObjectName> getAliasNameList() {
040        if (aliasNameList == null) {
041            aliasNameList = new ArrayList<>();
042        }
043        return aliasNameList;
044    }
045
046    private ArrayList<TObjectName> attributesFromUpLevelReferenceToStarColumn;
047
048    /**
049     * 这个属性只对 star column 有效。用来存放在 up level 中找到的关联到本 star column 的 column，
050     * 主要用来把来自 up level 的这些 column 继续和 本层 from clause 中的 table 关联起来，
051     * 以解决 up level column 来自低层哪个 table 的问题
052     *
053     * 实现代码见：TStarColumnPushDownResolver.preVisit(TSelectSqlStatement stmt)，
054     * TAttributeNode.addAttributeRefToThisNode(TObjectName objectName)
055     *
056     * @return
057     */
058    public ArrayList<TObjectName> getAttributesFromUpLevelReferenceToStarColumn() {
059        if (attributesFromUpLevelReferenceToStarColumn == null){
060            attributesFromUpLevelReferenceToStarColumn = new ArrayList<>();
061        }
062        return attributesFromUpLevelReferenceToStarColumn;
063    }
064
065    private String aliasName;
066
067    public void setAliasName(String aliasName) {
068        this.aliasName = aliasName;
069    }
070
071    public String getAliasName() {
072        return aliasName;
073    }
074
075    private ArrayList<TReplaceExprAsIdentifier> exprAsIdentifiers;
076
077    /**
078     * BigQuery replace columns
079     * <br>
080     * SELECT * REPLACE (quantity/2 AS quantity)
081     *
082     * @return replace expr as identifier list
083     */
084    public ArrayList<TReplaceExprAsIdentifier> getExprAsIdentifiers() {
085        return exprAsIdentifiers;
086    }
087
088    /**
089     * Bigquery except columns
090     * SELECT COMMON.* EXCEPT (column1, column2) FROM dataset1.table1 COMMON;
091     *
092     * @return Bigquery except columns
093     */
094    public TObjectNameList getExceptColumnList() {
095        return exceptColumnList;
096    }
097
098    private TObjectNameList exceptColumnList;
099
100    /**
101     * BigQuery select * except(expr as identifier)
102     * @return
103     */
104    public ArrayList<TReplaceExprAsIdentifier> getReplaceExprAsIdentifiers() {
105        return replaceExprAsIdentifiers;
106    }
107
108    private  ArrayList<TReplaceExprAsIdentifier>  replaceExprAsIdentifiers;
109
110    private TQualifyClause qualifyClause;
111
112    public void setQualifyClause(TQualifyClause qualifyClause) {
113        this.qualifyClause = qualifyClause;
114    }
115
116    public TQualifyClause getQualifyClause() {
117
118        return qualifyClause;
119    }
120
121    public void setDataTypeConversionList(TPTNodeList<TExplicitDataTypeConversion> dataTypeConversionList) {
122        expr.setDataTypeConversionList(dataTypeConversionList);
123    }
124
125    private  TPTNodeList <TExplicitDataTypeConversion> dataTypeConversionList = null; // teradata
126
127    private TObjectNameList targetColumns = null;
128
129    public TObjectNameList getTargetColumns() {
130        if (targetColumns == null) targetColumns = new TObjectNameList();
131        return targetColumns;
132    }
133
134    public boolean isMatchedUsingAlias(TObjectName pColumn){
135        boolean lcResult = pColumn.getColumnNameOnly().equalsIgnoreCase(getColumnAlias());
136        return lcResult;
137    }
138
139    public boolean isMatchedWithResultColumn(EDbVendor dbVendor, TObjectName pColumn){
140       // boolean lcResult = pColumn.getColumnNameOnly().equalsIgnoreCase(getColumnAlias());
141        //boolean lcResult = TSQLObject.compareTo(dbVendor, ESQLDataObjectType.dotColumn,pColumn.getColumnNameOnly(),getColumnAlias()) == 0;
142        boolean lcResult = TSQLEnv.compareIdentifier(dbVendor, dotColumn,pColumn.getColumnNameOnly(),getColumnAlias());
143        if ((getColumnAlias().length() > 0) && (!lcResult)){
144            return lcResult;
145        }
146        if (! lcResult) {
147            //lcResult = pColumn.getColumnNameOnly().equalsIgnoreCase(getColumnNameOnly());
148            //lcResult = TSQLObject.compareTo(dbVendor, ESQLDataObjectType.dotColumn,pColumn.getColumnNameOnly(),getColumnNameOnly()) == 0;
149            lcResult = TSQLEnv.compareIdentifier(dbVendor, dotColumn,pColumn.getColumnNameOnly(),getColumnNameOnly());
150        }
151
152        return lcResult;
153    }
154
155    public void TResultColumn(){
156
157    }
158
159    /**
160     * This is the display name shown in the output of select list
161     * @return display name
162     */
163    public String getDisplayName(){
164        if (getAliasClause() != null) return  getAliasClause().toString();
165        String result = "";
166        switch (expr.getExpressionType()){
167            case sqlserver_proprietary_column_alias_t:
168                if (expr.getRightOperand().getExpressionType() == EExpressionType.simple_object_name_t){
169                    result = expr.getRightOperand().getObjectOperand().getColumnNameOnly();
170                }
171                break;
172            case simple_object_name_t:
173                result = expr.getObjectOperand().getColumnNameOnly();
174                break;
175            default:
176                result = toString();
177                break;
178        }
179        return result;
180    }
181
182    public String getColumnAlias(){
183        if (getAliasClause() != null) return  getAliasClause().toString();
184        else return "";
185    }
186
187    public TObjectName getColumnFullname(){
188        TObjectName result = null;
189        switch (expr.getExpressionType()){
190            case sqlserver_proprietary_column_alias_t:
191                if (expr.getRightOperand().getExpressionType() == EExpressionType.simple_object_name_t){
192                    result = expr.getRightOperand().getObjectOperand();
193                }
194                break;
195            case simple_object_name_t:
196                result = expr.getObjectOperand();
197                break;
198            default:
199                break;
200        }
201        return result;
202    }
203
204    public String getColumnNameOnly(){
205        String result = "";
206        switch (expr.getExpressionType()){
207            case sqlserver_proprietary_column_alias_t:
208                if (expr.getRightOperand().getExpressionType() == EExpressionType.simple_object_name_t){
209                    result = expr.getRightOperand().getObjectOperand().getColumnNameOnly();
210                }
211                break;
212            case simple_object_name_t:
213                result = expr.getObjectOperand().getColumnNameOnly();
214                break;
215            case typecast_t:
216                result = expr.getLeftOperand().toString();
217                break;
218            default:
219                break;
220        }
221//        if (expr.getExpressionType() == EExpressionType.simple_object_name_t) return expr.getObjectOperand().getColumnNameOnly();
222//        else return "";
223
224        return result;
225    }
226
227    private TExpression expr = null;
228
229    public void setExpr(TExpression expr) {
230        this.expr = expr;
231    }
232
233    private  boolean placeHolder = false;
234
235    public void setPlaceHolder(boolean placeHolder) {
236        this.placeHolder = placeHolder;
237    }
238
239    /**
240     * this is true when  there is no column names specified for fields in teradata insert statement
241     * <p>
242     * INSERT INTO employee (10005, 'Orebo B',300,,,, 'Nov 17 1957','M',,,18,);
243     * @return
244     */
245    public boolean isPlaceHolder(){
246        return this.placeHolder;
247    }
248    /**
249     * column expression.
250     * If there is only column name in a select_list item, then, this expr is type of {@link TExpression#simpleObjectname},
251     * <p>Otherwise, it maybe a complex expr, you should check {@link TExpression#getExpressionType}.
252     * <p>for column values in update_set_clause, this expr is type of {@link TExpression#ASSIGNMENT}
253     * @return
254     */
255    public TExpression getExpr() {
256        return expr;
257    }
258
259
260    public void init(Object arg1)
261    {
262        if (arg1 instanceof TExpression){
263            expr = (TExpression)arg1;
264        }
265    }
266
267    public void init(Object arg1, Object arg2)
268    {
269        init(arg1);
270        if (arg2 instanceof TAliasClause) {
271            this.setAliasClause((TAliasClause) arg2);
272            if (((TAliasClause) arg2).getAliasName() != null) {
273                ((TAliasClause) arg2).getAliasName().setObjectType(TObjectName.ttobjColumnAlias);
274            }
275        }
276    }
277
278
279    public void doParse(TCustomSqlStatement psql, ESqlClause plocation){
280        if (this.isPlaceHolder()) return ;
281
282        if(psql.dbvendor == EDbVendor.dbvteradata){
283            boolean foundNamedDataAttribute = false;
284            if (expr.getDataConversions().size() > 0 ){
285                for(int i=0;i<expr.getDataConversions().size();i++){
286                    TDataConversion dataConversion = expr.getDataConversions().get(i);
287                    for(int j=0;j<dataConversion.getDataConversionItems().size();j++){
288                        TDataConversionItem dataConversionItem = dataConversion.getDataConversionItems().get(j);
289                        if (dataConversionItem.getDataConversionType() == TDataConversionItem.EDataConversionype.dataAttribute){
290                            TDatatypeAttribute datatypeAttribute = dataConversionItem.getDatatypeAttribute();
291                            if ((this.getAliasClause() == null) && (datatypeAttribute.getAttributeType() == EDataTypeAttribute.named_t)){
292                                TAliasClause aliasClause = new TAliasClause();
293
294                                aliasClause.init(datatypeAttribute.getNamedName());
295                                aliasClause.setStartToken(datatypeAttribute.getNamedName());
296                                aliasClause.setEndToken(datatypeAttribute.getNamedName());
297
298                                aliasClause.setTeradataNamedAlais(true);
299                                aliasClause.setAsToken(datatypeAttribute.getStartToken());
300                                this.setAliasClause(aliasClause);
301
302                                foundNamedDataAttribute = true;
303                                break;
304                            }
305                        }
306                    }
307                    if (foundNamedDataAttribute) break;
308                }
309            }
310
311//            if (expr.getDataTypeConversionList() != null){
312//                boolean namedAlias = false;
313//                TDatatypeAttribute datatypeAttribute = null;
314//                for(int i=0;i<expr.getDataTypeConversionList().size();i++){
315//                    TExplicitDataTypeConversion e = expr.getDataTypeConversionList().getElement(i);
316//                    if (e.getDataTypeAttributeList1() == null) continue;
317//                    for(int j=0;j<e.getDataTypeAttributeList1().size();j++){
318//                        datatypeAttribute = e.getDataTypeAttributeList1().getElement(j);
319//                        if (datatypeAttribute.getAttributeType() == EDataTypeAttribute.named_t){
320//                            break;
321//                        }else {
322//                            datatypeAttribute = null;
323//                        }
324//                    }
325//                    if (datatypeAttribute != null) break;
326//                }
327//
328//                if (datatypeAttribute != null){
329//                    if (datatypeAttribute.getAttributeType() == EDataTypeAttribute.named_t){
330//                        TAliasClause aliasClause = new TAliasClause();
331//                        if (datatypeAttribute.getValue_literal() != null){
332//                            aliasClause.init(datatypeAttribute.getValue_literal());
333//                            aliasClause.setStartToken(datatypeAttribute.getValue_literal().getStartToken());
334//                            aliasClause.setEndToken(datatypeAttribute.getValue_literal().getEndToken());
335//                        }else if (datatypeAttribute.getValue_identifier() != null){
336//                            aliasClause.init(datatypeAttribute.getValue_identifier());
337//                            aliasClause.setStartToken(datatypeAttribute.getValue_identifier());
338//                            aliasClause.setEndToken(datatypeAttribute.getValue_identifier());
339//                        }
340//                        aliasClause.setTeradataNamedAlais(true);
341//                        aliasClause.setAsToken(datatypeAttribute.getStartToken());
342//                        this.setAliasClause(aliasClause);
343//                        namedAlias = true;
344//                    }
345//                }
346//
347//                if(!namedAlias){
348//                    //expr.setEndToken(expr.getDataTypeConversion().getEndToken());
349//                }
350//
351//                //this.setEndToken(expr.getEndToken());
352//            }
353
354            // select col1 (DATE) from tab1
355//            if (expr.getExpressionType() == EExpressionType.function_t){
356//                TFunctionCall f = expr.getFunctionCall();
357//                if ((f.getArgs() != null)&&(f.getArgs().size() == 1)){
358//                    if (f.getArgs().getExpression(0).toString().equalsIgnoreCase("date")){
359//                        expr.setExpressionType(EExpressionType.simple_object_name_t);
360//                        f.getFunctionName().setDbObjectType(EDbObjectType.column);
361//                        f.getFunctionName().setPartToken(f.getFunctionName().getObjectToken());
362//                        f.getFunctionName().setObjectToken(null);
363//                        expr.setObjectOperand(f.getFunctionName());
364//                        expr.setStartToken(f.getFunctionName().getStartToken());
365//                        expr.setEndToken(f.getFunctionName().getEndToken());
366//                        //
367//                        TTypeName date1 = new TTypeName();
368//                        date1.init(EDataType.date_t.date_t);
369//                        date1.setStartToken(f.getArgs().getExpression(0).getStartToken());
370//                        date1.setEndToken(f.getArgs().getExpression(0).getEndToken());
371//                        TExplicitDataTypeConversion dtc = new TExplicitDataTypeConversion();
372//                        dtc.init(date1);
373//                        dtc.setStartToken(date1.getStartToken());
374//                        dtc.setEndToken(date1.getEndToken());
375//
376//                        TPTNodeList<TExplicitDataTypeConversion> dtcList = new TPTNodeList<TExplicitDataTypeConversion>();
377//                        dtcList.addNode(dtc);
378//                        expr.setDataTypeConversionList(dtcList);
379//                    }
380//                }
381//            }
382
383        }
384        // change plocation when resultcolumn is in update or insert
385        if (plocation == ESqlClause.set){
386            if (expr.getExpressionType() == EExpressionType.function_t){
387                /*
388                 *   UPDATE Cities
389                 *   SET Location.SetXY(23.5, 23.5)
390                 */
391                //expr.getFunctionCall().getFunctionName().parseColumnMethodName();
392                try{
393                    expr.getFunctionCall().getFunctionName().setObjectType(TObjectName.ttobjColumnMethod);
394                   // expr.getFunctionCall().getFunctionName().setDbObjectType(EDbObjectType.method);
395                }catch (Exception e){
396                    TSourceToken st = expr.getStartToken();
397                    psql.parseerrormessagehandle(new TSyntaxError(st.getAstext(), st.lineNo, st.columnNo
398                            ,"error function call in set clause", EErrorType.spfatalerror
399                            , TBaseType.MSG_ERROR_FUNCTION_IN_SET_CLAUSE
400                            ,psql,st.posinlist));
401                }
402                if( (expr.getFunctionCall().getFunctionName().getPartToken()!=null)&&(psql.getTargetTable()!=null)){
403                    TObjectName columName = TObjectName.createObjectName (psql.dbvendor, EDbObjectType.column,expr.getFunctionCall().getFunctionName().getPartToken());
404                    psql.getTargetTable().getLinkedColumns().addObjectName (columName);
405                    columName.setSourceTable(psql.getTargetTable());
406                    columName.setValidate_column_status(TBaseType.COLUMN_LINKED_TO_TABLE_IN_OLD_ALGORITHM);
407                }else{
408                     psql.linkColumnToTable(expr.getFunctionCall().getFunctionName(),plocation);
409                }
410
411                if (expr.getFunctionCall().getArgs() != null){
412                    for(int i=0;i<expr.getFunctionCall().getArgs().size();i++){
413                        expr.getFunctionCall().getArgs().doParse(psql,plocation);
414                    }
415                }
416              //  psql.linkColumnReferenceToTable( TGSqlParser.parseObjectName(psql.dbvendor, expr.getFunctionCall().getFunctionName().getPartToken().astext) ,plocation);
417            }else {
418                 if (expr.getLeftOperand().getExpressionType() == EExpressionType.simple_object_name_t){
419                     expr.getLeftOperand().getObjectOperand().setLocation(plocation);
420                     TTable lcTable = psql.tables.getTable(0);
421                     if (lcTable.isLinkTable()) lcTable = lcTable.getLinkTable();
422                     lcTable.getLinkedColumns().addObjectName(expr.getLeftOperand().getObjectOperand());
423                     expr.getLeftOperand().getObjectOperand().setSourceTable(lcTable);
424                     expr.getLeftOperand().getObjectOperand().setValidate_column_status(TBaseType.COLUMN_LINKED_TO_TABLE_IN_OLD_ALGORITHM);
425                     lcTable.getObjectNameReferences().addObjectName(expr.getLeftOperand().getObjectOperand());
426                     expr.getRightOperand().doParse(psql,ESqlClause.setValue);
427                 }else {
428                     expr.doParse(psql,plocation);
429                 }
430            }
431            //psql.linkColumnToTable()
432        }else if (
433                (expr.getExpressionType() == EExpressionType.simple_comparison_t)
434                &&((psql.dbvendor == EDbVendor.dbvmssql)||(psql.dbvendor == EDbVendor.dbvsybase))
435                &&(
436                        (plocation == ESqlClause.resultColumn)
437                        ||(plocation == ESqlClause.insertColumn)
438                                ||(plocation == ESqlClause.mergeInsert)
439                                ||(plocation == ESqlClause.selectList)
440                )
441
442            )
443        {
444            //@x in  select @x = id is not a alias
445            if (
446                (expr.getComparisonOperator().toString().equalsIgnoreCase("="))
447                 &&(!(expr.getLeftOperand().toString().startsWith("@")))
448                  ){
449                //expr.setExpressionType(TExpression.sqlserver_proprietary_column_alias);
450                expr.setExpressionType(EExpressionType.sqlserver_proprietary_column_alias_t);
451                TAliasClause aliasClause  = new TAliasClause();
452                if (expr.getLeftOperand().getExpressionType() == EExpressionType.simple_object_name_t){
453                    aliasClause.init(expr.getLeftOperand().getObjectOperand());
454                    aliasClause.setStartToken(expr.getLeftOperand().getStartToken());
455                    aliasClause.setEndToken(expr.getLeftOperand().getEndToken());
456                }else if (expr.getLeftOperand().getExpressionType() == EExpressionType.simple_constant_t){
457                    aliasClause.init(expr.getLeftOperand().getConstantOperand());
458                    aliasClause.setStartToken(expr.getLeftOperand().getStartToken());
459                    aliasClause.setEndToken(expr.getLeftOperand().getEndToken());
460                }
461                setAliasClause(aliasClause);
462            }
463            expr.doParse(psql,plocation);
464        }else if((psql.dbvendor == EDbVendor.dbvpostgresql)
465                &&(expr.getExpressionType() == EExpressionType.simple_constant_t)
466                &&(plocation == ESqlClause.selectList)
467                &&(expr.getObjectOperand() != null)&&(expr.getExprAlias() != null)
468        ){// func_name Sconst /* generic type 'literal' syntax */
469            expr.setExpressionType(EExpressionType.simple_object_name_t);
470            setAliasClause(expr.getExprAlias());
471            getAliasClause().setStartToken(expr.getExprAlias().getStartToken());
472            getAliasClause().setEndToken(expr.getExprAlias().getEndToken());
473            expr.doParse(psql,plocation);
474        }else{
475            expr.doParse(psql,plocation);
476        }
477
478        if (qualifyClause != null){
479            qualifyClause.doParse(psql,plocation);
480        }
481
482//        if ((expr.getFieldList() != null) && (psql.dbvendor == EDbVendor.dbvbigquery)){
483//            // SELECT COMMON.* EXCEPT (column1, column2) FROM dataset1.table1 COMMON;
484//            this.exceptColumnList = expr.getFieldList();
485//            TTable table = psql.tables.getTable(0);
486//            if (table != null){
487//                for(int i=0;i<this.exceptColumnList.size();i++){
488//                    table.getLinkedColumns().addObjectName(this.exceptColumnList.getObjectName(i));
489//                    this.exceptColumnList.getObjectName(i).setSourceTable(table);
490//                }
491//            }
492//        }
493
494        if (expr.getExceptReplaceClause() != null){
495            // SELECT COMMON.* EXCEPT (column1, column2) FROM dataset1.table1 COMMON;
496            this.exceptColumnList = expr.getExceptReplaceClause().getColumnList();
497
498            // select * replace(expr as identifier)
499            this.replaceExprAsIdentifiers = expr.getExceptReplaceClause().getExprAsIdentifiers();
500
501            TTable table = psql.tables.getTable(0);
502            if (table != null){
503                if (this.exceptColumnList != null){
504                    for(int i=0;i<this.exceptColumnList.size();i++){
505                        table.getLinkedColumns().addObjectName(this.exceptColumnList.getObjectName(i));
506                        this.exceptColumnList.getObjectName(i).setSourceTable(table);
507                    }
508                }
509
510                if (replaceExprAsIdentifiers != null){
511                    for(int i=0;i<replaceExprAsIdentifiers.size();i++){
512                        TReplaceExprAsIdentifier replaceExprAsIdentifier = replaceExprAsIdentifiers.get(i);
513                        table.getLinkedColumns().addObjectName(replaceExprAsIdentifier.getIdentifier());
514                        replaceExprAsIdentifier.getIdentifier().setSourceTable(table);
515                    }
516                }
517            }
518
519        }
520    }
521
522
523    /**
524     *
525     * @return this is used to provide back compatibility of .NET version only. 
526     */
527    public TObjectName getFieldAttr() {
528        TObjectName ret = null;
529        if (expr.getExpressionType() == EExpressionType.simple_object_name_t){
530            ret = expr.getObjectOperand();
531        }
532        return ret;
533    }
534
535    public String getPrefixTable(){
536        if (getFieldAttr() == null) return "";
537        return getFieldAttr().getTableString();
538    }
539
540    public String getPrefixSchema(){
541        if (getFieldAttr() == null) return "";
542        return getFieldAttr().getSchemaString();
543    }
544
545    public String getPrefixDatabase(){
546        if (getFieldAttr() == null) return "";
547        return getFieldAttr().getDatabaseString();
548    }
549
550    public String getPrefixServer(){
551        if (getFieldAttr() == null) return "";
552        return getFieldAttr().getServerString();
553    }
554
555    public void accept(TParseTreeVisitor v){
556        v.preVisit(this);
557        v.postVisit(this);
558    }
559
560    public void acceptChildren(TParseTreeVisitor v){
561        v.preVisit(this);
562
563        if (!placeHolder)  getExpr().acceptChildren(v);
564        if (getAliasClause() != null){
565            getAliasClause().acceptChildren(v);
566        }
567
568        v.postVisit(this);
569    }
570
571    public void setTargetColumns(TObjectNameList targetColumns) {
572        this.targetColumns = targetColumns;
573    }
574
575    private TUpdateFor updateFor; //couchbase
576
577    public void setUpdateFor(TUpdateFor updateFor) {
578        this.updateFor = updateFor;
579    }
580
581    public TUpdateFor getUpdateFor() {
582
583        return updateFor;
584    }
585
586    public int compareTo(Object o){
587        TResultColumn rc = (TResultColumn)o;
588        return  IdentifierService.normalizeStatic(this.dbvendor,dotColumn, this.getDisplayName()).compareTo(
589                IdentifierService.normalizeStatic(this.dbvendor,dotColumn,rc.getDisplayName())) ;
590
591    }
592
593//    private int pos = -1;
594//
595//    public void setPos(int pos) {
596//        this.pos = pos;
597//    }
598//
599//    public int getPos() {
600//        return pos;
601//    }
602}