/**********************************************************************
Copyright (c) 2007 Andy Jefferson and others. All rights reserved.
Licensed 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.
Contributors:
...
**********************************************************************/
package org.datanucleus.store.rdbms.scostore;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.util.NoSuchElementException;
import org.datanucleus.ClassLoaderResolver;
import org.datanucleus.Transaction;
import org.datanucleus.exceptions.NucleusDataStoreException;
import org.datanucleus.metadata.AbstractMemberMetaData;
import org.datanucleus.metadata.DiscriminatorStrategy;
import org.datanucleus.metadata.MapMetaData.MapType;
import org.datanucleus.query.expression.Expression;
import org.datanucleus.store.ExecutionContext;
import org.datanucleus.store.ObjectProvider;
import org.datanucleus.store.connection.ManagedConnection;
import org.datanucleus.store.mapped.StatementClassMapping;
import org.datanucleus.store.mapped.StatementMappingIndex;
import org.datanucleus.store.mapped.StatementParameterMapping;
import org.datanucleus.store.mapped.mapping.EmbeddedKeyPCMapping;
import org.datanucleus.store.mapped.mapping.MappingHelper;
import org.datanucleus.store.mapped.mapping.ReferenceMapping;
import org.datanucleus.store.mapped.mapping.SerialisedMapping;
import org.datanucleus.store.mapped.mapping.SerialisedPCMapping;
import org.datanucleus.store.mapped.mapping.SerialisedReferenceMapping;
import org.datanucleus.store.mapped.scostore.FKMapStore;
import org.datanucleus.store.mapped.scostore.MapEntrySetStore;
import org.datanucleus.store.mapped.scostore.MapKeySetStore;
import org.datanucleus.store.mapped.scostore.MapValueSetStore;
import org.datanucleus.store.query.ResultObjectFactory;
import org.datanucleus.store.rdbms.JDBCUtils;
import org.datanucleus.store.rdbms.RDBMSStoreManager;
import org.datanucleus.store.rdbms.SQLController;
import org.datanucleus.store.rdbms.mapping.RDBMSMapping;
import org.datanucleus.store.rdbms.sql.DiscriminatorStatementGenerator;
import org.datanucleus.store.rdbms.sql.SQLStatement;
import org.datanucleus.store.rdbms.sql.SQLStatementHelper;
import org.datanucleus.store.rdbms.sql.SQLTable;
import org.datanucleus.store.rdbms.sql.StatementGenerator;
import org.datanucleus.store.rdbms.sql.UnionStatementGenerator;
import org.datanucleus.store.rdbms.sql.expression.SQLExpression;
import org.datanucleus.store.rdbms.sql.expression.SQLExpressionFactory;
import org.datanucleus.store.rdbms.table.JoinTable;
import org.datanucleus.util.ClassUtils;
/**
* RDBMS-specific implementation of an {@link FKMapStore}.
*/
public class RDBMSFKMapStore extends FKMapStore
{
/** Statement for updating a foreign key for the map. */
private String updateFkStmt;
/** JDBC statement to use for retrieving the value of the map for a key (locking). */
private String getStmtLocked = null;
/** JDBC statement to use for retrieving the value of the map for a key (not locking). */
private String getStmtUnlocked = null;
private StatementClassMapping getMappingDef = null;
private StatementParameterMapping getMappingParams = null;
/**
* Constructor for the backing store for an FK Map for RDBMS.
* @param mmd Field Meta-Data for the Map field.
* @param storeMgr The Store Manager we are using.
* @param clr The ClassLoaderResolver
*/
public RDBMSFKMapStore(AbstractMemberMetaData mmd, RDBMSStoreManager storeMgr, ClassLoaderResolver clr)
{
super(mmd, storeMgr, clr, new RDBMSAbstractMapStoreSpecialization(LOCALISER, clr, storeMgr));
specialization.initialise(this);
}
protected void initialise()
{
updateFkStmt = getUpdateFkStmt();
}
private RDBMSStoreManager getStoreMgr()
{
return (RDBMSStoreManager) storeMgr;
}
/**
* Generate statement for updating a Foreign Key from key/value to owner in an inverse 1-N.
* <PRE>
* UPDATE MAPTABLE SET FK_COL_1 = ?, FK_COL_2 = ?
* WHERE ELEMENT_ID = ?
* </PRE>
* @return Statement for updating the FK in an inverse 1-N
*/
private String getUpdateFkStmt()
{
StringBuffer stmt = new StringBuffer();
stmt.append("UPDATE ");
stmt.append(getMapTable().toString());
stmt.append(" SET ");
for (int i=0; i<ownerMapping.getNumberOfDatastoreMappings(); i++)
{
if (i > 0)
{
stmt.append(",");
}
stmt.append(ownerMapping.getDatastoreMapping(i).getDatastoreField().getIdentifier().toString());
stmt.append(" = ");
stmt.append(((RDBMSMapping)ownerMapping.getDatastoreMapping(i)).getUpdateInputParameter());
}
stmt.append(" WHERE ");
if (keyFieldNumber >= 0)
{
for (int i=0; i<valueMapping.getNumberOfDatastoreMappings(); i++)
{
if (i > 0)
{
stmt.append(" AND ");
}
stmt.append(valueMapping.getDatastoreMapping(i).getDatastoreField().getIdentifier().toString());
stmt.append(" = ");
stmt.append(((RDBMSMapping)valueMapping.getDatastoreMapping(i)).getUpdateInputParameter());
}
}
else
{
for (int i=0; i<keyMapping.getNumberOfDatastoreMappings(); i++)
{
if (i > 0)
{
stmt.append(" AND ");
}
stmt.append(keyMapping.getDatastoreMapping(i).getDatastoreField().getIdentifier().toString());
stmt.append(" = ");
stmt.append(((RDBMSMapping)keyMapping.getDatastoreMapping(i)).getUpdateInputParameter());
}
}
return stmt.toString();
}
protected boolean updateValueFkInternal(ObjectProvider sm, Object value, Object owner)
{
boolean retval;
ExecutionContext ec = sm.getExecutionContext();
try
{
ManagedConnection mconn = getStoreMgr().getConnection(ec);
SQLController sqlControl = getStoreMgr().getSQLController();
try
{
PreparedStatement ps = sqlControl.getStatementForUpdate(mconn, updateFkStmt, false);
try
{
int jdbcPosition = 1;
if (owner == null)
{
if (ownerMemberMetaData != null)
{
ownerMapping.setObject(ec, ps, MappingHelper.getMappingIndices(1,ownerMapping), null,
sm, ownerMemberMetaData.getAbsoluteFieldNumber());
}
else
{
ownerMapping.setObject(ec, ps, MappingHelper.getMappingIndices(1,ownerMapping), null);
}
jdbcPosition += ownerMapping.getNumberOfDatastoreMappings();
}
else
{
jdbcPosition = BackingStoreHelper.populateOwnerInStatement(sm, ec, ps, jdbcPosition, this);
}
jdbcPosition = BackingStoreHelper.populateValueInStatement(ec, ps, value, jdbcPosition, valueMapping);
sqlControl.executeStatementUpdate(mconn, updateFkStmt, ps, true);
retval = true;
}
finally
{
sqlControl.closeStatement(mconn, ps);
}
}
finally
{
mconn.release();
}
}
catch (SQLException e)
{
throw new NucleusDataStoreException(LOCALISER.msg("056027",updateFkStmt),e);
}
return retval;
}
protected boolean updateKeyFkInternal(ObjectProvider sm, Object key, Object owner)
{
boolean retval;
ExecutionContext ec = sm.getExecutionContext();
try
{
ManagedConnection mconn = getStoreMgr().getConnection(ec);
SQLController sqlControl = getStoreMgr().getSQLController();
try
{
PreparedStatement ps = sqlControl.getStatementForUpdate(mconn, updateFkStmt, false);
try
{
int jdbcPosition = 1;
if (owner == null)
{
if (ownerMemberMetaData != null)
{
ownerMapping.setObject(ec, ps, MappingHelper.getMappingIndices(1,ownerMapping), null,
sm, ownerMemberMetaData.getAbsoluteFieldNumber());
}
else
{
ownerMapping.setObject(ec, ps, MappingHelper.getMappingIndices(1,ownerMapping), null);
}
jdbcPosition += ownerMapping.getNumberOfDatastoreMappings();
}
else
{
jdbcPosition = BackingStoreHelper.populateOwnerInStatement(sm, ec, ps, jdbcPosition, this);
}
jdbcPosition = BackingStoreHelper.populateKeyInStatement(ec, ps, key, jdbcPosition, keyMapping);
sqlControl.executeStatementUpdate(mconn, updateFkStmt, ps, true);
retval = true;
}
finally
{
sqlControl.closeStatement(mconn, ps);
}
}
finally
{
mconn.release();
}
}
catch (SQLException e)
{
throw new NucleusDataStoreException(LOCALISER.msg("056027",updateFkStmt),e);
}
return retval;
}
/**
* Method to retrieve a value from the Map given the key.
* @param ownerSM State Manager for the owner of the map.
* @param key The key to retrieve the value for.
* @return The value for this key
* @throws NoSuchElementException if the key was not found
*/
protected Object getValue(ObjectProvider ownerSM, Object key)
throws NoSuchElementException
{
if (!validateKeyForReading(ownerSM, key))
{
return null;
}
ExecutionContext ec = ownerSM.getExecutionContext();
if (getStmtLocked == null)
{
synchronized (this) // Make sure this completes in case another thread needs the same info
{
// Generate the statement, and statement mapping/parameter information
SQLStatement sqlStmt = getSQLStatementForGet(ownerSM);
getStmtUnlocked = sqlStmt.getSelectStatement().toSQL();
sqlStmt.addExtension("lock-for-update", true);
getStmtLocked = sqlStmt.getSelectStatement().toSQL();
}
}
Transaction tx = ec.getTransaction();
String stmt = (tx.lockReadObjects() ? getStmtLocked : getStmtUnlocked);
Object value = null;
try
{
RDBMSStoreManager storeMgr = (RDBMSStoreManager)this.storeMgr;
ManagedConnection mconn = storeMgr.getConnection(ec);
SQLController sqlControl = storeMgr.getSQLController();
try
{
// Create the statement and supply owner/key params
PreparedStatement ps = sqlControl.getStatementForQuery(mconn, stmt);
StatementMappingIndex ownerIdx = getMappingParams.getMappingForParameter("owner");
int numParams = ownerIdx.getNumberOfParameterOccurrences();
for (int paramInstance=0;paramInstance<numParams;paramInstance++)
{
ownerIdx.getMapping().setObject(ec, ps,
ownerIdx.getParameterPositionsForOccurrence(paramInstance), ownerSM.getObject());
}
StatementMappingIndex keyIdx = getMappingParams.getMappingForParameter("key");
numParams = keyIdx.getNumberOfParameterOccurrences();
for (int paramInstance=0;paramInstance<numParams;paramInstance++)
{
keyIdx.getMapping().setObject(ec, ps,
keyIdx.getParameterPositionsForOccurrence(paramInstance), key);
}
try
{
ResultSet rs = sqlControl.executeStatementQuery(mconn, stmt, ps);
try
{
boolean found = rs.next();
if (!found)
{
throw new NoSuchElementException();
}
if (valuesAreEmbedded || valuesAreSerialised)
{
int param[] = new int[valueMapping.getNumberOfDatastoreMappings()];
for (int i = 0; i < param.length; ++i)
{
param[i] = i + 1;
}
if (valueMapping instanceof SerialisedPCMapping ||
valueMapping instanceof SerialisedReferenceMapping ||
valueMapping instanceof EmbeddedKeyPCMapping)
{
// Value = Serialised
int ownerFieldNumber = ((JoinTable)mapTable).getOwnerMemberMetaData().getAbsoluteFieldNumber();
value = valueMapping.getObject(ec, rs, param, ownerSM, ownerFieldNumber);
}
else
{
// Value = Non-PC
value = valueMapping.getObject(ec, rs, param);
}
}
else if (valueMapping instanceof ReferenceMapping)
{
// Value = Reference (Interface/Object)
int param[] = new int[valueMapping.getNumberOfDatastoreMappings()];
for (int i = 0; i < param.length; ++i)
{
param[i] = i + 1;
}
value = valueMapping.getObject(ec, rs, param);
}
else
{
// Value = PC
ResultObjectFactory rof = storeMgr.newResultObjectFactory(vmd,
getMappingDef, false, null, clr.classForName(valueType));
value = rof.getObject(ec, rs);
}
JDBCUtils.logWarnings(rs);
}
finally
{
rs.close();
}
}
finally
{
sqlControl.closeStatement(mconn, ps);
}
}
finally
{
mconn.release();
}
}
catch (SQLException e)
{
throw new NucleusDataStoreException(LOCALISER.msg("056014", stmt), e);
}
return value;
}
/**
* Method to return an SQLStatement for retrieving the value for a key.
* Selects the join table and optionally joins to the value table if it has its own table.
* @param ownerSM StateManager for the owning object
* @return The SQLStatement
*/
protected SQLStatement getSQLStatementForGet(ObjectProvider ownerSM)
{
SQLStatement sqlStmt = null;
final ClassLoaderResolver clr = ownerSM.getExecutionContext().getClassLoaderResolver();
final Class valueCls = clr.classForName(this.valueType);
RDBMSStoreManager storeMgr = (RDBMSStoreManager)this.storeMgr;
if (ownerMemberMetaData.getMap().getMapType() == MapType.MAP_TYPE_KEY_IN_VALUE)
{
getMappingDef = new StatementClassMapping();
if (valueTable.getDiscriminatorMetaData() != null &&
valueTable.getDiscriminatorMetaData().getStrategy() != DiscriminatorStrategy.NONE)
{
// Value class has discriminator
if (ClassUtils.isReferenceType(valueCls))
{
String[] clsNames =
storeMgr.getNucleusContext().getMetaDataManager().getClassesImplementingInterface(valueType, clr);
Class[] cls = new Class[clsNames.length];
for (int i=0; i<clsNames.length; i++)
{
cls[i] = clr.classForName(clsNames[i]);
}
sqlStmt = new DiscriminatorStatementGenerator(storeMgr, clr, cls, true, null, null).getStatement();
}
else
{
sqlStmt = new DiscriminatorStatementGenerator(storeMgr, clr, valueCls, true, null, null).getStatement();
}
iterateUsingDiscriminator = true;
}
else
{
// Use union to resolve any subclasses of value
UnionStatementGenerator stmtGen = new UnionStatementGenerator(storeMgr, clr, valueCls, true, null, null);
stmtGen.setOption(StatementGenerator.OPTION_SELECT_NUCLEUS_TYPE);
getMappingDef.setNucleusTypeColumnName(UnionStatementGenerator.NUC_TYPE_COLUMN);
sqlStmt = stmtGen.getStatement();
}
// Select the value field(s)
SQLStatementHelper.selectFetchPlanOfSourceClassInStatement(sqlStmt, getMappingDef,
ownerSM.getExecutionContext().getFetchPlan(), sqlStmt.getPrimaryTable(), vmd, 0);
}
else
{
// Value is in key table
sqlStmt = new SQLStatement(storeMgr, mapTable, null, null);
sqlStmt.setClassLoaderResolver(clr);
if (vmd != null)
{
// Left outer join to value table (so we allow for null values)
SQLTable valueSqlTbl = sqlStmt.leftOuterJoin(sqlStmt.getPrimaryTable(), valueMapping,
valueTable, null, valueTable.getIdMapping(), null, null);
// Select the value field(s)
SQLStatementHelper.selectFetchPlanOfSourceClassInStatement(sqlStmt, getMappingDef,
ownerSM.getExecutionContext().getFetchPlan(), valueSqlTbl, vmd, 0);
}
else
{
sqlStmt.select(sqlStmt.getPrimaryTable(), valueMapping, null);
}
}
// Apply condition on owner field to filter by owner
SQLExpressionFactory exprFactory = storeMgr.getSQLExpressionFactory();
SQLTable ownerSqlTbl =
SQLStatementHelper.getSQLTableForMappingOfTable(sqlStmt, sqlStmt.getPrimaryTable(), ownerMapping);
SQLExpression ownerExpr = exprFactory.newExpression(sqlStmt, ownerSqlTbl, ownerMapping);
SQLExpression ownerVal = exprFactory.newLiteralParameter(sqlStmt, ownerMapping, null, "OWNER");
sqlStmt.whereAnd(ownerExpr.eq(ownerVal), true);
// Apply condition on key
if (keyMapping instanceof SerialisedMapping)
{
// if the keyMapping contains a BLOB column (or any other column not supported by the database
// as primary key), uses like instead of the operator OP_EQ (=)
// in future do not check if the keyMapping is of ObjectMapping, but use the database
// adapter to check the data types not supported as primary key
// if object mapping (BLOB) use like
SQLExpression keyExpr = exprFactory.newExpression(sqlStmt, sqlStmt.getPrimaryTable(), keyMapping);
SQLExpression keyVal = exprFactory.newLiteralParameter(sqlStmt, keyMapping, null, "KEY");
sqlStmt.whereAnd(new org.datanucleus.store.rdbms.sql.expression.BooleanExpression(keyExpr,
Expression.OP_LIKE, keyVal), true);
}
else
{
SQLExpression keyExpr = exprFactory.newExpression(sqlStmt, sqlStmt.getPrimaryTable(), keyMapping);
SQLExpression keyVal = exprFactory.newLiteralParameter(sqlStmt, keyMapping, null, "KEY");
sqlStmt.whereAnd(keyExpr.eq(keyVal), true);
}
// Input parameter(s) - owner, key
int inputParamNum = 1;
StatementMappingIndex ownerIdx = new StatementMappingIndex(ownerMapping);
StatementMappingIndex keyIdx = new StatementMappingIndex(keyMapping);
if (sqlStmt.getNumberOfUnions() > 0)
{
// Add parameter occurrence for each union of statement
for (int j=0;j<sqlStmt.getNumberOfUnions()+1;j++)
{
int[] ownerPositions = new int[ownerMapping.getNumberOfDatastoreMappings()];
for (int k=0;k<ownerPositions.length;k++)
{
ownerPositions[k] = inputParamNum++;
}
ownerIdx.addParameterOccurrence(ownerPositions);
int[] keyPositions = new int[keyMapping.getNumberOfDatastoreMappings()];
for (int k=0;k<keyPositions.length;k++)
{
keyPositions[k] = inputParamNum++;
}
keyIdx.addParameterOccurrence(keyPositions);
}
}
else
{
int[] ownerPositions = new int[ownerMapping.getNumberOfDatastoreMappings()];
for (int k=0;k<ownerPositions.length;k++)
{
ownerPositions[k] = inputParamNum++;
}
ownerIdx.addParameterOccurrence(ownerPositions);
int[] keyPositions = new int[keyMapping.getNumberOfDatastoreMappings()];
for (int k=0;k<keyPositions.length;k++)
{
keyPositions[k] = inputParamNum++;
}
keyIdx.addParameterOccurrence(keyPositions);
}
getMappingParams = new StatementParameterMapping();
getMappingParams.addMappingForParameter("owner", ownerIdx);
getMappingParams.addMappingForParameter("key", keyIdx);
return sqlStmt;
}
protected MapKeySetStore newMapKeySetStore()
{
return new RDBMSMapKeySetStore(valueTable, this, clr, ownerMapping, keyMapping, ownerMemberMetaData);
}
protected MapValueSetStore newMapValueSetStore()
{
return new RDBMSMapValueSetStore(valueTable, this, clr, ownerMapping, valueMapping, ownerMemberMetaData);
}
protected MapEntrySetStore newMapEntrySetStore()
{
return new RDBMSMapEntrySetStore(valueTable, this, clr, ownerMapping, keyMapping, valueMapping, ownerMemberMetaData);
}
}