How to use

FieldsLockingPolicy

in

org.eclipse.persistence.descriptors

/**
 * INTERNAL:
 * Returns the fields that should be compared in the where clause.
 * In this case, it is all the fields, except for the primary key
 * and class indicator field.
 */
protected List<DatabaseField> getAllNonPrimaryKeyFields() {
  if (allNonPrimaryKeyFields == null) {
    allNonPrimaryKeyFields = buildAllNonPrimaryKeyFields();
  }
  return allNonPrimaryKeyFields;
}

/**
 * INTERNAL:
 * filter the fields based on the passed in table.  Only return fields of this table.
 */
protected Vector getAllNonPrimaryKeyFields(DatabaseTable table) {
  Vector filteredFields = new Vector();
  for (Enumeration enumtr = getAllNonPrimaryKeyFields().elements(); enumtr.hasMoreElements();) {
    DatabaseField dbField = (DatabaseField)enumtr.nextElement();
    if (dbField.getTableName().equals(table.getName())) {
      filteredFields.addElement(dbField);
    }
  }
  return filteredFields;
}

/**
 * INTERNAL:
 * This method must be included in any locking policy.  When given an
 * expression, this method will return a new expression with the optimistic
 * locking values included.  The values are taken from the passed in database row.
 * This expression will be used in a delete call.
 */
public Expression buildUpdateExpression(DatabaseTable table, Expression mainExpression, AbstractRecord transRow, AbstractRecord modifyRow) {
  return mainExpression.and(buildExpression(table, transRow, modifyRow, mainExpression.getBuilder()));
}

/**
 * INTERNAL:
 * returns the expression to be used in both the delete and update where clause.
 */
protected Expression buildExpression(DatabaseTable table, AbstractRecord transRow, AbstractRecord modifyRow, ExpressionBuilder builder) {
  Expression exp = null;
  DatabaseField field;
  Iterator<DatabaseField> iterator = getFieldsToCompare(table, transRow, modifyRow).iterator();
  if (iterator.hasNext()) {
    field = iterator.next();//First element
    exp = builder.getField(field).equal(builder.getParameter(field));
  }
  while (iterator.hasNext()) {
    field = iterator.next();
    exp = exp.and(builder.getField(field).equal(builder.getParameter(field)));
  }
  return exp;
}

/**
 * INTERNAL: It is responsible for initializing the policy;
 */
@Override
public void initialize(AbstractSession session) {
  super.initialize(session);
  List<DatabaseField> lockFields = getLockFields();
  int size = lockFields.size();
  for (int index = 0; index < size; index++) {
    DatabaseField field = lockFields.get(index);
    field = descriptor.buildField(field);
    lockFields.set(index, field);
    List<DatabaseField> fieldsForTable = getLockFieldsByTable().get(field.getTable());
    if (fieldsForTable == null) {
      fieldsForTable = org.eclipse.persistence.internal.helper.NonSynchronizedVector.newInstance();
      getLockFieldsByTable().put(field.getTable(), fieldsForTable);
    }
    fieldsForTable.add(field);
  }
}

/**
 * INTERNAL:
 * Returns the fields that should be compared in the where clause.
 * In this case, it is all the fields, except for the primary key
 * and class indicator fields.
 * This is called durring lazy initialization
 */
protected Vector buildAllNonPrimaryKeyFields() {
  Vector fields = new Vector();
  for (Enumeration enumtr = descriptor.getFields().elements(); enumtr.hasMoreElements();) {
    DatabaseField dbField = (DatabaseField)enumtr.nextElement();
    if (!isPrimaryKey(dbField)) {
      if (descriptor.hasInheritance()) {
        DatabaseField classField = descriptor.getInheritancePolicy().getClassIndicatorField();
        if (!((classField == null) || dbField.equals(classField))) {
          fields.addElement(dbField);
        }
      } else {
        fields.addElement(dbField);
      }
    }
  }
  /* CR#... nullpoint occurs if null is returned, not sure why this was here.
  if (fields.isEmpty()) {
    return null;
  }*/
  return fields;
}

