Revision 44727 trunk/org.gvsig.desktop/org.gvsig.desktop.compat.cdc/org.gvsig.fmap.dal/org.gvsig.fmap.dal.db/org.gvsig.fmap.dal.db.jdbc/src/main/java/org/gvsig/fmap/dal/store/jdbc2/spi/operations/CountOperation.java

View differences:

CountOperation.java
4 4
import java.sql.ResultSet;
5 5
import java.sql.SQLException;
6 6
import java.sql.Statement;
7
import java.util.List;
7 8
import org.apache.commons.lang3.StringUtils;
8 9
import org.gvsig.expressionevaluator.ExpressionBuilder;
10
import org.gvsig.fmap.dal.SQLBuilder.SelectBuilder;
9 11
import org.gvsig.fmap.dal.exception.DataException;
12
import org.gvsig.fmap.dal.feature.FeatureQuery;
13
import org.gvsig.fmap.dal.feature.FeatureQueryOrder;
10 14
import org.gvsig.fmap.dal.feature.FeatureType;
11 15
import org.gvsig.fmap.dal.store.jdbc2.JDBCHelper;
12 16
import org.gvsig.fmap.dal.store.jdbc2.spi.JDBCSQLBuilderBase;
......
14 18
import org.gvsig.fmap.dal.store.jdbc2.JDBCUtils;
15 19
import org.gvsig.fmap.dal.store.jdbc2.OperationsFactory.TableReference;
16 20
import static org.gvsig.fmap.dal.store.jdbc2.spi.JDBCSQLBuilderBase.PROP_TABLE;
21
import org.gvsig.tools.evaluator.Evaluator;
17 22

  
18 23
public class CountOperation extends AbstractConnectionOperation {
19 24

  
20 25
    private final TableReference table;
21 26
    private final String baseFilter;
22
    private final String filter;
27
    private final FeatureQuery query;
23 28
    private final FeatureType featureType;
24 29

  
25 30
    public CountOperation(
......
33 38
            FeatureType featureType,
34 39
            TableReference table,
35 40
            String baseFilter,
36
            String filter
41
            FeatureQuery query
37 42
        ) {
38 43
        super(helper);
39 44
        this.featureType = featureType;
40 45
        this.table = table;
41 46
        this.baseFilter = baseFilter;
42
        this.filter = filter;
47
        this.query = query;
43 48
    }
44 49

  
45 50
    @Override
......
51 56
        JDBCSQLBuilderBase sqlbuilder = this.createSQLBuilder();
52 57
        ExpressionBuilder expbuilder = sqlbuilder.expression();
53 58

  
54
        sqlbuilder.select().column().value(sqlbuilder.count().all());
55
        sqlbuilder.select().from().table()
56
                .database(this.table.getDatabase())
57
                .schema(this.table.getSchema())
58
                .name(this.table.getTable());
59
        sqlbuilder.select().from().subquery(this.table.getSubquery());
60
        if (!StringUtils.isEmpty(baseFilter)) {
61
            sqlbuilder.select().where().set( expbuilder.custom(baseFilter) );
59
        SelectBuilder select = sqlbuilder.select();
60
        
61
        if( this.query!=null && this.query.hasGroupByColumns() ) {
62
          JDBCSQLBuilderBase subsqlbuilder = this.createSQLBuilder();
63
          SelectBuilder subselect = subsqlbuilder.select();
64
          subselect.column().value(subsqlbuilder.count().all());
65
          subselect.from().table()
66
                  .database(this.table.getDatabase())
67
                  .schema(this.table.getSchema())
68
                  .name(this.table.getTable());
69
          subselect.from().subquery(this.table.getSubquery());
70
          Evaluator filter = query==null? null:query.getFilter();
71
          if( filter != null ) {
72
              String sqlfilter = filter.getSQL();
73
              if( ! StringUtils.isEmpty(sqlfilter) ) {
74
                  if( this.helper.supportFilter(this.featureType, filter) ) {
75
                      subselect.where().set(expbuilder.toValue(sqlfilter));
76
                  }
77
              }
78
          }
79
          if( ! StringUtils.isEmpty(baseFilter) ) {
80
              subselect.where().and(expbuilder.toValue(baseFilter));
81
          }
82

  
83
          FeatureQueryOrder order = query==null? null:query.getOrder();
84
          if( order != null ) {
85
              for( FeatureQueryOrder.FeatureQueryOrderMember member : order.members() ) {
86
                  if( member.hasEvaluator() ) {
87
                      String sqlorder = member.getEvaluator().getSQL();
88
                      if( ! StringUtils.isEmpty(sqlorder) ) {
89
                          subselect.order_by().custom(sqlorder);
90
                      }
91
                  } else {
92
                      subselect.order_by()
93
                              .column(member.getAttributeName())
94
                              .ascending(member.getAscending());
95
                  }
96
              }
97
          }
98
          
99
          List<String> groupbyColumns = query==null? null:query.getGroupByColumns();
100
          if( groupbyColumns!=null && !groupbyColumns.isEmpty() ) {
101
            for(String columnName : groupbyColumns ) {
102
                subselect.group_by(expbuilder.column(columnName));
103
            }
104
          }
105
          subsqlbuilder.setProperties(
106
                  ExpressionBuilder.Variable.class, 
107
                  PROP_TABLE, table
108
          );
109
          String subsql = subselect.toString();
110
          select.from().table()
111
                  .database(this.table.getDatabase())
112
                  .schema(this.table.getSchema())
113
                  .name(this.table.getTable());
114
          select.from().subquery(subsql);
115
          
116
          
117
        } else {
118
          select.column().value(sqlbuilder.count().all());
119
          select.from().table()
120
                  .database(this.table.getDatabase())
121
                  .schema(this.table.getSchema())
122
                  .name(this.table.getTable());
123
          select.from().subquery(this.table.getSubquery());
124
          if (!StringUtils.isEmpty(baseFilter)) {
125
              sqlbuilder.select().where().set( expbuilder.custom(baseFilter) );
126
          }
127
          if( this.query!=null ) {
128
            if( this.query.getFilter()!=null && !StringUtils.isBlank(this.query.getFilter().getSQL()) ) {
129
              // El and() hace un set() si no hay un filtro previo
130
              select.where().and(expbuilder.toValue(this.query.getFilter().getSQL()));
131
            }
132
          }
62 133
        }
63
        if (!StringUtils.isEmpty(filter)) {
64
            // El and() hace un set() si no hay un filtro previo
65
            sqlbuilder.select().where().and(expbuilder.toValue(filter));
66
        }
67 134
        this.helper.replaceForeingValueFunction(sqlbuilder, featureType, null);
68 135
        
69
        sqlbuilder.select().remove_all_columns();
70
        sqlbuilder.select().column().value(sqlbuilder.count().all());
136
        select.remove_all_columns();
137
        select.column().value(sqlbuilder.count().all());
71 138
        
72 139
        sqlbuilder.setProperties(
73 140
                ExpressionBuilder.Variable.class, 
74 141
                PROP_TABLE, table
75 142
        );
76
        String sql = sqlbuilder.select().toString();
143

  
144
        String sql = select.toString();
77 145
        return sql;
78 146
    }
79 147
    

Also available in: Unified diff