Don't use the ListDBAccess classes to get the primary key layout information.
[online-glom:gwt-glom.git] / src / main / java / org / glom / web / server / database / ListDBAccess.java
1 /*
2  * Copyright (C) 2011 Openismus GmbH
3  *
4  * This file is part of GWT-Glom.
5  *
6  * GWT-Glom is free software: you can redistribute it and/or modify it
7  * under the terms of the GNU Lesser General Public License as published by the
8  * Free Software Foundation, either version 3 of the License, or (at your
9  * option) any later version.
10  *
11  * GWT-Glom is distributed in the hope that it will be useful, but WITHOUT
12  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
13  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public License
14  * for more details.
15  *
16  * You should have received a copy of the GNU Lesser General Public License
17  * along with GWT-Glom.  If not, see <http://www.gnu.org/licenses/>.
18  */
19
20 package org.glom.web.server.database;
21
22 import java.sql.Connection;
23 import java.sql.ResultSet;
24 import java.sql.SQLException;
25 import java.sql.Statement;
26 import java.util.ArrayList;
27
28 import org.glom.libglom.Document;
29 import org.glom.libglom.Field;
30 import org.glom.libglom.LayoutFieldVector;
31 import org.glom.libglom.LayoutItem_Field;
32 import org.glom.libglom.SortClause;
33 import org.glom.libglom.SortFieldPair;
34 import org.glom.web.server.Log;
35 import org.glom.web.server.Utils;
36 import org.glom.web.shared.DataItem;
37
38 import com.mchange.v2.c3p0.ComboPooledDataSource;
39
40 /**
41  * @author Ben Konrath <ben@bagu.org>
42  * 
43  */
44 public abstract class ListDBAccess extends DBAccess {
45         protected LayoutFieldVector fieldsToGet;
46
47         protected ListDBAccess(Document document, String documentID, ComboPooledDataSource cpds, String tableName) {
48                 super(document, documentID, cpds, tableName);
49         }
50
51         protected abstract String getSelectQuery(SortClause sortClause);
52
53         protected abstract String getCountQuery();
54
55         protected ArrayList<DataItem[]> getListData(int start, int length, boolean useSortClause, int sortColumnIndex,
56                         boolean isAscending) {
57
58                 // Add a LayoutItem_Field for the primary key to the end of the LayoutFieldVector if it doesn't already contain
59                 // a primary key.
60                 if (getPrimaryKeyIndex() < 0) {
61                         fieldsToGet.add(getPrimaryKeyLayoutItemField());
62                 }
63
64                 // create a sort clause for the column we've been asked to sort
65                 SortClause sortClause = new SortClause();
66                 if (useSortClause) {
67                         org.glom.libglom.LayoutItem item = fieldsToGet.get(sortColumnIndex);
68                         LayoutItem_Field layoutItemField = LayoutItem_Field.cast_dynamic(item);
69                         if (layoutItemField != null)
70                                 sortClause.addLast(new SortFieldPair(layoutItemField, isAscending));
71                         else {
72                                 Log.error(documentID, tableName, "Error getting LayoutItem_Field for column index " + sortColumnIndex
73                                                 + ". Cannot create a sort clause for this column.");
74                         }
75                 } else {
76                         // create a sort clause for the primary key if we're not asked to sort a specific column
77                         int numItems = Utils.safeLongToInt(fieldsToGet.size());
78                         for (int i = 0; i < numItems; i++) {
79                                 LayoutItem_Field layoutItem = fieldsToGet.get(i);
80                                 Field details = layoutItem.get_full_field_details();
81                                 if (details != null && details.get_primary_key()) {
82                                         sortClause.addLast(new SortFieldPair(layoutItem, true)); // ascending
83                                         break;
84                                 }
85                         }
86                 }
87
88                 ArrayList<DataItem[]> rowsList = new ArrayList<DataItem[]>();
89                 Connection conn = null;
90                 Statement st = null;
91                 ResultSet rs = null;
92                 try {
93                         // Setup the JDBC driver and get the query. Special care needs to be take to ensure that the results will be
94                         // based on a cursor so that large amounts of memory are not consumed when the query retrieve a large amount
95                         // of data. Here's the relevant PostgreSQL documentation:
96                         // http://jdbc.postgresql.org/documentation/83/query.html#query-with-cursor
97                         conn = cpds.getConnection();
98                         conn.setAutoCommit(false);
99                         st = conn.createStatement(ResultSet.TYPE_FORWARD_ONLY, ResultSet.CONCUR_READ_ONLY);
100                         st.setFetchSize(length);
101                         String query = getSelectQuery(sortClause) + " OFFSET " + start;
102                         // TODO Test memory usage before and after we execute the query that would result in a large ResultSet.
103                         // We need to ensure that the JDBC driver is in fact returning a cursor based result set that has a low
104                         // memory footprint. Check the difference between this value before and after the query:
105                         // Runtime.getRuntime().totalMemory() - Runtime.getRuntime().freeMemory()
106                         // Test the execution time at the same time (see the todo item in getLayoutListTable()).
107                         rs = st.executeQuery(query);
108
109                         // get the results from the ResultSet
110                         rowsList = convertResultSetToDTO(length, fieldsToGet, rs);
111                 } catch (SQLException e) {
112                         Log.error(documentID, tableName, "Error executing database query.", e);
113                         // TODO: somehow notify user of problem
114                 } finally {
115                         // cleanup everything that has been used
116                         try {
117                                 if (rs != null)
118                                         rs.close();
119                                 if (st != null)
120                                         st.close();
121                                 if (conn != null)
122                                         conn.close();
123                         } catch (Exception e) {
124                                 Log.error(documentID, tableName,
125                                                 "Error closing database resources. Subsequent database queries may not work.", e);
126                         }
127                 }
128                 return rowsList;
129         }
130
131         /*
132          * Get the number of rows a query with the table name and layout fields would return. This is needed for the /* list
133          * view pager.
134          */
135         protected int getResultSizeOfSQLQuery() {
136
137                 // Add a LayoutItem_Field for the primary key to the end of the LayoutFieldVector if it doesn't already contain
138                 // a primary key.
139                 if (getPrimaryKeyIndex() < 0) {
140                         fieldsToGet.add(getPrimaryKeyLayoutItemField());
141                 }
142
143                 Connection conn = null;
144                 Statement st = null;
145                 ResultSet rs = null;
146                 try {
147                         // Setup and execute the count query. Special care needs to be take to ensure that the results will be based
148                         // on a cursor so that large amounts of memory are not consumed when the query retrieve a large amount of
149                         // data. Here's the relevant PostgreSQL documentation:
150                         // http://jdbc.postgresql.org/documentation/83/query.html#query-with-cursor
151                         conn = cpds.getConnection();
152                         conn.setAutoCommit(false);
153                         st = conn.createStatement(ResultSet.TYPE_FORWARD_ONLY, ResultSet.CONCUR_READ_ONLY);
154                         String query = getCountQuery();
155                         // TODO Test execution time of this query with when the number of rows in the table is large (say >
156                         // 1,000,000). Test memory usage at the same time (see the todo item in getTableData()).
157                         rs = st.executeQuery(query);
158
159                         // get the number of rows in the query
160                         rs.next();
161                         return rs.getInt(1);
162
163                 } catch (SQLException e) {
164                         Log.error(documentID, tableName, "Error calculating number of rows in the query.", e);
165                         return -1;
166                 } finally {
167                         // cleanup everything that has been used
168                         try {
169                                 if (rs != null)
170                                         rs.close();
171                                 if (st != null)
172                                         st.close();
173                                 if (conn != null)
174                                         conn.close();
175                         } catch (Exception e) {
176                                 Log.error(documentID, tableName,
177                                                 "Error closing database resources. Subsequent database queries may not work.", e);
178                         }
179                 }
180         }
181
182         /**
183          * Gets the primary key index of this list layout.
184          * 
185          * @return index of primary key or -1 if a primary key was not found
186          */
187         public int getPrimaryKeyIndex() {
188                 for (int i = 0; i < fieldsToGet.size(); i++) {
189                         LayoutItem_Field layoutItemField = fieldsToGet.get(i);
190                         Field field = layoutItemField.get_full_field_details();
191                         if (field != null && field.get_primary_key())
192                                 return i;
193                 }
194                 return -1;
195         }
196 }