/**
 * INTERNAL:
 * This method must be included in any locking policy.  When given an
 * expression, this method will return a new expression with the optimistic
 * locking values included.  The values are taken from the passed in database row.
 * This expression will be used in a delete call.
 */
public Expression buildUpdateExpression(DatabaseTable table, Expression mainExpression, AbstractRecord transRow, AbstractRecord modifyRow) {
  return mainExpression.and(buildExpression(table, transRow, modifyRow, mainExpression.getBuilder()));
}

/**
 * INTERNAL:
 * returns the expression to be used in both the delete and update where clause.
 */
protected Expression buildExpression(DatabaseTable table, AbstractRecord transRow, AbstractRecord modifyRow, ExpressionBuilder builder) {
  Expression exp = null;
  DatabaseField field;
  Enumeration enumtr = getFieldsToCompare(table, transRow, modifyRow).elements();
  if (enumtr.hasMoreElements()) {
    field = (DatabaseField)enumtr.nextElement();//First element
    exp = builder.getField(field).equal(builder.getParameter(field));
  }
  while (enumtr.hasMoreElements()) {
    field = (DatabaseField)enumtr.nextElement();
    exp = exp.and(builder.getField(field).equal(builder.getParameter(field)));
  }
  return exp;
}

/**
 * INTERNAL: It is responsible for initializing the policy;
 */
@Override
public void initialize(AbstractSession session) {
  super.initialize(session);
  List<DatabaseField> lockFields = getLockFields();
  int size = lockFields.size();
  for (int index = 0; index < size; index++) {
    DatabaseField field = lockFields.get(index);
    field = descriptor.buildField(field);
    lockFields.set(index, field);
    List<DatabaseField> fieldsForTable = getLockFieldsByTable().get(field.getTable());
    if (fieldsForTable == null) {
      fieldsForTable = org.eclipse.persistence.internal.helper.NonSynchronizedVector.newInstance();
      getLockFieldsByTable().put(field.getTable(), fieldsForTable);
    }
    fieldsForTable.add(field);
  }
}

/**
 * INTERNAL:
 * Returns the fields that should be compared in the where clause.
 * In this case, it is all the fields, except for the primary key
 * and class indicator fields.
 * This is called during lazy initialization.
 */
protected List buildAllNonPrimaryKeyFields() {
  List fields = new ArrayList();
  for (DatabaseField dbField : descriptor.getSelectionFields()) {
    if (!isPrimaryKey(dbField)) {
      if (descriptor.hasInheritance()) {
        DatabaseField classField = descriptor.getInheritancePolicy().getClassIndicatorField();
        if (!((classField == null) || dbField.equals(classField))) {
          fields.add(dbField);
        }
      } else {
        fields.add(dbField);
      }
    }
  }
  /* CR#... nullpoint occurs if null is returned, not sure why this was here.
  if (fields.isEmpty()) {
    return null;
  }*/
  return fields;
}

/**
 * INTERNAL:
 * When given an expression, this method will return a new expression with the optimistic
 * locking values included.  The values are taken from the passed in database row.
 * This expression will be used in a delete call.
 */
public Expression buildDeleteExpression(DatabaseTable table, Expression mainExpression, AbstractRecord row) {
  return mainExpression.and(buildExpression(table, row, null, mainExpression.getBuilder()));
}

/**
 * INTERNAL:
 * Returns the fields that should be compared in the where clause.
 * In this case, it is all the fields, except for the primary key
 * and class indicator field.
 */
protected Vector getAllNonPrimaryKeyFields() {
  if (allNonPrimaryKeyFields == null) {
    allNonPrimaryKeyFields = buildAllNonPrimaryKeyFields();
  }
  return allNonPrimaryKeyFields;
}

/**
 * INTERNAL:
 * filter the fields based on the passed in table.  Only return fields of this table.
 */
protected List<DatabaseField> getAllNonPrimaryKeyFields(DatabaseTable table) {
  List<DatabaseField> filteredFields = new ArrayList<DatabaseField>();
  for (DatabaseField dbField : getAllNonPrimaryKeyFields()) {
    if (dbField.getTableName().equals(table.getName())) {
      filteredFields.add(dbField);
    }
  }
  return filteredFields;
}

