/**
* PUBLIC: Return a session broker that behaves as a client session broker. An acquire session
* broker is done under the covers on each session inside the session broker, and a new broker is
* returned.
*
* <p>NOTE: when finished with the client broker, it should be releases. See
* releaseClientSessionBroker.
*/
public SessionBroker acquireClientSessionBroker() {
log(SessionLog.FINER, SessionLog.CONNECTION, "acquire_client_session_broker");
SessionBroker clientBroker = copySessionBroker();
clientBroker.parent = this;
clientBroker
.getIdentityMapAccessorInstance()
.setIdentityMapManager(getIdentityMapAccessorInstance().getIdentityMapManager());
clientBroker.commitManager = getCommitManager();
clientBroker.commandManager = getCommandManager();
clientBroker.externalTransactionController = getExternalTransactionController();
clientBroker.setServerPlatform(getServerPlatform());
String sessionName;
AbstractSession serverSession;
Iterator names = this.getSessionsByName().keySet().iterator();
while (names.hasNext()) {
sessionName = (String) names.next();
serverSession = getSessionForName(sessionName);
if (serverSession instanceof org.eclipse.persistence.sessions.server.ServerSession) {
if (serverSession.getProject().hasIsolatedClasses()) {
throw ValidationException.isolatedDataNotSupportedInSessionBroker(sessionName);
}
clientBroker.internalRegisterSession(
sessionName,
((org.eclipse.persistence.sessions.server.ServerSession) serverSession)
.acquireClientSession());
} else {
throw ValidationException.cannotAcquireClientSessionFromSession();
}
}
clientBroker.initializeSequencing();
return clientBroker;
}
/**
* INTERNAL: Convert all the class-name-based settings in this InheritancePolicy to actual
* class-based settings. This method is used when converting a project that has been built with
* class names to a project with classes. It will also convert referenced classes to the versions
* of the classes from the classLoader.
*/
public void convertClassNamesToClasses(ClassLoader classLoader) {
Vector newParentInterfaces = new Vector();
for (Iterator iterator = getParentInterfaceNames().iterator(); iterator.hasNext(); ) {
String interfaceName = (String) iterator.next();
Class interfaceClass = null;
try {
if (PrivilegedAccessHelper.shouldUsePrivilegedAccess()) {
try {
interfaceClass =
(Class)
AccessController.doPrivileged(
new PrivilegedClassForName(interfaceName, true, classLoader));
} catch (PrivilegedActionException exception) {
throw ValidationException.classNotFoundWhileConvertingClassNames(
interfaceName, exception.getException());
}
} else {
interfaceClass =
org.eclipse.persistence.internal.security.PrivilegedAccessHelper.getClassForName(
interfaceName, true, classLoader);
}
} catch (ClassNotFoundException exc) {
throw ValidationException.classNotFoundWhileConvertingClassNames(interfaceName, exc);
}
newParentInterfaces.add(interfaceClass);
}
this.parentInterfaces = newParentInterfaces;
}
/**
* INTERNAL: Convert all the class-name-based settings in this mapping to actual class-based
* settings. This method is used when converting a project that has been built with class names to
* a project with classes.
*/
@Override
public void convertClassNamesToClasses(ClassLoader classLoader) {
super.convertClassNamesToClasses(classLoader);
Iterator iterator = getTypeIndicatorNameTranslation().entrySet().iterator();
this.typeIndicatorTranslation = new HashMap();
while (iterator.hasNext()) {
Map.Entry entry = (Map.Entry) iterator.next();
String referenceClassName = (String) entry.getKey();
Object indicator = entry.getValue();
Class referenceClass = null;
try {
if (PrivilegedAccessHelper.shouldUsePrivilegedAccess()) {
try {
referenceClass =
(Class)
AccessController.doPrivileged(
new PrivilegedClassForName(referenceClassName, true, classLoader));
} catch (PrivilegedActionException exception) {
throw ValidationException.classNotFoundWhileConvertingClassNames(
referenceClassName, exception.getException());
}
} else {
referenceClass =
PrivilegedAccessHelper.getClassForName(referenceClassName, true, classLoader);
}
} catch (ClassNotFoundException exception) {
throw ValidationException.classNotFoundWhileConvertingClassNames(
referenceClassName, exception);
}
addClassIndicator(referenceClass, indicator);
}
}
/**
* PUBLIC: Connect to the database using the predefined login. This connects all of the child
* sessions and expects that they are in a valid state to be connected.
*/
public void login(String userName, String password) throws DatabaseException {
// Bug#3440544 Check if logged in already to stop the attempt to login more than once
if (isLoggedIn) {
throw ValidationException.alreadyLoggedIn(this.getName());
} else {
if (this.eventManager != null) {
this.eventManager.preLogin(this);
}
// Bug 3848021 - ensure the external transaction controller is initialized
if (!isConnected()) {
getServerPlatform().initializeExternalTransactionController();
}
// Connection all sessions and initialize
for (Iterator sessionEnum = getSessionsByName().values().iterator();
sessionEnum.hasNext(); ) {
DatabaseSessionImpl session = (DatabaseSessionImpl) sessionEnum.next();
if (session.hasEventManager()) {
session.getEventManager().preLogin(session);
}
session.getDatasourceLogin().setUserName(userName);
session.getDatasourceLogin().setPassword(password);
if (!session.isConnected()) {
session.connect();
}
}
initializeDescriptors();
this.isLoggedIn = true;
}
}
/** INTERNAL: Return the session by name. */
public AbstractSession getSessionForName(String name) throws ValidationException {
AbstractSession sessionByName = getSessionsByName().get(name);
if (sessionByName == null) {
throw ValidationException.noSessionRegisteredForName(name);
}
return sessionByName;
}
/** INTERNAL: Return the session to be used for the class. */
public AbstractSession getSessionForClass(Class domainClass) throws ValidationException {
if (domainClass == null) {
// CR2114; we don't have a session name. Return us.
return this;
}
String sessionName = getSessionNamesByClass().get(domainClass);
if (sessionName == null) {
throw ValidationException.noSessionRegisteredForClass(domainClass);
}
return getSessionsByName().get(sessionName);
}
/** Append the string containing the SQL insert string for the given table. */
protected SQLCall buildCallWithoutReturning(AbstractSession session) {
SQLCall call = new SQLCall();
call.returnNothing();
Writer writer = new CharArrayWriter(200);
try {
writer.write("INSERT ");
if (getHintString() != null) {
writer.write(getHintString());
writer.write(" ");
}
writer.write("INTO ");
writer.write(getTable().getQualifiedNameDelimited(session.getPlatform()));
writer.write(" (");
Vector fieldsForTable = new Vector();
for (Enumeration fieldsEnum = getModifyRow().keys(); fieldsEnum.hasMoreElements(); ) {
DatabaseField field = (DatabaseField) fieldsEnum.nextElement();
if (field.getTable().equals(getTable()) || (!field.hasTableName())) {
fieldsForTable.addElement(field);
}
}
if (fieldsForTable.isEmpty()) {
throw QueryException.objectToInsertIsEmpty(getTable());
}
for (int i = 0; i < fieldsForTable.size(); i++) {
writer.write(
((DatabaseField) fieldsForTable.elementAt(i)).getNameDelimited(session.getPlatform()));
if ((i + 1) < fieldsForTable.size()) {
writer.write(", ");
}
}
writer.write(") VALUES (");
for (int i = 0; i < fieldsForTable.size(); i++) {
DatabaseField field = (DatabaseField) fieldsForTable.elementAt(i);
call.appendModify(writer, field);
if ((i + 1) < fieldsForTable.size()) {
writer.write(", ");
}
}
writer.write(")");
call.setSQLString(writer.toString());
} catch (IOException exception) {
throw ValidationException.fileError(exception);
}
return call;
}
/** INTERNAL: Acquires a special historical session for reading objects as of a past time. */
public org.eclipse.persistence.sessions.Session acquireHistoricalSession(AsOfClause clause)
throws ValidationException {
if (isServerSessionBroker()) {
throw ValidationException.cannotAcquireHistoricalSession();
}
// ? logMessage("acquire_client_session_broker", (Object[])null);
SessionBroker historicalBroker = copySessionBroker();
String sessionName;
AbstractSession session;
Iterator names = this.getSessionsByName().keySet().iterator();
while (names.hasNext()) {
sessionName = (String) names.next();
session = getSessionForName(sessionName);
historicalBroker.registerSession(sessionName, session.acquireHistoricalSession(clause));
}
return historicalBroker;
}
/** PUBLIC: You cannot add a project to a session broker, you must add it to its session. */
public void addDescriptors(org.eclipse.persistence.sessions.Project project)
throws ValidationException {
throw ValidationException.cannotAddDescriptorsToSessionBroker();
}
/** PUBLIC: You cannot add descriptors to a session broker, you must add them to its session. */
public void addDescriptors(Vector descriptors) throws ValidationException {
throw ValidationException.cannotAddDescriptorsToSessionBroker();
}
/** PUBLIC: You cannot add a descriptor to a session broker, you must add it to its session. */
public void addDescriptor(ClassDescriptor descriptor) {
throw ValidationException.cannotAddDescriptorsToSessionBroker();
}
/** Append the string containing the SQL insert string for the given table. */
public DatabaseCall buildCall(AbstractSession session) {
SQLCall call = new SQLCall();
call.returnNothing();
Writer writer = new CharArrayWriter(100);
Vector mainPrimaryKeys = new Vector();
mainPrimaryKeys.addAll((Collection) tablesToPrimaryKeyFields.get(table));
Vector allFields = (Vector) mainPrimaryKeys.clone();
Iterator itDatabaseFieldsToValues = tables_databaseFieldsToValues.values().iterator();
while (itDatabaseFieldsToValues.hasNext()) {
Iterator itDatabaseFields = ((HashMap) itDatabaseFieldsToValues.next()).keySet().iterator();
while (itDatabaseFields.hasNext()) {
allFields.addElement(itDatabaseFields.next());
}
}
try {
// DECLARE
writer.write("DECLARE\n");
for (int i = 0; i < allFields.size(); i++) {
writeDeclareTypeAndVar(
writer, (DatabaseField) allFields.elementAt(i), session.getPlatform());
}
// BEGIN
writer.write("BEGIN\n");
// select t0.emp_id, concat('Even', t0.f_name), t1.salary + 1000 BULK COLLECT into
// EMPLOYEEE_EMP_ID_VAR, EMPLOYEEE_F_NAME_VAR, SALARY_SALARY_VAR from employee t0, salary t1
// where t0.l_name like 'updateEmployeeTestUsingTempTable' and t0.f_name in ('0', '2') and
// t1.salary = 0 and t0.emp_id = t1.emp_id;
String selectStr = selectCall.getSQLString();
int index = selectStr.toUpperCase().indexOf(" FROM ");
String firstPart = selectStr.substring(0, index);
String secondPart = selectStr.substring(index, selectStr.length());
writer.write(tab);
writer.write(firstPart);
writer.write(" BULK COLLECT INTO ");
for (int i = 0; i < allFields.size(); i++) {
writeVar(writer, (DatabaseField) allFields.elementAt(i), session.getPlatform());
if (i < allFields.size() - 1) {
writer.write(", ");
}
}
writer.write(secondPart);
writer.write(";\n");
call.getParameters().addAll(selectCall.getParameters());
call.getParameterTypes().addAll(selectCall.getParameterTypes());
DatabaseField firstMainPrimaryKey = (DatabaseField) mainPrimaryKeys.firstElement();
writer.write(tab);
writer.write("IF ");
writeVar(writer, firstMainPrimaryKey, session.getPlatform());
writer.write(".COUNT > 0 THEN\n");
Iterator itEntries = tables_databaseFieldsToValues.entrySet().iterator();
while (itEntries.hasNext()) {
writeForAll(writer, firstMainPrimaryKey, session.getPlatform());
writer.write(trpltab);
writer.write("UPDATE ");
Map.Entry entry = (Map.Entry) itEntries.next();
DatabaseTable t = (DatabaseTable) entry.getKey();
writer.write(t.getQualifiedNameDelimited(session.getPlatform()));
writer.write(" SET ");
HashMap databaseFieldsToValues = (HashMap) entry.getValue();
int counter = 0;
Iterator itDatabaseFields = databaseFieldsToValues.keySet().iterator();
while (itDatabaseFields.hasNext()) {
counter++;
DatabaseField field = (DatabaseField) itDatabaseFields.next();
writer.write(field.getNameDelimited(session.getPlatform()));
writer.write(" = ");
writeVar(writer, field, session.getPlatform());
writer.write("(i)");
if (counter < databaseFieldsToValues.size()) {
writer.write(", ");
}
}
writer.write(" WHERE ");
Vector tablePrimaryKeys = new Vector();
tablePrimaryKeys.addAll((Collection) tablesToPrimaryKeyFields.get(t));
for (int i = 0; i < mainPrimaryKeys.size(); i++) {
DatabaseField tableField = (DatabaseField) tablePrimaryKeys.elementAt(i);
writer.write(tableField.getNameDelimited(session.getPlatform()));
writer.write(" = ");
DatabaseField mainField = (DatabaseField) mainPrimaryKeys.elementAt(i);
writeVar(writer, mainField, session.getPlatform());
writer.write("(i)");
if (i < mainPrimaryKeys.size() - 1) {
writer.write(" AND ");
} else {
writer.write(";\n");
}
}
}
writer.write(tab);
writer.write("END IF;\n");
writer.write(tab);
DatabaseField outField = new DatabaseField("ROW_COUNT");
outField.setType(Integer.class);
call.appendOut(writer, outField);
writer.write(" := ");
writeVar(writer, firstMainPrimaryKey, session.getPlatform());
writer.write(".COUNT;\n");
writer.write("END;");
call.setSQLString(writer.toString());
} catch (IOException exception) {
throw ValidationException.fileError(exception);
}
return call;
}
