/** * 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: * 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 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: * 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 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())); }