← Back to branch summary

~mortenoh/+junk/dhis2-detailed-import-export

« back to all changes in this revision

Viewing changes to dhis-2/dhis-services/dhis-service-jdbc/src/main/java/org/hisp/dhis/jdbc/statementbuilder/PostgreSQLStatementBuilder.java

  • Committer: larshelge at gmail
  • Date: 2009-03-03 16:46:36 UTC
  • Revision ID: larshelge@gmail.com-20090303164636-2sjlrquo7ib1gf7r
Initial check-in

Show diffs side-by-side

added added

removed removed

Lines of Context:
dhis-2/dhis-services/dhis-service-jdbc/src/main/java/org/hisp/dhis/jdbc/statementbuilder/PostgreSQLStatementBuilder.java
 
1
package org.hisp.dhis.jdbc.statementbuilder;
 
2
 
 
3
/*
 
4
 * Copyright (c) 2004-2007, University of Oslo
 
5
 * All rights reserved.
 
6
 *
 
7
 * Redistribution and use in source and binary forms, with or without
 
8
 * modification, are permitted provided that the following conditions are met:
 
9
 * * Redistributions of source code must retain the above copyright notice, this
 
10
 *   list of conditions and the following disclaimer.
 
11
 * * Redistributions in binary form must reproduce the above copyright notice,
 
12
 *   this list of conditions and the following disclaimer in the documentation
 
13
 *   and/or other materials provided with the distribution.
 
14
 * * Neither the name of the HISP project nor the names of its contributors may
 
15
 *   be used to endorse or promote products derived from this software without
 
16
 *   specific prior written permission.
 
17
 *
 
18
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
 
19
 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
 
20
 * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
 
21
 * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR
 
22
 * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
 
23
 * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
 
24
 * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
 
25
 * ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 
26
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
 
27
 * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
28
 */
 
29
 
 
30
import java.util.Iterator;
 
31
import java.util.Map;
 
32
import java.util.Map.Entry;
 
33
 
 
34
import org.hisp.dhis.period.Period;
 
35
import org.hisp.dhis.period.RelativePeriodType;
 
36
 
 
37
/**
 
38
 * @author Lars Helge Overland
 
39
 * @version $Id: PostgreSQLStatementBuilder.java 5715 2008-09-17 14:05:28Z larshelg $
 
40
 */
 
41
public class PostgreSQLStatementBuilder
 
42
    extends AbstractStatementBuilder
 
