/** * INTERNAL: * Retrieves the lock value from the object. */ protected Object lockValueFromObject(Object domainObject) { // PERF: If mapping with a direct mapping get from cached mapping. if (this.lockMapping != null) { return this.lockMapping.getAttributeValueFromObject(domainObject); } else { return this.descriptor.getObjectBuilder().getBaseValueForField(this.writeLockField, domainObject); } }
@Override protected Object buildCompositeObject(ObjectBuilder objectBuilder, AbstractRecord nestedRow, ObjectBuildingQuery query, CacheKey parentCacheKey, JoinedAttributeManager joinManager, AbstractSession targetSession) { Object aggregateObject = objectBuilder.buildNewInstance(); objectBuilder.buildAttributesIntoObject(aggregateObject, parentCacheKey, nestedRow, query, joinManager, query.getExecutionFetchGroup(objectBuilder.getDescriptor()), false, targetSession); return aggregateObject; }
/** * Build the row representation of an object. */ public AbstractRecord buildRow(Object object, AbstractSession session, WriteType writeType) { return buildRow(createRecord(session), object, session, writeType); }
/** * Build the row representation of the object for update. The row built does not * contain entries for uninstantiated attributes. */ public AbstractRecord buildRowForShallowInsert(Object object, AbstractSession session) { return buildRowForShallowInsert(createRecord(session), object, session); }
protected Object buildCompositeObject(ObjectBuilder objectBuilder, AbstractRecord nestedRow, ObjectBuildingQuery query, JoinedAttributeManager joinManager) { Object aggregateObject = objectBuilder.buildNewInstance(); objectBuilder.buildAttributesIntoObject(aggregateObject, nestedRow, query, joinManager, false); return aggregateObject; }
/** * Build the row of all of the fields used for insertion. */ public AbstractRecord buildTemplateInsertRow(AbstractSession session) { AbstractRecord databaseRow = createRecord(session); buildTemplateInsertRow(session, databaseRow); return databaseRow; }
existingValue = this.sequenceMapping.getAttributeValueFromObject(object); } else { existingValue = getBaseValueForField(sequenceNumberField, object); if (isPrimaryKeyComponentInvalid(existingValue, index) || this.descriptor.getSequence().shouldAlwaysOverrideExistingValue()) { sequenceValue = writeSession.getSequencing().getNextValue(this.descriptor.getJavaClass()); } else { } else { AbstractRecord tempRow = createRecord(1, writeSession); tempRow.put(sequenceNumberField, sequenceValue); DatabaseMapping mapping = getBaseMappingForField(sequenceNumberField); Object sequenceIntoObject = getParentObjectForField(sequenceNumberField, object); clearPrimaryKey(object); Object primaryKey = extractPrimaryKeyFromObject(object, writeSession); writeQuery.setPrimaryKey(primaryKey); AbstractRecord modifyRow = writeQuery.getModifyRow(); addPrimaryKeyForNonDefaultTable(modifyRow, object, writeSession); ChangeRecord changeRecord = getBaseChangeRecordForField(objectChangeSet, object, sequenceNumberField, writeSession); if (changeRecord.getMapping().isDirectCollectionMapping()) {
} else { if(changeSet != null && (!changeSet.isNew() || (query.getDescriptor() != null && query.getDescriptor().shouldUseFullChangeSetsForNewObjects()))) { aggregateChangeSet = getReferenceDescriptor(aggregate, query.getSession()).getObjectBuilder().createObjectChangeSet(aggregate, (UnitOfWorkChangeSet)((UnitOfWorkImpl)query.getSession()).getUnitOfWorkChangeSet(), true, query.getSession()); getObjectBuilder(aggregate, query.getSession()).assignReturnRow(aggregate, query.getSession(), aggregateRow, aggregateChangeSet); Object fieldValue = valueFromObject(targetObject, field, query.getSession()); if (fieldValue == null) { Object baseValue = getDescriptor().getObjectBuilder().getBaseValueForField(field, targetObject); if (baseValue != null) { DatabaseMapping baseMapping = getDescriptor().getObjectBuilder().getBaseMappingForField(field); if (baseMapping.isForeignReferenceMapping()) { ForeignReferenceMapping refMapping = (ForeignReferenceMapping)baseMapping; aggregateChangeSet = getReferenceDescriptor(aggregate, query.getSession()).getObjectBuilder().createObjectChangeSet(aggregate, (UnitOfWorkChangeSet)((UnitOfWorkImpl)query.getSession()).getUnitOfWorkChangeSet(), true, query.getSession());
existingValue = this.sequenceMapping.getAttributeValueFromObject(object); } else { existingValue = getBaseValueForField(sequenceNumberField, object); } else { AbstractRecord tempRow = createRecord(1, writeSession); tempRow.put(sequenceNumberField, sequenceValue); DatabaseMapping mapping = getBaseMappingForField(sequenceNumberField); Object sequenceIntoObject = getParentObjectForField(sequenceNumberField, object); clearPrimaryKey(object);
setSelectionCriteria(this.descriptor.getObjectBuilder().getPrimaryKeyExpression()); setExpressionBuilder(getSelectionCriteria().getBuilder()); extendPessimisticLockScope(); if (this.selectionId != null) { setTranslationRow(this.descriptor.getObjectBuilder().buildRowFromPrimaryKeyValues(this.selectionId, this.session)); } else {//(getSelectionObject() != null) setTranslationRow(this.descriptor.getObjectBuilder().buildRowForTranslation(this.selectionObject, this.session)); if (selectionCriteria != null) { if (((this.cacheUsage == CheckCacheByPrimaryKey) && (!this.descriptor.getObjectBuilder().isPrimaryKeyExpression(false, selectionCriteria, this.session))) || ((this.cacheUsage == CheckCacheByExactPrimaryKey) && (!this.descriptor.getObjectBuilder().isPrimaryKeyExpression(true, selectionCriteria, this.session)))) { this.cacheUsage = DoNotCheckCache;
getObjectBuilder().initialize(session); for (int index = getObjectBuilder().getPrimaryKeyMappings().size() - 1; index >= 0; index--) { DatabaseMapping mapping = getObjectBuilder().getPrimaryKeyMappings().get(index); if ((mapping != null) && mapping.isDirectToFieldMapping()) { getMappings().remove(mapping);
public static String stringifyId(Object entity, String typeName, PersistenceContext app) { ClassDescriptor descriptor = app.getDescriptor(typeName); List<DatabaseMapping> pkMappings = descriptor.getObjectBuilder().getPrimaryKeyMappings(); if (pkMappings.isEmpty()) { return ""; if (sourceToTargetFields.containsKey(field)) { if ((fieldName != null) && (dbFieldName.equals(fieldName))) { Object value = descriptor.getObjectBuilder().getBaseValueForField(dbField, entity); Object realAttributeValue = refMapping.getRealAttributeValueFromAttribute(refMapping.getAttributeValueFromObject(value), value, (AbstractSession) app.getServerSession()); key.append(realAttributeValue);
/** * Build the primary key expression for the secondary table. */ public Expression buildPrimaryKeyExpression(DatabaseTable table) throws DescriptorException { if (this.descriptor.getTables().firstElement().equals(table)) { return getPrimaryKeyExpression(); } Map keyMapping = this.descriptor.getAdditionalTablePrimaryKeyFields().get(table); if (keyMapping == null) { throw DescriptorException.multipleTablePrimaryKeyNotSpecified(this.descriptor); } ExpressionBuilder builder = new ExpressionBuilder(); Expression expression = null; for (Iterator primaryKeyEnum = keyMapping.values().iterator(); primaryKeyEnum.hasNext();) { DatabaseField field = (DatabaseField)primaryKeyEnum.next(); expression = (builder.getField(field).equal(builder.getParameter(field))).and(expression); } return expression; }
/** * Return the row with primary keys and their values from the given expression. */ public Vector extractPrimaryKeyFromExpression(boolean requiresExactMatch, Expression expression, AbstractRecord translationRow, AbstractSession session) { AbstractRecord primaryKeyRow = createRecord(getPrimaryKeyMappings().size(), session); expression.getBuilder().setSession(session.getRootSession(null)); // Get all the field & values from expression. boolean isValid = expression.extractPrimaryKeyValues(requiresExactMatch, this.descriptor, primaryKeyRow, translationRow); if (requiresExactMatch && (!isValid)) { return null; } // Check that the sizes match. if (primaryKeyRow.size() != this.descriptor.getPrimaryKeyFields().size()) { return null; } return extractPrimaryKeyFromRow(primaryKeyRow, session); }
/** * INTERNAL: * Prepare the receiver for execution in a session. */ public void prepareForExecution() throws QueryException { super.prepareForExecution(); // For bug 2989998 the translation row now sometimes set earlier in prepare. if (shouldPrepare()) { if (getSelectionKey() != null) { // Row must come from the key. setTranslationRow(this.descriptor.getObjectBuilder().buildRowFromPrimaryKeyValues(getSelectionKey(), getSession())); } else if (getSelectionObject() != null) { // The expression is set in the prepare as params. setTranslationRow(this.descriptor.getObjectBuilder().buildRowForTranslation(getSelectionObject(), getSession())); } } }
/** * Extract primary key attribute values from the domainObject. */ @Override public Object extractPrimaryKeyFromObject(Object domainObject, AbstractSession session) { return extractPrimaryKeyFromObject(domainObject, session, false); }
@Override protected Object buildCompositeObject(ClassDescriptor descriptor, AbstractRecord nestedRow, ObjectBuildingQuery query, CacheKey parentsCacheKey, JoinedAttributeManager joinManager, AbstractSession targetSession) { if (((EISDescriptor)descriptor).isXMLFormat()) { return descriptor.getObjectBuilder().buildObject(query, nestedRow, joinManager); } else { Object element = descriptor.getObjectBuilder().buildNewInstance(); descriptor.getObjectBuilder().buildAttributesIntoObject(element, parentsCacheKey, nestedRow, query, joinManager, query.getExecutionFetchGroup(descriptor), false, targetSession); return element; } }
DatabaseField field = getReferenceFields().elementAt(i); if (row.containsKey(field)) { getObjectBuilder(aggregate, query.getSession()).assignReturnValueForField(aggregate, query, row, field, handledMappings); Object fieldValue = valueFromObject(targetObject, field, query.getSession()); if (fieldValue == null) { Object baseValue = getDescriptor().getObjectBuilder().getBaseValueForField(field, targetObject); if (baseValue != null) { DatabaseMapping baseMapping = getDescriptor().getObjectBuilder().getBaseMappingForField(field); if (baseMapping.isForeignReferenceMapping()) { ForeignReferenceMapping refMapping = (ForeignReferenceMapping)baseMapping;
/** * Return the row with primary keys and their values from the given expression. */ public AbstractRecord extractPrimaryKeyRowFromExpression(Expression expression, AbstractRecord translationRow, AbstractSession session) { AbstractRecord primaryKeyRow = createRecord(getPrimaryKeyMappings().size(), session); expression.getBuilder().setSession(session.getRootSession(null)); // Get all the field & values from expression boolean isValid = expression.extractPrimaryKeyValues(true, this.descriptor, primaryKeyRow, translationRow); if (!isValid) { return null; } // Check that the sizes match up if (primaryKeyRow.size() != this.descriptor.getPrimaryKeyFields().size()) { return null; } return primaryKeyRow; }
/** * Extract the key field values from the specified row. * Used for batch reading. Keep the fields in the same order * as in the targetForeignKeysToSourceKeys hashtable. */ protected Vector extractPrimaryKeyFromRow(AbstractRecord row, AbstractSession session) { Vector key = new Vector(this.getTargetForeignKeysToSourceKeys().size()); for (Iterator stream = getTargetForeignKeysToSourceKeys().values().iterator(); stream.hasNext();) { DatabaseField field = (DatabaseField)stream.next(); Object value = row.get(field); // Must ensure the classification to get a cache hit. try { value = session.getDatasourcePlatform().convertObject(value, getDescriptor().getObjectBuilder().getFieldClassification(field)); } catch (ConversionException e) { throw ConversionException.couldNotBeConverted(this, getDescriptor(), e); } key.addElement(value); } return key; }