Пример #1
0
  /**
   * 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);
   }
 }
Пример #4
0
  /**
   * 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;
    }
  }
Пример #5
0
  /** 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;
  }
Пример #6
0
 /** 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;
  }
Пример #8
0
  /** 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;
  }
Пример #9
0
 /** 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();
 }
Пример #10
0
 /** 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();
 }
Пример #11
0
 /** 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;
  }