43
{
 
44
    private static final String AUTO_INCREMENT = "nextval('hibernate_sequence')";
 
45
    
 
46
    // -------------------------------------------------------------------------
 
47
    // Constructor
 
48
    // -------------------------------------------------------------------------
 
49
 
 
50
    public PostgreSQLStatementBuilder()
 
51
    {
 
52
        super();
 
53
    }    
 
54
 
 
55
    // -------------------------------------------------------------------------
 
56
    // AbstractStatementBuilder implementation
 
57
    // -------------------------------------------------------------------------
 
58
 
 
59
    public String getInsertStatementOpening( String table )
 
60
    {
 
61
        if ( autoIncrementColumnIndex != null && autoIncrementColumnName != null )
 
62
        {
 
63
            columns.add( autoIncrementColumnIndex, autoIncrementColumnName );
 
64
        }
 
65
        
 
66
        StringBuffer buffer = new StringBuffer();
 
67
        
 
68
        buffer.append( "INSERT INTO " + table + " (" );
 
69
        
 
70
        for ( String column : columns )
 
71
        {
 
72
            buffer.append( column + SEPARATOR );
 
73
        }
 
74
        
 
75
        if ( columns.size() > 0 )
 
76
        {
 
77
            buffer.deleteCharAt( buffer.length() - 1 );
 
78
        }
 
79
        
 
80
        buffer.append( BRACKET_END + " VALUES " );
 
81
        
 
82
        columns.clear();
 
83
        
 
84
        return buffer.toString();
 
85
    }
 
86
 
 
87
    public String getNoColumnInsertStatementOpening( String table )
 
88
    {
 
89
        String sql = "INSERT INTO " + table + " VALUES ";
 
90
        
 
91
        return sql;
 
92
    }
 
93
        
 
94
    public String getInsertStatementValues()
 
95
    {
 
96
        if ( autoIncrementColumnIndex != null )
 
97
        {
 
98
            values.add( autoIncrementColumnIndex, AUTO_INCREMENT );
 
99
        }
 
100
        
 
101
        StringBuffer buffer = new StringBuffer();
 
102
        
 
103
        buffer.append( BRACKET_START );
 
104
        
 
105
        for ( String value : values )
 
106
        {
 
107
            buffer.append( value + SEPARATOR );
 
108
        }
 
109
        
 
110
        if ( values.size() > 0 )
 
111
        {
 
112
            buffer.deleteCharAt( buffer.length() - 1 );
 
113
        }
 
114
        
 
115
        buffer.append( BRACKET_END + SEPARATOR );
 
116
        
 
117
        values.clear();
 
118
        
 
119
        return buffer.toString();
 
120
    }
 
121
 
 
122
    public String getUpdateStatement( String table )
 
123
    {
 
124
        StringBuffer buffer = new StringBuffer();
 
125
        
 
126
        buffer.append( "UPDATE " + table + " SET " );
 
127
 
 
128
        Iterator<String> columnIterator = columns.iterator();
 
129
        Iterator<String> valueIterator = values.iterator();
 
130
        
 
131
        while ( columnIterator.hasNext() )
 
132
        {
 
133
            buffer.append( columnIterator.next() + "=" + valueIterator.next() + SEPARATOR );
 
134
        }
 
135
        
 
136
        if ( columns.size() > 0 && values.size() > 0 )
 
137
        {
 
138
            buffer.deleteCharAt( buffer.length() - 1 );
 
139
        }
 
140
        
 
141
        buffer.append( " WHERE " + identifierColumnName + "=" + identifierColumnValue );
 
142
        
 
143
        columns.clear();
 
144
        values.clear();
 
145
        
 
146
        return buffer.toString();
 
147
    }
 
148
    
 
149
    public String getValueStatement( String table, String returnField, String compareField, String value )
 
150
    {
 
151
        String sql = "SELECT " + returnField + " FROM " + table + " WHERE " + compareField + " = '" + sqlEncode( value ) + "'";
 
152
        
 
153
        return sql;
 
154
    }
 
155
 
 
156
    public String getValueStatement( String table, String returnField1, String returnField2, String compareField1, String value1, String compareField2, String value2 )
 
157
    {
 
158
        String sql = "SELECT " + returnField1 + ", " + returnField2 + " FROM " + table + " WHERE " + compareField1 + "='" + sqlEncode( value1 ) + "' AND " + compareField2 + "='" + value2 + "'";
 
159
        
 
160
        return sql;
 
161
    }
 
162
 
 
163
    public String getValueStatement( String table, String returnField, Map<String, String> fieldMap, boolean union )
 
164
    {
 
165
        String operator = union ? " AND " : " OR ";
 
166
        
 
167
        StringBuffer sqlBuffer = new StringBuffer( "SELECT " ).append( returnField ).append( " FROM " ).append( table ).append( " WHERE " );
 
168
        
 
169
        for ( Entry<String, String> entry : fieldMap.entrySet() )
 
170
        {
 
171
            sqlBuffer.append( entry.getKey() ).append( "='" ).append( sqlEncode( entry.getValue() ) ).append( "'" ).append( operator );
 
172
        }
 
173
 
 
174
        String sql = sqlBuffer.toString();
 
175
        sql = sql.substring( 0, sql.length() - operator.length() );
 
176
        
 
177
        return sql;
 
178
    }
 
179
    
 
180
    public String getDoubleColumnType()
 
181
    {
 
182
        String type = "DOUBLE PRECISION";
 
183
        
 
184
        return type;
 
185
    }
 
186
    
 
187
    public String getPeriodIdentifierStatement( Period period )
 
188
    {
 
189
        String sql = 
 
190
            "SELECT periodid FROM period WHERE periodtypeid=" + period.getPeriodType().getId() + " " + 
 
191
            "AND startdate='" + getDateString( period.getStartDate() ) + "' " +
 
192
            "AND enddate='" + getDateString( period.getEndDate() ) + "'";
 
193
        
 
194
        return sql;
 
195
    }
 
196
 
 
197
    public String getCreateAggregatedDataValueTable()
 
198
    {
 
199
        String sql = "CREATE TABLE aggregateddatavalue ( " +
 
200
            "dataelementid INTEGER, " +
 
201
            "categoryoptioncomboid INTEGER, " +
 
202
            "periodid INTEGER, " +
 
203
            "organisationunitid INTEGER, " +
 
204
            "periodtypeid INTEGER, " +
 
205
            "level INTEGER, " +
 
206
            "value DOUBLE PRECISION );";
 
207
        
 
208
        return sql;
 
209
    }
 
210
    
 
211
    public String getCreateAggregatedIndicatorTable()
 
212
    {
 
213
        String sql = "CREATE TABLE aggregatedindicatorvalue ( " +
 
214
            "indicatorid INTEGER, " +
 
215
            "periodid INTEGER, " +
 
216
            "organisationunitid INTEGER, " +
 
217
            "periodtypeid INTEGER, " +
 
218
            "level INTEGER, " +
 
219
            "annualized VARCHAR( 10 ), " +
 
220
            "factor DOUBLE PRECISION, " +
 
221
            "value DOUBLE PRECISION, " +
 
222
            "numeratorvalue DOUBLE PRECISION, " +
 
223
            "denominatorvalue DOUBLE PRECISION );";
 
224
        
 
225
        return sql;
 
226
    }
 
227
 
 
228
    public String getCreateDataSetCompletenessTable()
 
229
    {
 
230
        String sql = "CREATE TABLE aggregateddatasetcompleteness ( " +
 
231
            "datasetid INTEGER, " +
 
232
            "periodid INTEGER, " +
 
233
            "periodname VARCHAR( 30 ), " +
 
234
            "organisationunitid INTEGER, " +
 
235
            "reporttableid INTEGER, " +
 
236
            "sources INTEGER, " +
 
237
            "registrations INTEGER, " +
 
238
            "registrationsOnTime INTEGER, " +
 
239
            "value DOUBLE PRECISION, " +
 
240
            "valueOnTime DOUBLE PRECISION );";
 
241
        
 
242
        return sql;
 
243
    }
 
244
 
 
245
    public String getCreateDataValueIndex()
 
246
    {
 
247
        String sql =
 
248
            "CREATE INDEX crosstab " +
 
249
            "ON datavalue ( periodid, sourceid );";
 
250
        
 
251
        return sql;
 
252
    }
 
253
    
 
254
    public String getDeleteRelativePeriods()
 
255
    {
 
256
        String sql =
 
257
            "DELETE FROM period " +
 
258
            "USING periodtype " +
 
259
            "WHERE period.periodtypeid = periodtype.periodtypeid " +
 
260
            "AND periodtype.name = '" + RelativePeriodType.NAME + "';";
 
261
        
 
262
        return sql;
 
263
    }
 
264
    
 
265
    public String getDeleteZeroDataValues()
 
266
    {
 
267
        String sql = 
 
268
            "DELETE FROM datavalue " +
 
269
            "USING dataelement " +
 
270
            "WHERE datavalue.dataelementid = dataelement.dataelementid " +
 
271
            "AND dataelement.aggregationtype = 'sum' " +
 
272
            "AND datavalue.value IN ( '0', '0.', '.0', '0.0', ' 0', '0 ', '0 0' )";
 
273
        
 
274
        return sql;
 
275
    }
 
276
}