/**
 * INTERNAL:
 * returns the expression to be used in both the delete and update where clause.
 */
protected Expression buildExpression(DatabaseTable table, AbstractRecord transRow, AbstractRecord modifyRow, ExpressionBuilder builder) {
  Expression exp = null;
  DatabaseField field;
  Iterator<DatabaseField> iterator = getFieldsToCompare(table, transRow, modifyRow).iterator();
  if (iterator.hasNext()) {
    field = iterator.next();//First element
    exp = builder.getField(field).equal(builder.getParameter(field));
  }
  while (iterator.hasNext()) {
    field = iterator.next();
    exp = exp.and(builder.getField(field).equal(builder.getParameter(field)));
  }
  return exp;
}

/**
 * INTERNAL:
 * It is responsible for initializing the policy;
 */
public void initialize(AbstractSession session) {
  super.initialize(session);
  List lockFields = getLockFields();
  int size = lockFields.size();
  for (int index = 0; index < size; index++) {
    DatabaseField field = (DatabaseField)lockFields.get(index);
    field = descriptor.buildField(field);
    lockFields.set(index, field);
    Vector fieldsForTable = (Vector)getLockFieldsByTable().get(field.getTable());
    if (fieldsForTable == null) {
      fieldsForTable = org.eclipse.persistence.internal.helper.NonSynchronizedVector.newInstance();
      getLockFieldsByTable().put(field.getTable(), fieldsForTable);
    }
    fieldsForTable.addElement(field);
  }
}

/**
 * INTERNAL:
 * Returns the fields that should be compared in the where clause.
 * In this case, it is all the fields, except for the primary key
 * and class indicator fields.
 * This is called during lazy initialization.
 */
protected List buildAllNonPrimaryKeyFields() {
  List fields = new ArrayList();
  for (DatabaseField dbField : descriptor.getSelectionFields()) {
    if (!isPrimaryKey(dbField)) {
      if (descriptor.hasInheritance()) {
        DatabaseField classField = descriptor.getInheritancePolicy().getClassIndicatorField();
        if (!((classField == null) || dbField.equals(classField))) {
          fields.add(dbField);
        }
      } else {
        fields.add(dbField);
      }
    }
  }
  /* CR#... nullpoint occurs if null is returned, not sure why this was here.
  if (fields.isEmpty()) {
    return null;
  }*/
  return fields;
}

/**
 * INTERNAL:
 * When given an expression, this method will return a new expression with the optimistic
 * locking values included.  The values are taken from the passed in database row.
 * This expression will be used in a delete call.
 */
public Expression buildDeleteExpression(DatabaseTable table, Expression mainExpression, AbstractRecord row) {
  return mainExpression.and(buildExpression(table, row, null, mainExpression.getBuilder()));
}

/**
 * INTERNAL:
 * Returns the fields that should be compared in the where clause.
 * In this case, it is all the fields, except for the primary key
 * and class indicator field.
 */
protected List<DatabaseField> getAllNonPrimaryKeyFields() {
  if (allNonPrimaryKeyFields == null) {
    allNonPrimaryKeyFields = buildAllNonPrimaryKeyFields();
  }
  return allNonPrimaryKeyFields;
}

/**
 * INTERNAL:
 * filter the fields based on the passed in table.  Only return fields of this table.
 */
protected List<DatabaseField> getAllNonPrimaryKeyFields(DatabaseTable table) {
  List<DatabaseField> filteredFields = new ArrayList<DatabaseField>();
  for (DatabaseField dbField : getAllNonPrimaryKeyFields()) {
    if (dbField.getTableName().equals(table.getName())) {
      filteredFields.add(dbField);
    }
  }
  return filteredFields;
}

/**
 * INTERNAL:
 * When given an expression, this method will return a new expression with the optimistic
 * locking values included.  The values are taken from the passed in database row.
 * This expression will be used in a delete call.
 */
public Expression buildDeleteExpression(DatabaseTable table, Expression mainExpression, AbstractRecord row) {
  return mainExpression.and(buildExpression(table, row, null, mainExpression.getBuilder()));
}