Revision 46505 trunk/org.gvsig.desktop/org.gvsig.desktop.compat.cdc/org.gvsig.fmap.dal/org.gvsig.fmap.dal.spi/src/main/java/org/gvsig/fmap/dal/feature/spi/SQLBuilderBase.java

View differences:

SQLBuilderBase.java
19 19
import static org.gvsig.expressionevaluator.ExpressionBuilder.PARAMETER_TYPE_CONSTANT;
20 20
import static org.gvsig.expressionevaluator.ExpressionBuilder.PARAMETER_TYPE_VARIABLE;
21 21
import org.gvsig.expressionevaluator.ExpressionBuilder.Parameter;
22
import static org.gvsig.expressionevaluator.ExpressionBuilder.VALUE_NULL;
22 23
import org.gvsig.expressionevaluator.ExpressionBuilder.Value;
23 24
import org.gvsig.expressionevaluator.ExpressionBuilder.Variable;
24 25
import org.gvsig.expressionevaluator.ExpressionBuilder.Visitable;
......
54 55
import org.gvsig.fmap.geom.primitive.Envelope;
55 56
import org.gvsig.tools.dataTypes.DataType;
56 57
import org.gvsig.tools.dynobject.Tags;
58
import org.gvsig.tools.util.PropertiesSupport;
57 59
import org.slf4j.Logger;
58 60
import org.slf4j.LoggerFactory;
59 61

  
......
480 482
            if (!support_schemas()) {
481 483
                return false;
482 484
            }
483
            return !StringUtils.isEmpty(this.schemaName);
485
            return !StringUtils.isBlank(this.schemaName);
484 486
        }
485 487

  
486 488
        @Override
489
        public boolean has_name() {
490
            return !StringUtils.isBlank(this.tableName);
491
        }
492

  
493
        @Override
487 494
        public boolean has_database() {
488
            return !StringUtils.isEmpty(this.databaseName);
495
            return !StringUtils.isBlank(this.databaseName);
489 496
        }
490 497

  
491 498
        @Override
......
713 720

  
714 721
        @Override
