/*
* Licensed to the Apache Software Foundation (ASF) under one
* or more contributor license agreements. See the NOTICE file
* distributed with this work for additional information
* regarding copyright ownership. The ASF licenses this file
* to you under the Apache License, Version 2.0 (the
* "License"); you may not use this file except in compliance
* with the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing,
* software distributed under the License is distributed on an
* "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
* KIND, either express or implied. See the License for the
* specific language governing permissions and limitations
* under the License.
*/
package org.apache.openjpa.jdbc.kernel;
import java.io.IOException;
import java.io.NotSerializableException;
import java.io.ObjectOutputStream;
import java.sql.Connection;
import java.util.Collection;
import org.apache.openjpa.conf.OpenJPAConfiguration;
import org.apache.openjpa.kernel.Broker;
import org.apache.openjpa.kernel.OpenJPASavepoint;
import org.apache.openjpa.kernel.RestoreState;
import org.apache.openjpa.kernel.SavepointManager;
import org.apache.openjpa.lib.conf.Configurable;
import org.apache.openjpa.lib.conf.Configuration;
/**
* Abstract {@link SavepointManager} implementation that
* delegates to the subclass for savepoint operations on the active
* {@link Connection}. This implementation issues a flush and relies
* on the driver/db to restore back to the flushed state.
*
* @author Steve Kim
* @since 0.3.4
*/
public abstract class AbstractJDBCSavepointManager
implements SavepointManager, Configurable {
private boolean _restore = false;
public void startConfiguration() {
}
public void setConfiguration(Configuration conf) {
_restore = ((OpenJPAConfiguration) conf).getRestoreStateConstant()
!= RestoreState.RESTORE_NONE;
}
public void endConfiguration() {
}
/**
* Return whether to retain in-memory copies of field values for restore
* on rollback. Defaults to {@link OpenJPAConfiguration#getRestoreState).
*/
public boolean getRestoreFieldState() {
return _restore;
}
/**
* Set whether to retain in-memory copies of field values for restore
* on rollback. Defaults to {@link OpenJPAConfiguration#getRestoreState}.
*/
public void setRestoreFieldState(boolean restore) {
_restore = restore;
}
public OpenJPASavepoint newSavepoint(String name, Broker broker) {
// flush after creating savepoint b/c flush may add/change states
OpenJPASavepoint save = new ConnectionSavepoint(broker, name, _restore);
broker.flush();
return save;
}
public boolean supportsIncrementalFlush() {
return true;
}
/**
* Rollback the datastore savepoint.
*/
protected abstract void rollbackDataStore(ConnectionSavepoint savepoint);
/**
* Set the datastore savepoint.
*/
protected abstract void setDataStore(ConnectionSavepoint savepoint);
/**
* A savepoint which provides access to the current transactional
* connection.
*/
protected class ConnectionSavepoint extends OpenJPASavepoint {
private Object _savepoint;
public ConnectionSavepoint(Broker broker, String name, boolean copy) {
super(broker, name, copy);
}
/**
* Return the stored savepoint object
*/
public Object getDataStoreSavepoint() {
return _savepoint;
}
/**
* Set the implementation specific savepoint object
*/
public void setDataStoreSavepoint(Object savepoint) {
_savepoint = savepoint;
}
/**
* Return the current {@link Connection} for this savepoint.
*/
public Connection getConnection() {
return ((JDBCStoreManager) getBroker().getStoreManager().
getInnermostDelegate()).getConnection();
}
public Collection rollback(Collection previous) {
AbstractJDBCSavepointManager.this.rollbackDataStore(this);
return super.rollback(previous);
}
public void save(Collection states) {
AbstractJDBCSavepointManager.this.setDataStore(this);
super.save(states);
}
private void writeObject(ObjectOutputStream out)
throws IOException {
throw new NotSerializableException();
}
}
}