/**********************************************************************************
* $URL: https://source.sakaiproject.org/svn/kernel/trunk/kernel-util/src/main/java/org/sakaiproject/util/BaseDbDualSingleStorage.java $
* $Id: BaseDbDualSingleStorage.java 82133 2010-09-07 21:45:01Z aaronz@vt.edu $
***********************************************************************************
*
* Copyright (c) 2003, 2004, 2005, 2006, 2007, 2008 Sakai Foundation
*
* Licensed under the Educational Community 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.opensource.org/licenses/ECL-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.sakaiproject.util;
import java.sql.Connection;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.util.ArrayList;
import java.util.Hashtable;
import java.util.List;
import java.util.Map;
import java.util.Vector;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.sakaiproject.db.api.SqlReader;
import org.sakaiproject.db.api.SqlService;
import org.sakaiproject.entity.api.Edit;
import org.sakaiproject.entity.api.Entity;
import org.sakaiproject.entity.api.serialize.EntityParseException;
import org.sakaiproject.entity.api.serialize.EntityReader;
import org.sakaiproject.entity.api.serialize.EntityReaderHandler;
import org.sakaiproject.event.cover.UsageSessionService;
import org.sakaiproject.javax.Filter;
import org.sakaiproject.time.cover.TimeService;
/**
* <p>
* BaseDbDualSingleStorage is a class that stores Resources (of some type) in a
* database, <br />
* provides locked access, and generally implements a services "storage" class.
* The resources are encoded into two fields.
* Optionally a second storage can be provided which is where the items are loaded
* from when a putDeleteResource is called.
* The <br />
* service's storage class can extend this to provide covers to turn Resource
* and <br />
* Edit into something more type specific to the service.
* </p>
* <p>
* Note: the methods here are all "id" based, with the following assumptions:
* <br /> - just the Resource Id field is enough to distinguish one Resource
* from another <br /> - a resource's reference is based on no more than the
* resource id <br /> - a resource's id cannot change.
* </p>
* <p>
* In order to handle Unicode characters properly, the SQL statements executed
* by this class <br />
* should not embed Unicode characters into the SQL statement text; rather,
* Unicode values <br />
* should be inserted as fields in a PreparedStatement. Databases handle Unicode
* better in fields.
* </p>
*/
public class BaseDbDualSingleStorage implements DbSingleStorage
{
public static final String STORAGE_FIELDS = "XML, BINARY_ENTITY";
/** Our logger. */
private static Log M_log = LogFactory.getLog(BaseDbDualSingleStorage.class);
/** Table name for resource records. */
protected String m_resourceTableName = null;
/** The field in the resource table that holds the resource id. */
protected String m_resourceTableIdField = null;
/**
* The additional field names in the resource table that go between the two
* ids and the xml
*/
protected String[] m_resourceTableOtherFields = null;
/** The xml tag name for the element holding each actual resource entry. */
protected String m_resourceEntryTagName = null;
/** If true, we do our locks in the remote database. */
protected boolean m_locksAreInDb = false;
/**
* If true, we do our locks in the remove database using a separate locking
* table.
*/
protected boolean m_locksAreInTable = true;
/** The StorageUser to callback for new Resource and Edit objects. */
protected SingleStorageUser m_user = null;
/**
* Locks, keyed by reference, holding Connections (or, if locks are done
* locally, holding an Edit).
*/
protected Hashtable m_locks = null;
/** If set, we treat reasource ids as case insensitive. */
protected boolean m_caseInsensitive = false;
/** Injected (by constructor) SqlService. */
protected SqlService m_sql = null;
/** contains a map of the database dependent handlers. */
protected static Map<String, MultiSingleStorageSql> databaseBeans;
/** The db handler we are using. */
protected MultiSingleStorageSql singleStorageSql;
private long ttotal = 0;
private int ntime = 0;
private int rntime = 0;
private long rttotal = 0;
private long rmtotal = 0;
private long mtotal = 0;
public void setDatabaseBeans(Map databaseBeans)
{
this.databaseBeans = databaseBeans;
}
/**
* sets which bean containing database dependent code should be used
* depending on the database vendor.
*/
public void setSingleStorageSql(String vendor)
{
this.singleStorageSql = (databaseBeans.containsKey(vendor) ? databaseBeans
.get(vendor) : databaseBeans.get("default"));
}
// since spring is not used and this class is instatiated directly, we need
// to "inject" these values ourselves
static
{
databaseBeans = new Hashtable<String, MultiSingleStorageSql>();
databaseBeans.put("default", new MultiSingleStorageSqlDefault(STORAGE_FIELDS));
databaseBeans.put("hsql", new MultiSingleStorageSqlHSql(STORAGE_FIELDS));
databaseBeans.put("mysql", new MultiSingleStorageSqlMySql(STORAGE_FIELDS));
databaseBeans.put("oracle", new MultiSingleStorageSqlOracle(STORAGE_FIELDS));
}
/**
* Construct.
*
* @param resourceTableName
* Table name for resources.
* @param resourceTableIdField
* The field in the resource table that holds the id.
* @param resourceTableOtherFields
* The other fields in the resource table (between the two id and the
* xml fields).
* @param locksInDb
* If true, we do our locks in the remote database, otherwise we do
* them here.
* @param resourceEntryName
* The xml tag name for the element holding each actual resource
* entry.
* @param user
* The StorageUser class to call back for creation of Resource and
* Edit objects. This must implement EntityReader interface as well.
* @param sqlService
* The SqlService.
*/
public BaseDbDualSingleStorage(String resourceTableName, String resourceTableIdField,
String[] resourceTableOtherFields, boolean locksInDb,
String resourceEntryName, SingleStorageUser user, SqlService sqlService)
{
this(resourceTableName, resourceTableIdField, resourceTableOtherFields, locksInDb, resourceEntryName, user, sqlService, null);
}
// support for SAK-12874
protected DbSingleStorage m_storage = null;
/**
* Construct.
*
* @param resourceTableName
* Table name for resources.
* @param resourceTableIdField
* The field in the resource table that holds the id.
* @param resourceTableOtherFields
* The other fields in the resource table (between the two id and the
* xml fields).
* @param locksInDb
* If true, we do our locks in the remote database, otherwise we do
* them here.
* @param resourceEntryName
* The xml tag name for the element holding each actual resource
* entry.
* @param user
* The StorageUser class to call back for creation of Resource and
* Edit objects.
* @param sqlService
* The SqlService.
* @param storage
* The storage for the normal resource (only used by delete storage), this is how we load the original resource.
*/
public BaseDbDualSingleStorage(String resourceTableName, String resourceTableIdField,
String[] resourceTableOtherFields, boolean locksInDb,
String resourceEntryName, SingleStorageUser user, SqlService sqlService,
DbSingleStorage storage)
{
m_resourceTableName = resourceTableName;
m_resourceTableIdField = resourceTableIdField;
m_resourceTableOtherFields = resourceTableOtherFields;
m_locksAreInDb = locksInDb;
m_resourceEntryTagName = resourceEntryName;
m_user = user;
m_sql = sqlService;
// support for SAK-12874
m_storage = storage;
if (m_storage == null && m_resourceTableName != null && m_resourceTableName.toUpperCase().contains("DELETE")) {
// warn if the delete storage does not have the main storage set
M_log.warn("resource storage is not set, delete table resource file paths will be invalid");
}
setSingleStorageSql(m_sql.getVendor());
}
/**
* Open and be ready to read / write.
*/
public void open()
{
// setup for locks
m_locks = new Hashtable();
}
/**
* Close.
*/
public void close()
{
if (!m_locks.isEmpty())
{
M_log.warn("close(): locks remain!");
// %%%
}
m_locks.clear();
m_locks = null;
}
/**
* Read one Resource from xml
*
* @param xml
* An string containing the xml which describes the resource.
* @return The Resource object created from the xml.
*/
protected Entity readResource(String xml, byte[] blob)
{
Runtime r = Runtime.getRuntime();
long ms = r.freeMemory();
long start = System.currentTimeMillis();
String type = "";
try
{
type = "direct";
EntityReader de_user = (EntityReader) m_user;
EntityReaderHandler de_handler = de_user.getHandler();
return de_handler.parse(null, xml, blob);
}
catch (Exception e)
{
M_log.warn("readResource(): " + e.getMessage());
M_log.warn("readResource(): ", e);
return null;
}
finally
{
long t = System.currentTimeMillis() - start;
long me = r.freeMemory();
long md = ms - me;
if (md >= 0)
{
rmtotal += md;
}
else
{
if (rntime != 0)
{
rmtotal += (rmtotal / rntime);
}
}
rttotal += t;
rntime++;
if (rntime % 100 == 0)
{
double a = (1.0 * rttotal) / (1.0 * rntime);
double m = (1.0 * rmtotal) / (1.0 * rntime);
M_log.debug("Average " + type + " Parse now " + (a) + "ms " + m
+ " bytes");
}
}
}
/**
* Check if a Resource by this id exists.
*
* @param id
* The id.
* @return true if a Resource by this id exists, false if not.
*/
public boolean checkResource(String id)
{
// just see if the record exists
String sql = singleStorageSql.getResourceIdSql(m_resourceTableIdField,
m_resourceTableName);
Object fields[] = new Object[1];
fields[0] = caseId(id);
List ids = m_sql.dbRead(sql, fields, null);
return (!ids.isEmpty());
}
/**
* Get the Resource with this id, or null if not found.
*
* @param id
* The id.
* @return The Resource with this id, or null if not found.
*/
public Entity getResource(String id)
{
Entity entry = null;
// get the user from the db
List xml = null;
String sql = singleStorageSql.getXmlSql(m_resourceTableIdField,
m_resourceTableName);
Object fields[] = new Object[1];
fields[0] = caseId(id);
xml = loadResources(sql, fields);
if (!xml.isEmpty())
{
// create the Resource from the db xml
entry = (Entity) xml.get(0);
}
return entry;
}
public boolean isEmpty()
{
// count
int count = countAllResources();
return (count == 0);
}
public List getAllResources()
{
List all = new Vector();
// read all users from the db
List xml = null;
String sql = singleStorageSql.getXmlSql(m_resourceTableName);
xml = loadResources(sql, null);
// %%% + "order by " + m_resourceTableOrderField + " asc";
// process all result xml into user objects
if (!xml.isEmpty())
{
for (int i = 0; i < xml.size(); i++)
{
Entity entry = (Entity) xml.get(i);
if (entry != null) all.add(entry);
}
}
return all;
}
public List getAllResources(int first, int last)
{
Object[] fields = singleStorageSql.getXmlFields(first, last);
List xml = null;
String sql = singleStorageSql.getXmlSql(m_resourceTableIdField,
m_resourceTableName, first, last);
xml = loadResources(sql, fields);
List rv = new Vector();
// process all result xml into user objects
if (!xml.isEmpty())
{
for (int i = 0; i < xml.size(); i++)
{
Entity entry = (Entity) xml.get(i);
if (entry != null) rv.add(entry);
}
}
return rv;
}
public int countAllResources()
{
// read all count
String sql = singleStorageSql.getNumRowsSql(m_resourceTableName);
List results = m_sql.dbRead(sql, null, new SqlReader()
{
public Object readSqlResultRecord(ResultSet result)
{
try
{
int count = result.getInt(1);
return Integer.valueOf(count);
}
catch (SQLException ignore)
{
return null;
}
}
});
if (results.isEmpty()) return 0;
return ((Integer) results.get(0)).intValue();
}
public int countSelectedResourcesWhere(String sqlWhere)
{
// read all where count
String sql = singleStorageSql.getNumRowsSql(m_resourceTableName, sqlWhere);
List results = m_sql.dbRead(sql, null, new SqlReader()
{
public Object readSqlResultRecord(ResultSet result)
{
try
{
int count = result.getInt(1);
return Integer.valueOf(count);
}
catch (SQLException ignore)
{
return null;
}
}
});
if (results.isEmpty()) return 0;
return ((Integer) results.get(0)).intValue();
}
/**
* Get all Resources where the given field matches the given value.
*
* @param field
* The db field name for the selection.
* @param value
* The value to select.
* @return The list of all Resources that meet the criteria.
*/
public List getAllResourcesWhere(String field, String value)
{
// read all users from the db
String sql = singleStorageSql.getXmlSql(field, m_resourceTableName);
Object[] fields = new Object[1];
fields[0] = value;
// %%% + "order by " + m_resourceTableOrderField + " asc";
return loadResources(sql, fields);
}
/**
* Get all Resources where the given field matches the given value.
*
* @param field
* The db field name for the selection.
* @param value
* The value to select.
* @return The list of all Resources that meet the criteria.
*/
public List getAllResourcesWhere(String selectBy, String selectByValue, String orderBy, int first, int pageSize)
{
// read all users from the db
String sql = singleStorageSql.getXmlWhereLimitSql(selectBy, orderBy, m_resourceTableName, first, pageSize);
Object[] fields = new Object[1];
fields[0] = selectByValue;
// %%% + "order by " + m_resourceTableOrderField + " asc";
return loadResources(sql, fields);
}
protected List loadResources(String sql, Object[] fields)
{
List all = m_sql.dbRead(sql, fields, new SqlReader()
{
public Object readSqlResultRecord(ResultSet result)
{
try
{
// create the Resource from the db xml
return readResource(result.getString(1), result.getBytes(2));
}
catch (SQLException ignore)
{
return null;
}
}
});
return all;
}
public List getAllResourcesWhereLike(String field, String value)
{
String sql = singleStorageSql.getXmlLikeSql(field, m_resourceTableName);
Object[] fields = new Object[1];
fields[0] = value;
// %%% + "order by " + m_resourceTableOrderField + " asc";
return loadResources(sql, fields);
}
/**
* Get selected Resources, filtered by a test on the id field
*
* @param filter
* A filter to select what gets returned.
* @return The list of selected Resources.
*/
public List getSelectedResources(final Filter filter)
{
List all = new Vector();
// read all users from the db
String sql = singleStorageSql.getXmlAndFieldSql(m_resourceTableIdField,
m_resourceTableName);
// %%% + "order by " + m_resourceTableOrderField + " asc";
List xml = m_sql.dbRead(sql, null, new SqlReader()
{
public Object readSqlResultRecord(ResultSet result)
{
try
{
// read the id m_resourceTableIdField
String id = result.getString(1);
// read the xml
String xml = result.getString(2);
byte[] blob = result.getBytes(3);
if (!filter.accept(caseId(id))) return null;
return readResource(xml, blob);
}
catch (SQLException ignore)
{
return null;
}
}
});
// process all result xml into user objects
if (!xml.isEmpty())
{
for (int i = 0; i < xml.size(); i++)
{
Entity entry = (Entity) xml.get(i);
if (entry != null) all.add(entry);
}
}
return all;
}
/**
* Get selected Resources, using a supplied where clause
*
* @param sqlWhere
* The SQL where clause.
* @return The list of selected Resources.
*/
public List getSelectedResourcesWhere(String sqlWhere)
{
List all = new Vector();
// read all users from the db
String sql = singleStorageSql.getXmlWhereSql(m_resourceTableName, sqlWhere);
List xml = loadResources(sql, null);
// process all result xml into user objects
if (!xml.isEmpty())
{
for (int i = 0; i < xml.size(); i++)
{
Entity entry = (Entity) xml.get(i);
if (entry != null) all.add(entry);
}
}
return all;
}
/**
* Add a new Resource with this id.
*
* @param id
* The id.
* @param others
* Other fields for the newResource call
* @return The locked Resource object with this id, or null if the id is in
* use.
*/
public Edit putResource(String id, Object[] others)
{
// create one with just the id, and perhaps some other fields as well
Entity entry = m_user.newResource(null, id, others);
// form the XML and SQL for the insert
Object blob = getBlob(entry);
String statement = null;
if (blob instanceof byte[])
{
statement = // singleStorageSql.
"insert into "
+ m_resourceTableName
+ insertFields(m_resourceTableIdField, m_resourceTableOtherFields,
"BINARY_ENTITY, XML") + " values ( ?, "
+ valuesParams(m_resourceTableOtherFields) + " ? , NULL )";
}
else
{
statement = // singleStorageSql.
"insert into "
+ m_resourceTableName
+ insertFields(m_resourceTableIdField, m_resourceTableOtherFields,
"XML, BINARY_ENTITY ") + " values ( ?, "
+ valuesParams(m_resourceTableOtherFields) + " ?, NULL )";
}
Object[] flds = m_user.storageFields(entry);
if (flds == null) flds = new Object[0];
Object[] fields = new Object[flds.length + 2];
System.arraycopy(flds, 0, fields, 1, flds.length);
fields[0] = caseId(entry.getId());
fields[fields.length - 1] = blob;
// process the insert
boolean ok = m_sql.dbWrite(statement, fields);
// if this failed, assume a key conflict (i.e. id in use)
if (!ok) return null;
// now get a lock on the record for edit
Edit edit = editResource(id);
if (edit == null)
{
M_log.warn("putResource(): didn't get a lock!");
return null;
}
return edit;
}
/**
* store the record in content_resource_delete table along with
* resource_uuid and date
*/
public Edit putDeleteResource(String id, String uuid, String userId, Object[] others)
{
// support for SAK-12874
Entity entry = null;
if (m_storage != null) {
// use the object being deleted
entry = m_storage.getResource(id);
}
if (entry == null) {
// failsafe to the old method
entry = m_user.newResource(null, id, others);
}
// form the XML and SQL for the insert
Object blob = getBlob(entry);
String statement = null;
if (blob instanceof byte[])
{
statement = "insert into "
+ m_resourceTableName
+ insertDeleteFields(m_resourceTableIdField,
m_resourceTableOtherFields, "RESOURCE_UUID", "DELETE_DATE",
"DELETE_USERID", "BINARY_ENTITY, XML") + " values ( ?, "
+ valuesParams(m_resourceTableOtherFields) + " ? ,? ,? ,?, NULL)";
}
else
{
statement = "insert into "
+ m_resourceTableName
+ insertDeleteFields(m_resourceTableIdField,
m_resourceTableOtherFields, "RESOURCE_UUID", "DELETE_DATE",
"DELETE_USERID", "XML, BINARY_ENTITY") + " values ( ?, "
+ valuesParams(m_resourceTableOtherFields) + " ? ,? ,? ,?, NULL)";
}
Object[] flds = m_user.storageFields(entry);
if (flds == null) flds = new Object[0];
Object[] fields = new Object[flds.length + 5];
System.arraycopy(flds, 0, fields, 1, flds.length);
fields[0] = caseId(entry.getId());
// uuid added here
fields[fields.length - 4] = uuid;
// date added here
fields[fields.length - 3] = TimeService.newTime();// .toStringLocalDate();
// userId added here
fields[fields.length - 2] = userId;
fields[fields.length - 1] = blob;
// process the insert
boolean ok = m_sql.dbWrite(statement, fields);
// if this failed, assume a key conflict (i.e. id in use)
if (!ok) return null;
// now get a lock on the record for edit
Edit edit = editResource(id);
if (edit == null)
{
M_log.warn("putResourceDelete(): didn't get a lock!");
return null;
}
return edit;
}
/** Construct the SQL statement */
protected String insertDeleteFields(String before, String[] fields, String uuid,
String date, String userId, String after)
{
StringBuilder buf = new StringBuilder();
buf.append(" (");
buf.append(before);
buf.append(",");
if (fields != null)
{
for (int i = 0; i < fields.length; i++)
{
buf.append(fields[i] + ",");
}
}
buf.append(uuid);
buf.append(",");
buf.append(date);
buf.append(",");
buf.append(userId);
buf.append(",");
buf.append(after);
buf.append(")");
return buf.toString();
}
/** update XML attribute on properties and remove locks */
public void commitDeleteResource(Edit edit, String uuid)
{
// form the SQL statement and the var w/ the XML
Object blob = getBlob(edit);
String statement = null;
if (blob instanceof byte[])
{
statement = "update " + m_resourceTableName + " set "
+ updateSet(m_resourceTableOtherFields)
+ " BINARY_ENTITY = ?, XML = NULL where ( RESOURCE_UUID = ? )";
}
else
{
statement = "update " + m_resourceTableName + " set "
+ updateSet(m_resourceTableOtherFields)
+ " XML = ?, BINARY_ENTITY = NULL where ( RESOURCE_UUID = ? )";
}
Object[] flds = m_user.storageFields(edit);
if (flds == null) flds = new Object[0];
Object[] fields = new Object[flds.length + 2];
System.arraycopy(flds, 0, fields, 0, flds.length);
fields[fields.length - 2] = blob;
fields[fields.length - 1] = uuid;// caseId(edit.getId());
if (m_locksAreInDb)
{
// use this connection that is stored with the lock
Connection lock = (Connection) m_locks.get(edit.getReference());
if (lock == null)
{
M_log.warn("commitResource(): edit not in locks");
return;
}
// update, commit, release the lock's connection
m_sql.dbUpdateCommit(statement, fields, null, lock);
// remove the lock
m_locks.remove(edit.getReference());
}
else if (m_locksAreInTable)
{
// process the update
m_sql.dbWrite(statement, fields);
// remove the lock
statement = singleStorageSql.getDeleteLocksSql();
// collect the fields
Object lockFields[] = new Object[2];
lockFields[0] = m_resourceTableName;
lockFields[1] = internalRecordId(caseId(edit.getId()));
boolean ok = m_sql.dbWrite(statement, lockFields);
if (!ok)
{
M_log.warn("commit: missing lock for table: " + lockFields[0] + " key: "
+ lockFields[1]);
}
}
else
{
// just process the update
m_sql.dbWrite(statement, fields);
// remove the lock
m_locks.remove(edit.getReference());
}
}
/**
* Get a lock on the Resource with this id, or null if a lock cannot be
* gotten.
*
* @param id
* The user id.
* @return The locked Resource with this id, or null if this records cannot
* be locked.
*/
public Edit editResource(String id)
{
Edit edit = null;
if (m_locksAreInDb)
{
if ("oracle".equals(m_sql.getVendor()))
{
final List<Entity> l = new ArrayList<Entity>();
Connection lock = null;
if (m_user instanceof EntityReaderHandler)
{
// read the record and get a lock on it (non blocking)
String statement = "select XML from " + m_resourceTableName
+ " where ( " + m_resourceTableIdField + " = '"
+ StorageUtils.escapeSql(caseId(id)) + "' )"
+ " for update nowait";
lock = m_sql.dbReadLock(statement, new SqlReader()
{
public Object readSqlResultRecord(ResultSet result)
{
try
{
l.add(readResource(result.getString(1), result
.getBytes(2)));
}
catch (SQLException e)
{
M_log.warn("Failed to retrieve record ", e);
}
return null;
}
});
}
else
{
// read the record and get a lock on it (non blocking)
String statement = "select BENTRY, XML from " + m_resourceTableName
+ " where ( " + m_resourceTableIdField + " = '"
+ StorageUtils.escapeSql(caseId(id)) + "' )"
+ " for update nowait";
lock = m_sql.dbReadLock(statement, new SqlReader()
{
public Object readSqlResultRecord(ResultSet result)
{
try
{
l.add(readResource(result.getString(1), result
.getBytes(2)));
}
catch (SQLException e)
{
M_log.warn("Failed to retrieve record ", e);
}
return null;
}
});
}
// for missing or already locked...
if ((lock == null) || (l.size() == 0)) return null;
// make first a Resource, then an Edit
Entity entry = l.get(0);
edit = m_user.newResourceEdit(null, entry);
// store the lock for this object
m_locks.put(entry.getReference(), lock);
}
else
{
throw new UnsupportedOperationException(
"Record locking only available when configured with Oracle database");
}
}
// if the locks are in a separate table in the db
else if (m_locksAreInTable)
{
// read the record - fail if not there
Entity entry = getResource(id);
if (entry == null) return null;
// write a lock to the lock table - if we can do it, we get the lock
String statement = singleStorageSql.getInsertLocks();
// we need session id and user id
String sessionId = UsageSessionService.getSessionId();
if (sessionId == null)
{
sessionId = "";
}
// collect the fields
Object fields[] = new Object[4];
fields[0] = m_resourceTableName;
fields[1] = internalRecordId(caseId(id));
fields[2] = TimeService.newTime();
fields[3] = sessionId;
// add the lock - if fails, someone else has the lock
boolean ok = m_sql.dbWriteFailQuiet(null, statement, fields);
if (!ok)
{
return null;
}
// we got the lock! - make the edit from the Resource
edit = m_user.newResourceEdit(null, entry);
}
// otherwise, get the lock locally
else
{
// get the entry, and check for existence
Entity entry = getResource(id);
if (entry == null) return null;
// we only sync this getting - someone may release a lock out of
// sync
synchronized (m_locks)
{
// if already locked
if (m_locks.containsKey(entry.getReference())) return null;
// make the edit from the Resource
edit = m_user.newResourceEdit(null, entry);
// store the edit in the locks by reference
m_locks.put(entry.getReference(), edit);
}
}
return edit;
}
/**
* Commit the changes and release the lock.
*
* @param user
* The Edit to commit.
*/
public void commitResource(Edit edit)
{
// form the SQL statement and the var w/ the XML
Object blob = getBlob(edit);
String statement = null;
if (blob instanceof byte[])
{
statement = "update " + m_resourceTableName + " set "
+ updateSet(m_resourceTableOtherFields) + " BINARY_ENTITY = ?, XML = NULL where ( "
+ m_resourceTableIdField + " = ? )";
}
else
{
statement = "update " + m_resourceTableName + " set "
+ updateSet(m_resourceTableOtherFields) + " XML = ?, BINARY_ENTITY = NULL where ( "
+ m_resourceTableIdField + " = ? )";
}
Object[] flds = m_user.storageFields(edit);
if (flds == null) flds = new Object[0];
Object[] fields = new Object[flds.length + 2];
System.arraycopy(flds, 0, fields, 0, flds.length);
fields[fields.length - 2] = blob;
fields[fields.length - 1] = caseId(edit.getId());
// singleStorageSql.getUpdateXml(m_resourceTableIdField,
// m_resourceTableOtherFields, m_resourceTableName);
if (m_locksAreInDb)
{
// use this connection that is stored with the lock
Connection lock = (Connection) m_locks.get(edit.getReference());
if (lock == null)
{
M_log.warn("commitResource(): edit not in locks");
return;
}
// update, commit, release the lock's connection
m_sql.dbUpdateCommit(statement, fields, null, lock);
// remove the lock
m_locks.remove(edit.getReference());
}
else if (m_locksAreInTable)
{
// process the update
m_sql.dbWrite(statement, fields);
// remove the lock
statement = singleStorageSql.getDeleteLocksSql();
// collect the fields
Object lockFields[] = new Object[2];
lockFields[0] = m_resourceTableName;
lockFields[1] = internalRecordId(caseId(edit.getId()));
boolean ok = m_sql.dbWrite(statement, lockFields);
if (!ok)
{
M_log.warn("commit: missing lock for table: " + lockFields[0] + " key: "
+ lockFields[1]);
}
}
else
{
// just process the update
m_sql.dbWrite(statement, fields);
// remove the lock
m_locks.remove(edit.getReference());
}
}
/**
* Cancel the changes and release the lock.
*
* @param user
* The Edit to cancel.
*/
public void cancelResource(Edit edit)
{
if (m_locksAreInDb)
{
// use this connection that is stored with the lock
Connection lock = (Connection) m_locks.get(edit.getReference());
if (lock == null)
{
M_log.warn("cancelResource(): edit not in locks");
return;
}
// rollback and release the lock's connection
m_sql.dbCancel(lock);
// release the lock
m_locks.remove(edit.getReference());
}
else if (m_locksAreInTable)
{
// remove the lock
String statement = singleStorageSql.getDeleteLocksSql();
// collect the fields
Object lockFields[] = new Object[2];
lockFields[0] = m_resourceTableName;
lockFields[1] = internalRecordId(caseId(edit.getId()));
boolean ok = m_sql.dbWrite(statement, lockFields);
if (!ok)
{
M_log.warn("cancel: missing lock for table: " + lockFields[0] + " key: "
+ lockFields[1]);
}
}
else
{
// release the lock
m_locks.remove(edit.getReference());
}
}
/**
* Remove this (locked) Resource.
*
* @param user
* The Edit to remove.
*/
public void removeResource(Edit edit)
{
// form the SQL delete statement
String statement = singleStorageSql.getDeleteSql(m_resourceTableIdField,
m_resourceTableName);
Object fields[] = new Object[1];
fields[0] = caseId(edit.getId());
if (m_locksAreInDb)
{
// use this connection that is stored with the lock
Connection lock = (Connection) m_locks.get(edit.getReference());
if (lock == null)
{
M_log.warn("removeResource(): edit not in locks");
return;
}
// process the delete statement, commit, and release the lock's
// connection
m_sql.dbUpdateCommit(statement, fields, null, lock);
// release the lock
m_locks.remove(edit.getReference());
}
else if (m_locksAreInTable)
{
// process the delete statement
m_sql.dbWrite(statement, fields);
// remove the lock
statement = singleStorageSql.getDeleteLocksSql();
// collect the fields
Object lockFields[] = new Object[2];
lockFields[0] = m_resourceTableName;
lockFields[1] = internalRecordId(caseId(edit.getId()));
boolean ok = m_sql.dbWrite(statement, lockFields);
if (!ok)
{
M_log.warn("remove: missing lock for table: " + lockFields[0] + " key: "
+ lockFields[1]);
}
}
else
{
// process the delete statement
m_sql.dbWrite(statement, fields);
// release the lock
m_locks.remove(edit.getReference());
}
}
/**
* Form a string of n question marks with commas, for sql value statements,
* one for each item in the values array, or an empty string if null.
*
* @param values
* The values to be inserted into the sql statement.
* @return A sql statement fragment for the values part of an insert, one
* for each value in the array.
*/
protected String valuesParams(String[] fields)
{
if ((fields == null) || (fields.length == 0)) return "";
StringBuilder buf = new StringBuilder();
for (int i = 0; i < fields.length; i++)
{
buf.append(" ?,");
}
return buf.toString();
}
/**
* Form a string of n name=?, for sql update set statements, one for each
* item in the values array, or an empty string if null.
*
* @param values
* The values to be inserted into the sql statement.
* @return A sql statement fragment for the values part of an insert, one
* for each value in the array.
*/
protected String updateSet(String[] fields)
{
if ((fields == null) || (fields.length == 0)) return "";
StringBuilder buf = new StringBuilder();
for (int i = 0; i < fields.length; i++)
{
buf.append(fields[i] + " = ?,");
}
return buf.toString();
}
/**
* Form a string of (field, field, field), for sql insert statements, one
* for each item in the fields array, plus one before, and one after.
*
* @param before
* The first field name.
* @param values
* The extra field names, in the middle.
* @param after
* The last field name.
* @return A sql statement fragment for the insert fields.
*/
protected String insertFields(String before, String[] fields, String after)
{
StringBuilder buf = new StringBuilder();
buf.append(" (");
buf.append(before);
buf.append(",");
if (fields != null)
{
for (int i = 0; i < fields.length; i++)
{
buf.append(fields[i] + ",");
}
}
buf.append(after);
buf.append(")");
return buf.toString();
}
/**
* Fix the case of resource ids to support case insensitive ids if enabled
*
* @param The
* id to fix.
* @return The id, case modified as needed.
*/
protected String caseId(String id)
{
if (m_caseInsensitive)
{
return id.toLowerCase();
}
return id;
}
/**
* Enable / disable case insensitive ids.
*
* @param setting
* true to set case insensitivity, false to set case sensitivity.
*/
protected void setCaseInsensitivity(boolean setting)
{
m_caseInsensitive = setting;
}
/**
* Return a record ID to use internally in the database. This is needed for
* databases (MySQL) that have limits on key lengths. The hash code ensures
* that the record ID will be unique, even if the DB only considers a prefix
* of a very long record ID.
*
* @param recordId
* @return The record ID to use internally in the database
*/
private String internalRecordId(String recordId)
{
if ("mysql".equals(m_sql.getVendor()))
{
if (recordId == null) recordId = "null";
return recordId.hashCode() + " - " + recordId;
}
else
// oracle, hsqldb
{
return recordId;
}
}
/**
* @param entry
* @return
*/
private Object getBlob(Entity entry)
{
Runtime r = Runtime.getRuntime();
long ms = r.freeMemory();
long start = System.currentTimeMillis();
try
{
EntityReader er_user = (EntityReader) m_user;
try
{
EntityReaderHandler erHandler = er_user.getHandler();
return erHandler.serialize(entry);
}
catch (EntityParseException ep)
{
M_log.warn("Unable to Serialize Entity, falling back to XML "
+ entry.getId(), ep);
}
return null;
}
finally
{
long t = System.currentTimeMillis() - start;
long me = r.freeMemory();
long md = ms - me;
if (md >= 0)
{
mtotal += md;
}
else
{
if (ntime != 0)
{
mtotal += (mtotal / ntime);
}
}
ttotal += t;
ntime++;
if (ntime % 100 == 0)
{
double a = (1.0 * ttotal) / (1.0 * ntime);
double m = (1.0 * mtotal) / (1.0 * ntime);
M_log.debug("Average Serialization now " + (a) + "ms " + m + " bytes");
}
}
}
}