001: /**
002: * Objective Database Abstraction Layer (ODAL)
003: * Copyright (c) 2004, The ODAL Development Group
004: * All rights reserved.
005: * For definition of the ODAL Development Group please refer to LICENCE.txt file
006: *
007: * Distributable under LGPL license.
008: * See terms of license at gnu.org.
009: */package com.completex.objective.components.persistency.core.impl;
010:
011: import com.completex.objective.components.log.Log;
012: import com.completex.objective.components.persistency.AbstractParameters;
013: import com.completex.objective.components.persistency.Call;
014: import com.completex.objective.components.persistency.CallParameters;
015: import com.completex.objective.components.persistency.LifeCycleController;
016: import com.completex.objective.components.persistency.OdalPersistencyException;
017: import com.completex.objective.components.persistency.OdalRuntimePersistencyException;
018: import com.completex.objective.components.persistency.ResultableQueryManager;
019: import com.completex.objective.components.persistency.core.ResultSetCtl;
020: import com.completex.objective.components.persistency.core.ResultSetExecutor;
021: import com.completex.objective.components.persistency.core.ResultSetExecutorManager;
022: import com.completex.objective.components.persistency.core.ResultSetIterator;
023: import com.completex.objective.components.persistency.core.impl.query.QueryContext;
024: import com.completex.objective.components.persistency.transact.Transaction;
025: import com.completex.objective.components.persistency.type.MultipartCollection;
026:
027: import java.sql.CallableStatement;
028: import java.sql.PreparedStatement;
029: import java.sql.SQLException;
030: import java.util.Collection;
031:
032: /**
033: * @author Gennady Krizhevsky
034: */
035: public class ResultSetExecutorManagerImpl implements
036: ResultSetExecutorManager {
037:
038: private QueryResultSetExecutor defaultQueryResultSetExecutor = new QueryResultSetExecutor();
039: private RefCursorResultSetExecutor defaultRefCursorResultSetExecutor = new RefCursorResultSetExecutor();
040: private BasicDatabasePersistencyImpl persistency;
041: private ResultSetExecutor queryResultSetExecutor = defaultQueryResultSetExecutor;
042: private ResultSetExecutor refCursorResultSetExecutor = defaultRefCursorResultSetExecutor;
043: private Log logger = Log.NULL_LOGGER;
044:
045: ResultSetExecutorManagerImpl() {
046: }
047:
048: public ResultSetExecutorManagerImpl(
049: BasicDatabasePersistencyImpl persistency, Log logger) {
050: setPersistency(persistency);
051: setLogger(logger);
052: }
053:
054: public ResultSetExecutorManagerImpl(
055: BasicDatabasePersistencyImpl persistency,
056: ResultSetExecutor queryResultSetExecutor,
057: ResultSetExecutor refCursorResultSetExecutor, Log logger) {
058:
059: if (queryResultSetExecutor != null) {
060: this .queryResultSetExecutor = queryResultSetExecutor;
061: }
062: if (refCursorResultSetExecutor != null) {
063: this .refCursorResultSetExecutor = refCursorResultSetExecutor;
064: }
065: setPersistency(persistency);
066: setLogger(logger);
067: }
068:
069: //
070: // Query methods:
071: //
072: public Collection executeSingleRsQuery(Transaction transaction,
073: PreparedStatement statement, ResultableQueryManager query,
074: ResultSetCtl resultSetCtl, LifeCycleController controller,
075: QueryContext queryContext) throws SQLException {
076: MultipartCollection results = new MultipartCollection();
077:
078: queryResultSetExecutor.executeSingleRs(transaction, statement,
079: query, resultSetCtl, results, controller, queryContext);
080: invalidateEmptyCollections(results);
081: return results.getFirst();
082: }
083:
084: public Collection executeQueryFetch(Transaction transaction,
085: ResultableQueryManager query, ResultSetCtl resultSetCtl,
086: LifeCycleController controller, QueryContext queryContext)
087: throws SQLException {
088: return queryResultSetExecutor.executeFetch(
089: ((DatabaseTransactionImpl) transaction), query,
090: resultSetCtl, controller, queryContext);
091: }
092:
093: public Collection executeCallFetch(Transaction transaction,
094: ResultableQueryManager query, ResultSetCtl resultSetCtl,
095: LifeCycleController controller) throws SQLException {
096: if (supportsRefCursor()) {
097: return refCursorResultSetExecutor.executeFetch(
098: ((DatabaseTransactionImpl) transaction), query,
099: resultSetCtl, controller, null);
100: } else {
101: return queryResultSetExecutor.executeFetch(
102: ((DatabaseTransactionImpl) transaction), query,
103: resultSetCtl, controller, null);
104: }
105: }
106:
107: //
108: // Call methods:
109: //
110: public Collection executeSingleRsCall(Transaction transaction,
111: CallableStatement statement, Call query,
112: ResultSetCtl resultSetCtl, LifeCycleController controller)
113: throws SQLException {
114: MultipartCollection results = executeCall(transaction,
115: statement, query, resultSetCtl, controller, true);
116: invalidateEmptyCollections(results);
117: return results.getFirst();
118: }
119:
120: public void invalidateEmptyCollections(
121: MultipartCollection collection)
122: throws OdalPersistencyException {
123: if (collection == null || collection.isEmpty()) {
124: throw new OdalPersistencyException(
125: "Retrived collection is null "
126: + "meaning that the query is not SELECT one or the "
127: + "call is not the one that CAN ever return ResultSet");
128: }
129: }
130:
131: public MultipartCollection executeMultiRsCall(
132: Transaction transaction, CallableStatement statement,
133: Call query, ResultSetCtl resultSetCtl,
134: LifeCycleController controller) throws SQLException {
135: return executeCall(transaction, statement, query, resultSetCtl,
136: controller, false);
137: }
138:
139: public ResultSetIterator resultSetIterator(
140: PreparedStatement statement, AbstractParameters parameters)
141: throws SQLException {
142: validateCallable(statement, parameters);
143: if (isRefCursorCall(statement)) {
144: return refCursorResultSetExecutor.resultSetIterator(
145: statement, parameters);
146: } else {
147: return queryResultSetExecutor.resultSetIterator(statement,
148: parameters);
149: }
150: }
151:
152: private void validateCallable(PreparedStatement statement,
153: AbstractParameters parameters) {
154: if (statement instanceof CallableStatement
155: && !(parameters instanceof CallParameters)) {
156: throw new OdalRuntimePersistencyException(
157: "Expected parameters to be of "
158: + "CallParameters type whereas received "
159: + parameters);
160: }
161: }
162:
163: protected MultipartCollection executeCall(Transaction transaction,
164: CallableStatement statement, Call query,
165: ResultSetCtl resultSetCtl, LifeCycleController controller,
166: boolean firstOnly) throws SQLException {
167: MultipartCollection results = new MultipartCollection();
168: if (supportsRefCursor()) {
169: refCursorResultSetExecutor.execute(transaction, statement,
170: query, resultSetCtl, results, controller,
171: firstOnly, null);
172: } else {
173: queryResultSetExecutor.execute(transaction, statement,
174: query, resultSetCtl, results, controller,
175: firstOnly, null);
176: }
177: //
178: // Populate all the out parameters:
179: //
180: persistency.populateCallOutParameters(query, statement);
181: return results;
182: }
183:
184: private boolean isRefCursorCall(PreparedStatement statement) {
185: boolean supportsRefCursor = supportsRefCursor();
186: boolean isCall = statement instanceof CallableStatement;
187: return supportsRefCursor && isCall;
188: }
189:
190: private boolean supportsRefCursor() {
191: return persistency.getDatabasePolicy().getRefCursorJdbcType() != 0;
192: }
193:
194: //
195: // Util methods;
196: //
197: public BasicDatabasePersistencyImpl getPersistency() {
198: return persistency;
199: }
200:
201: public void setPersistency(BasicDatabasePersistencyImpl persistency) {
202: this .persistency = persistency;
203: this .defaultQueryResultSetExecutor.setPersistency(persistency);
204: this .defaultRefCursorResultSetExecutor
205: .setPersistency(persistency);
206: }
207:
208: public Log getLogger() {
209: return logger;
210: }
211:
212: public void setLogger(Log logger) {
213: if (logger != null) {
214: this.logger = logger;
215: }
216: this.defaultQueryResultSetExecutor.setLogger(logger);
217: this.defaultRefCursorResultSetExecutor.setLogger(logger);
218: }
219:
220: }
|