protected void initializeWithTableNames(Session session, Collection tableNames) {
    tableNameToClass = new Hashtable(tableNames.size());
    tableNameToPkFieldNames = new Hashtable(tableNames.size());

    // pkFieldVectors cached here to avoid calculating it more than once per class
    Hashtable classToPkFieldNames = new Hashtable();
    // loop through the descriptors to fill out tableNameToClass and tableNameToPkFieldNames
    Iterator descriptors = session.getDescriptors().values().iterator();
    while (descriptors.hasNext() && !tableNames.isEmpty()) {
      ClassDescriptor desc = (ClassDescriptor) descriptors.next();

      // Create a Vector containing names of all tables mapped to the descriptor
      Vector descTableNames = desc.getTableNames();

      // bypass descriptors with no tables
      if (descTableNames.isEmpty()) {
        continue;
      }

      // Remove schema names (if any) converting "SCHEMA_NAME.TABLE_NAME" to "TABLE_NAME"
      removePrefixFromDatabaseObjectNames(descTableNames);

      // handle inheritance: table name should be mapped to the base mapped class
      Class baseClass = desc.getJavaClass();
      while (desc.isChildDescriptor()) {
        desc = session.getDescriptor(desc.getInheritancePolicy().getParentClass());
        baseClass = desc.getJavaClass();
      }

      Iterator it = tableNames.iterator();
      while (it.hasNext()) {
        // for each tableName specified by the user
        String tableName = (String) it.next();
        // verify whether the descriptor maps a table with the same name
        if (descTableNames.contains(tableName)) {
          // map the table name to the baseClass corresponding to the descriptor
          tableNameToClass.put(tableName, baseClass);

          // try to obtain cached pkFieldNames Vector corresponding to baseClass
          Vector pkFieldNames = (Vector) classToPkFieldNames.get(baseClass);
          if (pkFieldNames == null) {
            // Create a Vector containing names of all primary key fields
            pkFieldNames = desc.getPrimaryKeyFieldNames();
            // Remove table name converting from "TABLE_NAME.FIELD_NAME" to "FIELD_NAME"
            removePrefixFromDatabaseObjectNames(pkFieldNames);
            // cache pkFieldNames Vector corresponding to baseClass
            classToPkFieldNames.put(baseClass, pkFieldNames);
          }
          // map the table name to the Vector of names of primary key fields.
          tableNameToPkFieldNames.put(tableName, pkFieldNames);

          // the table name is mapped - remove it from the list of table names to be mapped.
          it.remove();
        }
      }
    }
  }
  protected void onConnectAllSequences() {
    connectedSequences = new Vector();
    boolean shouldUseTransaction = false;
    boolean shouldUsePreallocation = false;
    boolean shouldAcquireValueAfterInsert = false;
    Iterator descriptors = getOwnerSession().getDescriptors().values().iterator();
    while (descriptors.hasNext()) {
      ClassDescriptor descriptor = (ClassDescriptor) descriptors.next();
      // Find root sequence, because inheritance needs to be resolved here.
      // TODO: The way we initialize sequencing needs to be in line with descriptor init.
      ClassDescriptor parentDescriptor = descriptor;
      while (!parentDescriptor.usesSequenceNumbers() && parentDescriptor.isChildDescriptor()) {
        ClassDescriptor newDescriptor =
            getOwnerSession()
                .getDescriptor(parentDescriptor.getInheritancePolicy().getParentClass());
        // Avoid issue with error cases of self parent, or null parent.
        if ((newDescriptor == null) || (newDescriptor == parentDescriptor)) {
          break;
        }
        parentDescriptor = newDescriptor;
      }
      if (!parentDescriptor.usesSequenceNumbers()) {
        continue;
      }
      String seqName = parentDescriptor.getSequenceNumberName();
      Sequence sequence = getSequence(seqName);
      if (sequence == null) {
        sequence = new DefaultSequence(seqName);
        getOwnerSession().getDatasourcePlatform().addSequence(sequence);
      }
      // PERF: Initialize the sequence, this avoid having to look it up every time.
      descriptor.setSequence(sequence);
      if (connectedSequences.contains(sequence)) {
        continue;
      }
      try {
        if (sequence instanceof DefaultSequence
            && !connectedSequences.contains(getDefaultSequence())) {
          getDefaultSequence().onConnect(getOwnerSession().getDatasourcePlatform());
          connectedSequences.add(0, getDefaultSequence());
          shouldUseTransaction |= getDefaultSequence().shouldUseTransaction();
          shouldUsePreallocation |= getDefaultSequence().shouldUsePreallocation();
          shouldAcquireValueAfterInsert |= getDefaultSequence().shouldAcquireValueAfterInsert();
        }
        sequence.onConnect(getOwnerSession().getDatasourcePlatform());
        connectedSequences.addElement(sequence);
        shouldUseTransaction |= sequence.shouldUseTransaction();
        shouldUsePreallocation |= sequence.shouldUsePreallocation();
        shouldAcquireValueAfterInsert |= sequence.shouldAcquireValueAfterInsert();
      } catch (RuntimeException ex) {
        // defaultSequence has to disconnect the last
        for (int i = connectedSequences.size() - 1; i >= 0; i--) {
          try {
            Sequence sequenceToDisconnect = (Sequence) connectedSequences.elementAt(i);
            sequenceToDisconnect.onDisconnect(getOwnerSession().getDatasourcePlatform());
          } catch (RuntimeException ex2) {
            // ignore
          }
        }
        connectedSequences = null;
        throw ex;
      }
    }

    if (shouldAcquireValueAfterInsert && !shouldUsePreallocation) {
      whenShouldAcquireValueForAll = AFTER_INSERT;
    } else if (!shouldAcquireValueAfterInsert && shouldUsePreallocation) {
      whenShouldAcquireValueForAll = BEFORE_INSERT;
    }
    atLeastOneSequenceShouldUseTransaction = shouldUseTransaction;
    atLeastOneSequenceShouldUsePreallocation = shouldUsePreallocation;
  }