715 722
        public void accept(Visitor visitor, VisitorFilter filter) {
723
            boolean visitChildren = true;
716 724
            if (filter==null || filter.accept(this)) {
717 725
                visitor.visit(this);
726
            } else {
727
                visitChildren = !filter.skipChildren();
718 728
            }
719
            if (this.tableName != null) {
720
                this.tableName.accept(visitor, filter);
729
            if(visitChildren){
730
                if (this.tableName != null) {
731
                    this.tableName.accept(visitor, filter);
732
                }
721 733
            }
722 734
        }
723 735

  
......
767 779
            extends AbstractStatementPart
768 780
            implements SelectColumnBuilder {
769 781

  
770
        protected Variable name = null;
782
        protected Column name = null;
771 783
        protected String alias = null;
772 784
        protected Value value = null;
773 785
        protected boolean asGeometry = false;
......
782 794
        public SelectColumnBuilderBase clone() throws CloneNotSupportedException {
783 795
            SelectColumnBuilderBase other = (SelectColumnBuilderBase) super.clone();
784 796
            other.value = (Value) org.gvsig.tools.lang.Cloneable.cloneQuietly(value);
785
            other.name = (Variable) org.gvsig.tools.lang.Cloneable.cloneQuietly(name);
797
            other.name = (Column) org.gvsig.tools.lang.Cloneable.cloneQuietly(name);
786 798
            other.table = (TableNameBuilder) org.gvsig.tools.lang.Cloneable.cloneQuietly(table);
787 799
            return other;
788 800
        }
789 801

  
790 802
        @Override
791 803
        public void accept(Visitor visitor, VisitorFilter filter) {
804
            boolean visitChildren = true;
792 805
            if (filter==null || filter.accept(this)) {
793 806
                visitor.visit(this);
807
            } else {
808
                visitChildren = !filter.skipChildren();
794 809
            }
795
            if (this.name != null) {
796
                this.name.accept(visitor, filter);
810
            if(visitChildren){
811
                if (this.value != null) {
812
                    this.value.accept(visitor, filter);
813
                } else if (this.name != null) {
814
                    this.name.accept(visitor, filter);
815
                }
797 816
            }
798
            if (this.value != null) {
799
                this.value.accept(visitor, filter);
800
            }
801 817
        }
802 818

  
803 819
        @Override
804 820
        public void replace(Value target, Value replacement) {
805 821
            if (this.name!=null ) {
806 822
                if( this.name == target) {
807
                    this.name = (Variable) replacement;
823
                    if(replacement == null){
824
                        this.name = null;
825
                    } else if(replacement instanceof Column){
826
                        this.name = (Column) replacement;
827
                    } else if(replacement instanceof Variable){
828
                        this.name = new ColumnBase(this.table, ((Variable) replacement).name());
829
                    } else {
830
                        this.value = replacement;
831
                    }
808 832
                }
809 833
            }
810 834
            if( this.value!=null ) {
......
828 852
                // Remove quotes
829 853
                name = name.substring(1, name.length() - 1);
830 854
            }
831
            this.name = expression().variable(name);
832 855
            this.table = table;
856
            this.name = new ColumnBase(this.table, name);
833 857
            this.value = null;
834 858
            this.asGeometry = false;
835 859
            return this;
......
852 876
        @Override
853 877
        public SelectColumnBuilder value(Value value) {
854 878
            this.value = value;
855
            this.name = null;
856 879
            return this;
857 880
        }
858 881

  
......
876 899
        }
877 900

  
878 901
        @Override
879
        public String getValue() {
880
            return this.alias;
902
        public Value getValue() {
903
            return this.value;
881 904
        }
882 905

  
883 906
        @Override
......
892 915
            }
893 916
            StringBuilder builder = new StringBuilder();
894 917
            if (this.asGeometry) {
895
                builder.append(expression().ST_AsBinary(this.name).toString(formatter));
918
                if(this.value == VALUE_NULL){
919
                    builder.append(this.value.toString(formatter));
920
                } else {
921
                    builder.append(expression().ST_AsBinary(this.name).toString(formatter));
922
                }
896 923
            } else {
897
                if (this.name != null) {
898
                    if( this.table==null ) {
899
                        builder.append(this.name.toString(formatter));
900
                    } else {
901
                        builder.append(this.table.toString(formatter));
902
                        builder.append(".");
903
                        builder.append(this.name.toString(formatter));
904
                    }
924
                if (this.value == null) {
925
                    builder.append(this.name.toString(formatter));
905 926
                } else {
906 927
                    builder.append(this.value.toString(formatter));
907 928
                }
......
959 980
        
960 981
        @Override
961 982
        public void accept(Visitor visitor, VisitorFilter filter) {
983
            boolean visitChildren = true;
962 984
            if (filter==null || filter.accept(this)) {
963 985
                visitor.visit(this);
986
            } else {
987
                visitChildren = !filter.skipChildren();
964 988
            }
965
            if (this.value!=null) {
966
                this.value.accept(visitor, filter);
989
            if(visitChildren){
990
                if (this.value!=null) {
991
                    this.value.accept(visitor, filter);
992
                }
967 993
            }
968 994
        }
969 995

  
......
1062 1088
            }
1063 1089
            return order_s;
1064 1090
        }
1091

  
1092
        @Override
1093
        public void replace(Value target, Value replacement) {
1094
            super.replace(target, replacement);
1095
            if(target == this.value){
1096
                this.value = replacement;
1097
                return;
1098
            }
1099
            if(this.value == null){
1100
                return;
1101
            }
1102
            this.value.replace(target, replacement);
1103
        }
1104
        
1105
        
1065 1106
    }
1066 1107

  
1067 1108
    public class SelectBuilderBase
......
1120 1161

  
1121 1162
        @Override
1122 1163
        public void accept(Visitor visitor, VisitorFilter filter) {
1164
            boolean visitChildren = true;
1123 1165
            if (filter==null || filter.accept(this)) {
1124 1166
                visitor.visit(this);
1167
            } else {
1168
                visitChildren = !filter.skipChildren();
1125 1169
            }
1126
            for (SelectColumnBuilder column : columns) {
1127
                column.accept(visitor, filter);
1128
            }
1129
            if (this.has_from()) {
1130
                this.from.accept(visitor, filter);
1131
            }
1132
            if (this.has_where()) {
1133
                this.where.accept(visitor, filter);
1134
            }
1135
            if (this.has_order_by()) {
1136
                for (OrderByBuilder order : order_by) {
1137
                    order.accept(visitor, filter);
1170
            if(visitChildren){
1171
                for (SelectColumnBuilder column : columns) {
1172
                    column.accept(visitor, filter);
1138 1173
                }
1139
            }
1140
            if (this.has_group_by()) {
1141
                for (Value group : groupColumn) {
1142
                    group.accept(visitor, filter);
1174
                if (this.has_from()) {
1175
                    this.from.accept(visitor, filter);
1143 1176
                }
1177
                if (this.has_where()) {
1178
                    this.where.accept(visitor, filter);
1179
                }
1180
                if (this.has_order_by()) {
1181
                    for (OrderByBuilder order : order_by) {
1182
                        order.accept(visitor, filter);
1183
                    }
1184
                }
1185
                if (this.has_group_by()) {
1186
                    for (Value group : groupColumn) {
1187
                        group.accept(visitor, filter);
1188
                    }
1189
                }
1144 1190
            }
1145 1191
        }
1146 1192

  
......
1208 1254
        }
1209 1255

  
1210 1256
        @Override
1257
        public SelectColumnBuilder column(String name) {
1258
            for (SelectColumnBuilder column : columns) {
1259
                if (StringUtils.equals(name, column.getName())) {
1260
                    return column;
1261
                }
1262
            }
1263
            SelectColumnBuilder builder = createSelectColumnBuilder();
1264
            builder.name(name);
1265
            this.columns.add(builder);
1266
            return builder;
1267
        }
1268

  
1269
        @Override
1211 1270
        public SelectBuilder remove_all_columns() {
1212 1271
            this.columns = new ArrayList<>();
1213 1272
            return this;
......
1322 1381
            }
1323 1382
            return null;
1324 1383
        }
1384
        
1385
        @Override
1386
        public boolean isGroupBy(String column) {
1387
            if(this.groupColumn == null){
1388
                return false;
1389
            }
1390
            for (Value group : this.groupColumn) {
1391
                if(group instanceof Variable){
1392
                    if(StringUtils.equalsIgnoreCase(((Variable)group).name(), column)){
1393
                        return true;
1394
                    }
1395
                }
1396
            }
1397
            return false;
1398
        }
1325 1399

  
1326 1400
        @Override
1327 1401
        public boolean has_order_by() {
......
1460 1534

  
1461 1535
        @Override
1462 1536
        public void accept(Visitor visitor, VisitorFilter filter) {
1537
            boolean visitChildren = true;
1463 1538
            if (filter==null || filter.accept(this)) {
1464 1539
                visitor.visit(this);
1540
            } else {
1541
                visitChildren = !filter.skipChildren();
1465 1542
            }
1466
            this.table.accept(visitor, filter);
1543
            if(visitChildren){
1544
                this.table.accept(visitor, filter);
1545
            }
1467 1546
        }
1468 1547

  
1469 1548
        @Override
......
1679 1758

  
1680 1759
        @Override
1681 1760
        public void accept(Visitor visitor, VisitorFilter filter) {
1761
            boolean visitChildren = true;
1682 1762
            if (filter==null || filter.accept(this)) {
1683 1763
                visitor.visit(this);
1764
            } else {
1765
                visitChildren = !filter.skipChildren();
1684 1766
            }
1685
            if (this.table != null) {
1686
                this.table.accept(visitor, filter);
1767
            if(visitChildren){
1768
                if (this.table != null) {
1769
                    this.table.accept(visitor, filter);
1770
                }
1687 1771
            }
1688 1772
        }
1689 1773

  
......
1772 1856

  
1773 1857
        @Override
1774 1858
        public void accept(Visitor visitor, VisitorFilter filter) {
1859
            boolean visitChildren = true;
1775 1860
            if (filter==null || filter.accept(this)) {
1776 1861
                visitor.visit(this);
1862
            } else {
1863
                visitChildren = !filter.skipChildren();
1777 1864
            }
1778
            if (this.table != null) {
1779
                this.table.accept(visitor, filter);
1865
            if(visitChildren){
1866
                if (this.table != null) {
1867
                    this.table.accept(visitor, filter);
1868
                }
1869
                for (UpdateColumnBuilder column : columns) {
1870
                    column.accept(visitor, filter);
1871
                }
1872
                if (this.has_where()) {
1873
                    this.where.accept(visitor, filter);
1874
                }
1780 1875
            }
1781
            for (UpdateColumnBuilder column : columns) {
1782
                column.accept(visitor, filter);
1783
            }
1784
            if (this.has_where()) {
1785
                this.where.accept(visitor, filter);
1786
            }
1787 1876
        }
1788 1877

  
1789 1878
        @Override
......
1875 1964

  
1876 1965
        @Override
1877 1966
        public void accept(Visitor visitor, VisitorFilter filter) {
1967
            boolean visitChildren = true;
1878 1968
            if (filter==null || filter.accept(this)) {
1879 1969
                visitor.visit(this);
1970
            } else {
1971
                visitChildren = !filter.skipChildren();
1880 1972
            }
1881
            if (this.table != null) {
1882
                this.table.accept(visitor, filter);
1973
            if(visitChildren){
1974
                if (this.table != null) {
1975
                    this.table.accept(visitor, filter);
1976
                }
1977
                if (this.has_where()) {
1978
                    this.where.accept(visitor, filter);
1979
                }
1883 1980
            }
1884
            if (this.has_where()) {
1885
                this.where.accept(visitor, filter);
1886
            }
1887 1981
        }
1888 1982

  
1889 1983
        @Override
......
1999 2093

  
2000 2094
        @Override
2001 2095
        public void accept(Visitor visitor, VisitorFilter filter) {
2096
            boolean visitChildren = true;
2002 2097
            if (filter==null || filter.accept(this)) {
2003 2098
                visitor.visit(this);
2099
            } else {
2100
                visitChildren = !filter.skipChildren();
2004 2101
            }
2005
            if (this.table != null) {
2006
                this.table.accept(visitor, filter);
2102
            if(visitChildren){
2103
                if (this.table != null) {
2104
                    this.table.accept(visitor, filter);
2105
                }
2007 2106
            }
2008 2107
        }
2009 2108

  
......
2176 2275

  
2177 2276
        @Override
2178 2277
        public void accept(Visitor visitor, VisitorFilter filter) {
2278
            boolean visitChildren = true;
2179 2279
            if (filter==null || filter.accept(this)) {
2180 2280
                visitor.visit(this);
2281
            } else {
2282
                visitChildren = !filter.skipChildren();
2181 2283
            }
2182
            if (this.table != null) {
2183
                this.table.accept(visitor, filter);
2284
            if(visitChildren){
2285
                if (this.table != null) {
2286
                    this.table.accept(visitor, filter);
2287
                }
2184 2288
            }
2185 2289
        }
2186 2290

  
......
2429 2533

  
2430 2534
        @Override
2431 2535
        public void accept(Visitor visitor, VisitorFilter filter) {
2536
            boolean visitChildren = true;
2432 2537
            if (filter==null || filter.accept(this)) {
2433 2538
                visitor.visit(this);
2539
            } else {
2540
                visitChildren = !filter.skipChildren();
2434 2541
            }
2435
            if (this.table != null) {
2436
                this.table.accept(visitor, filter);
2542
            if(visitChildren){
2543
                if (this.table != null) {
2544
                    this.table.accept(visitor, filter);
2545
                }
2437 2546
            }
2438 2547
        }
2439 2548

  
......
2622 2731

  
2623 2732
        @Override
2624 2733
        public void accept(Visitor visitor, VisitorFilter filter) {
2734
            boolean visitChildren = true;
2625 2735
            if (filter==null || filter.accept(this)) {
2626 2736
                visitor.visit(this);
2737
            } else {
2738
                visitChildren = !filter.skipChildren();
2627 2739
            }
2628
            if (this.name != null) {
2629
                this.name.accept(visitor, filter);
2740
            if(visitChildren){
2741
                if (this.name != null) {
2742
                    this.name.accept(visitor, filter);
2743
                }
2744
                if (this.value != null) {
2745
                    this.value.accept(visitor, filter);
2746
                }
2630 2747
            }
2631
            if (this.value != null) {
2632
                this.value.accept(visitor, filter);
2633
            }
2634 2748
        }
2635 2749

  
2636 2750
        @Override
......
2682 2796

  
2683 2797
        @Override
2684 2798
        public void accept(Visitor visitor, VisitorFilter filter) {
2799
            boolean visitChildren = true;
2685 2800
            if (filter==null || filter.accept(this)) {
2686 2801
                visitor.visit(this);
2802
            } else {
2803
                visitChildren = !filter.skipChildren();
2687 2804
            }
2688
            if (this.table != null) {
2689
                this.table.accept(visitor, filter);
2805
            if(visitChildren){
2806
                if (this.table != null) {
2807
                    this.table.accept(visitor, filter);
2808
                }
2809
                for (InsertColumnBuilder column : columns) {
2810
                    column.accept(visitor, filter);
2811
                }
2690 2812
            }
2691
            for (InsertColumnBuilder column : columns) {
2692
                column.accept(visitor, filter);
2693
            }
2694 2813
        }
2695 2814

  
2696 2815
        @Override
......
2764 2883

  
2765 2884
        @Override
2766 2885
        public void accept(Visitor visitor, VisitorFilter filter) {
2886
            boolean visitChildren = true;
2767 2887
            if (filter==null || filter.accept(this)) {
2768 2888
                visitor.visit(this);
2889
            } else {
2890
                visitChildren = !filter.skipChildren();
2769 2891
            }
2770
            if (this.table != null) {
2771
                this.table.accept(visitor, filter);
2892
            if(visitChildren){
2893
                if (this.table != null) {
2894
                    this.table.accept(visitor, filter);
2895
                }
2772 2896
            }
2773 2897
        }
2774 2898

  
......
2876 3000

  
2877 3001
    public SQLBuilderBase() {
2878 3002
        this.expressionBuilder = GeometryExpressionEvaluatorLocator.getManager().createExpressionBuilder();
3003
        this.expressionBuilder.setProperty("SQLBUILDER", this);
2879 3004

  
2880 3005
        this.hasSpatialFunctions = false;
2881 3006
        this.supportSchemas = true;
......
2889 3014
    @Override
2890 3015
    public void setProperties(Class filter, final Object... values) {
2891 3016
        this.expressionBuilder.setProperties(filter, values);
2892
        this.accept((Visitable v) -> {
3017
        setProperties(this, filter, values);
3018
    }
3019
    
3020
    @Override
3021
    public void setProperties(Visitable visitable, Class filter, final Object... values) {
3022
        if(visitable == null){
3023
            return;
3024
        }
3025
        if(visitable instanceof PropertiesSupport){
2893 3026
            for (int i = 0; i < values.length; i+=2) {
2894
                ((Value)v).setProperty((String) values[i], values[i+1]);
3027
                ((PropertiesSupport)visitable).setProperty((String) values[i], values[i+1]);
2895 3028
            }
3029
        }
3030
        visitable.accept((Visitable v) -> {
3031
            if(v instanceof PropertiesSupport){
3032
                for (int i = 0; i < values.length; i+=2) {
3033
                    ((PropertiesSupport)v).setProperty((String) values[i], values[i+1]);
3034
                }
3035
            }
2896 3036
        }, new ClassVisitorFilter(filter) );
2897 3037
    }
2898 3038

  
......
3165 3305
        return new FromBuilderBase();
3166 3306
    }
3167 3307

  
3168
    protected SelectBuilder createSelectBuilder() {
3308
    public SelectBuilder createSelectBuilder() {
3169 3309
        return new SelectBuilderBase();
3170 3310
    }
3171 3311

  
......
3326 3466
        return new JoinBase(type, table, expression);
3327 3467
    }
3328 3468

  
3469
    @Override
3329 3470
    public void accept(Visitor visitor, VisitorFilter filter) {
3330 3471
        if (this.select != null) {
3331 3472
            this.select.accept(visitor, filter);
......
3353 3494
        }
3354 3495
    }
3355 3496

  
3356
	@Override
3497
    @Override
3357 3498
    public Formatter formatter() {
3358 3499
        return expression().formatter();
3359 3500
    }

Also available in: Unified diff