1 package org.objectledge.parameters.db;
2
3 import java.sql.Connection;
4 import java.sql.ResultSet;
5 import java.sql.SQLException;
6 import java.sql.Statement;
7 import java.util.HashMap;
8 import java.util.Map;
9
10 import org.jcontainer.dna.Logger;
11 import org.objectledge.database.Database;
12 import org.objectledge.database.DatabaseUtils;
13 import org.objectledge.parameters.DefaultParameters;
14 import org.objectledge.parameters.Parameters;
15
16 /***
17 * Manages the parameters stored in database.
18 *
19 * @author <a href="mailto:pablo@caltha.com">Pawel Potempski</a>
20 * @version $Id: DefaultDBParametersManager.java,v 1.5 2005/12/20 09:09:32 pablo Exp $
21 */
22 public class DefaultDBParametersManager implements DBParametersManager
23 {
24 /*** the logger */
25 private Logger logger;
26
27 /*** the database */
28 private Database database;
29
30 /*** the parameters cache */
31 private Map<Long, Parameters> localCache;
32
33 /***
34 * Component cons.
35 *
36 * @param database the database access component.
37 * @param logger the logger.
38 */
39 public DefaultDBParametersManager(Database database, Logger logger)
40 {
41 this.logger = logger;
42 this.database = database;
43 localCache = new HashMap<Long, Parameters>();
44 }
45
46 /***
47 * Creates an empty container stored in database.
48 *
49 * @return the container.
50 * @throws DBParametersException thrown if creation failed.
51 */
52 public Parameters createContainer()
53 throws DBParametersException
54 {
55
56 long id = -1;
57 Connection conn = null;
58 try
59 {
60 conn = database.getConnection();
61 Statement statement = conn.createStatement();
62 id = database.getNextId(TABLE_NAME);
63 statement.execute("INSERT INTO "+TABLE_NAME+" values ("+id+",'','')");
64 }
65
66 catch(SQLException e)
67 {
68 throw new DBParametersException("Failed to insert the empty parameters", e);
69 }
70
71 finally
72 {
73 DatabaseUtils.close(conn);
74 }
75 DBParameters parameters = new DBParameters(null, id, database, logger);
76 Long key = new Long(id);
77 localCache.put(key, parameters);
78 return parameters;
79 }
80
81 /***
82 * Retrieves parameters from database.
83 *
84 * @param id the parameters identifier.
85 * @return the parameters.
86 * @throws DBParametersException if parameters cannot be found.
87 */
88 public Parameters getParameters(long id) throws DBParametersException
89 {
90 Parameters parameters;
91 Long key = new Long(id);
92 if (localCache.containsKey(key))
93 {
94 return (Parameters)localCache.get(key);
95 }
96 parameters = new DefaultParameters();
97 Connection conn = null;
98 try
99 {
100 conn = database.getConnection( );
101 Statement statement = conn.createStatement();
102 ResultSet result = statement.executeQuery("SELECT * from " + TABLE_NAME +
103 " where parameters_id = " + id);
104 boolean exist = false;
105 while (result.next())
106 {
107 exist = true;
108 if (!result.getString("name").equals(""))
109 {
110 parameters.add(DatabaseUtils.unescapeSqlString(result.getString("name")),
111 DatabaseUtils.unescapeSqlString(result.getString("value")));
112 }
113 }
114 if (!exist)
115 {
116 throw new DBParametersException("DBParameters with id = " + id + " does not exist");
117 }
118 parameters = new DBParameters(parameters, id, database, logger);
119 localCache.put(key, parameters);
120 return parameters;
121 }
122
123 catch (SQLException e)
124 {
125 throw new DBParametersException("Failed to retrieve object", e);
126 }
127
128 finally
129 {
130 DatabaseUtils.close(conn);
131 }
132 }
133
134 /***
135 * Deletes parameters from database.
136 *
137 * @param id the parameters identifier
138 * @throws DBParametersException thrown if failed to delete.
139 */
140 public void deleteParameters(long id)
141 throws DBParametersException
142 {
143 Long key = new Long(id);
144 Connection conn = null;
145 try
146 {
147 conn = database.getConnection();
148 Statement statement = conn.createStatement();
149 statement.execute("DELETE FROM "+TABLE_NAME+" where parameters_id = "+id);
150 localCache.remove(key);
151 }
152
153 catch(SQLException e)
154 {
155 throw new DBParametersException("Failed to delete parameters", e);
156 }
157
158 finally
159 {
160 DatabaseUtils.close(conn);
161 }
162 }
163
164 /***
165 * {@inheritDoc}
166 */
167 public void preloadContainers()
168 throws DBParametersException
169 {
170 Connection conn = null;
171 try
172 {
173 conn = database.getConnection();
174 Statement statement = conn.createStatement();
175 ResultSet result = statement.executeQuery("SELECT parameters_id, name, value FROM "+
176 TABLE_NAME+" ORDER BY parameters_id");
177 if(result.next())
178 {
179 long lastId;
180 Parameters temp = new DefaultParameters();
181 do
182 {
183 do
184 {
185 lastId = result.getLong(1);
186 if(result.getString(2).length() > 0)
187 {
188 temp.add(DatabaseUtils.unescapeSqlString(result.getString(2)),
189 DatabaseUtils.unescapeSqlString(result.getString(3)));
190 }
191 }
192 while(result.next() && result.getLong(1) == lastId);
193 Parameters pc = new DBParameters(temp, lastId, database, logger);
194 temp.remove();
195 localCache.put(new Long(lastId), pc);
196 }
197 while(!result.isAfterLast());
198 }
199 }
200 catch(SQLException e)
201 {
202 throw new DBParametersException("failed to preload parameters", e);
203 }
204 finally
205 {
206 DatabaseUtils.close(conn);
207 }
208 }
209 }