1 21 package oracle.toplink.essentials.mappings; 23 24 import java.util.*; 25 import oracle.toplink.essentials.exceptions.*; 26 import oracle.toplink.essentials.expressions.Expression; 27 import oracle.toplink.essentials.expressions.ExpressionBuilder; 28 import oracle.toplink.essentials.internal.identitymaps.CacheKey; 29 import oracle.toplink.essentials.internal.expressions.*; 30 import oracle.toplink.essentials.internal.helper.*; 31 import oracle.toplink.essentials.internal.indirection.*; 32 import oracle.toplink.essentials.internal.queryframework.*; 33 import oracle.toplink.essentials.internal.sessions.*; 34 import oracle.toplink.essentials.sessions.DatabaseRecord; 35 import oracle.toplink.essentials.mappings.converters.*; 36 import oracle.toplink.essentials.queryframework.*; 37 import oracle.toplink.essentials.internal.sessions.AbstractRecord; 38 import oracle.toplink.essentials.internal.sessions.UnitOfWorkImpl; 39 import oracle.toplink.essentials.internal.sessions.AbstractSession; 40 41 56 public class DirectMapMapping extends DirectCollectionMapping { 57 58 59 protected DatabaseField directKeyField; 60 61 62 protected Converter keyConverter; 63 64 67 public DirectMapMapping() { 68 super(); 69 this.selectionQuery = new DataReadQuery(); 70 this.containerPolicy = new DirectMapContainerPolicy(ClassConstants.Hashtable_Class); 71 } 72 73 78 public Converter getKeyConverter() { 79 return keyConverter; 80 } 81 82 87 public void setKeyConverter(Converter keyConverter) { 88 this.keyConverter = keyConverter; 89 } 90 91 97 public void addToCollectionChangeRecord(Object newKey, Object newValue, ObjectChangeSet objectChangeSet, UnitOfWorkImpl uow) throws DescriptorException { 98 DirectMapChangeRecord collectionChangeRecord = (DirectMapChangeRecord)objectChangeSet.getChangesForAttributeNamed(this.getAttributeName()); 99 if (collectionChangeRecord == null) { 100 collectionChangeRecord = new DirectMapChangeRecord(objectChangeSet); 101 collectionChangeRecord.setAttribute(getAttributeName()); 102 collectionChangeRecord.setMapping(this); 103 objectChangeSet.addChange(collectionChangeRecord); 104 } 105 collectionChangeRecord.addAdditionChange(newKey, newValue); 106 } 107 108 113 public Object buildCloneForPartObject(Object attributeValue, Object original, Object clone, UnitOfWorkImpl unitOfWork, boolean isExisting) { 114 DirectMapContainerPolicy containerPolicy = (DirectMapContainerPolicy)getContainerPolicy(); 115 if (attributeValue == null) { 116 return containerPolicy.containerInstance(1); 117 } 118 Object clonedAttributeValue = containerPolicy.containerInstance(containerPolicy.sizeFor(attributeValue)); 119 120 Object temporaryCollection = null; 125 synchronized (attributeValue) { 126 temporaryCollection = containerPolicy.cloneFor(attributeValue); 127 } 128 129 for (Object keysIterator = containerPolicy.iteratorFor(temporaryCollection); 130 containerPolicy.hasNext(keysIterator);) { 131 Object key = containerPolicy.next(keysIterator, unitOfWork); 132 Object cloneKey = buildKeyClone(key, unitOfWork, isExisting); 133 Object cloneValue = buildElementClone(containerPolicy.valueFromKey(key, temporaryCollection), unitOfWork, isExisting); 134 containerPolicy.addInto(cloneKey, cloneValue, clonedAttributeValue, unitOfWork); 135 } 136 return clonedAttributeValue; 137 } 138 139 146 protected Object buildKeyClone(Object element, UnitOfWorkImpl unitOfWork, boolean isExisting) { 147 Object cloneValue = element; 148 if ((getKeyConverter() != null) && getKeyConverter().isMutable()) { 149 cloneValue = getKeyConverter().convertDataValueToObjectValue(getKeyConverter().convertObjectValueToDataValue(cloneValue, unitOfWork), unitOfWork); 150 } 151 return cloneValue; 152 } 153 154 160 public ChangeRecord compareForChange(Object clone, Object backUp, ObjectChangeSet owner, AbstractSession session) { 161 Object cloneAttribute = null; 162 Object backUpAttribute = null; 163 164 DirectMapContainerPolicy cp = (DirectMapContainerPolicy)getContainerPolicy(); 165 166 cloneAttribute = getAttributeValueFromObject(clone); 167 if ((cloneAttribute != null) && (!getIndirectionPolicy().objectIsInstantiated(cloneAttribute))) { 168 return null; 169 } 170 171 Map cloneObjectCollection = (Map)getRealCollectionAttributeValueFromObject(clone, session); 172 HashMap originalKeyValues = new HashMap(10); 173 HashMap cloneKeyValues = new HashMap(10); 174 175 if (!owner.isNew()) { 176 backUpAttribute = getAttributeValueFromObject(backUp); 177 if ((backUpAttribute == null) && (cloneAttribute == null)) { 178 return null; 179 } 180 Map backUpCollection = (Map)getRealCollectionAttributeValueFromObject(backUp, session); 181 Object backUpIter = cp.iteratorFor(backUpCollection); 182 while (cp.hasNext(backUpIter)) { Object key = cp.next(backUpIter, session); 184 originalKeyValues.put(key, backUpCollection.get(key)); 185 } 186 } 187 Object cloneIter = cp.iteratorFor(cloneObjectCollection); 188 while (cp.hasNext(cloneIter)) { Object firstObject = cp.next(cloneIter, session); 190 Object firstValue = cloneObjectCollection.get(firstObject); 191 Object backupValue = originalKeyValues.get(firstObject); 192 if ( ! originalKeyValues.containsKey(firstObject) ){ 193 cloneKeyValues.put(firstObject, cloneObjectCollection.get(firstObject)); 194 }else if ( (backupValue == null && firstValue != null) || (!backupValue.equals(firstValue)) ) { cloneKeyValues.put(firstObject, cloneObjectCollection.get(firstObject)); 196 }else{ 197 originalKeyValues.remove(firstObject); 198 } 199 } 200 if (cloneKeyValues.isEmpty() && originalKeyValues.isEmpty() && (!owner.isNew())) { 201 return null; 202 } 203 DirectMapChangeRecord changeRecord = new DirectMapChangeRecord(owner); 204 changeRecord.setAttribute(getAttributeName()); 205 changeRecord.setMapping(this); 206 changeRecord.addAdditionChange(cloneKeyValues); 207 changeRecord.addRemoveChange(originalKeyValues); 208 return changeRecord; 209 } 210 211 215 public boolean compareObjects(Object firstObject, Object secondObject, AbstractSession session) { 216 Object firstObjectMap = getRealCollectionAttributeValueFromObject(firstObject, session); 217 Object secondObjectMap = getRealCollectionAttributeValueFromObject(secondObject, session); 218 DirectMapContainerPolicy mapContainerPolicy = (DirectMapContainerPolicy)getContainerPolicy(); 219 220 return mapContainerPolicy.compareContainers(firstObjectMap, secondObjectMap); 221 } 222 223 230 public void convertClassNamesToClasses(ClassLoader classLoader){ 231 super.convertClassNamesToClasses(classLoader); 232 if (keyConverter != null && keyConverter instanceof TypeConversionConverter){ 233 ((TypeConversionConverter)keyConverter).convertClassNamesToClasses(classLoader); 234 } 235 }; 236 237 240 public DatabaseField getDirectKeyField() { 241 return directKeyField; 242 } 243 244 248 public void initialize(AbstractSession session) throws DescriptorException { 249 super.initialize(session); 250 initializeDirectKeyField(session); 251 initializeContainerPolicy(session); 252 if (getKeyConverter() != null) { 253 getKeyConverter().initialize(this, session); 254 } 255 if (getValueConverter() != null) { 256 getValueConverter().initialize(this, session); 257 } 258 } 259 260 263 protected void initializeContainerPolicy(AbstractSession session) { 264 ((DirectMapContainerPolicy)getContainerPolicy()).setKeyField(getDirectKeyField()); 265 ((DirectMapContainerPolicy)getContainerPolicy()).setValueField(getDirectField()); 266 ((DirectMapContainerPolicy)getContainerPolicy()).setKeyConverter(getKeyConverter()); 267 ((DirectMapContainerPolicy)getContainerPolicy()).setValueConverter(getValueConverter()); 268 } 269 270 protected void initializeDeleteQuery(AbstractSession session) { 271 if (!getDeleteQuery().hasSessionName()) { 272 getDeleteQuery().setSessionName(session.getName()); 273 } 274 275 if (hasCustomDeleteQuery()) { 276 return; 277 } 278 279 Expression builder = new ExpressionBuilder(); 280 Expression directKeyExp = builder.getField(getDirectKeyField()).equal(builder.getParameter(getDirectKeyField())); 281 Expression expression = null; 282 SQLDeleteStatement statement = new SQLDeleteStatement(); 283 284 for (int index = 0; index < getReferenceKeyFields().size(); index++) { 286 DatabaseField referenceKey = (DatabaseField)getReferenceKeyFields().elementAt(index); 287 DatabaseField sourceKey = (DatabaseField)getSourceKeyFields().elementAt(index); 288 289 Expression subExp1 = builder.getField(referenceKey); 290 Expression subExp2 = builder.getParameter(sourceKey); 291 Expression subExpression = subExp1.equal(subExp2); 292 293 expression = subExpression.and(expression); 294 } 295 expression = expression.and(directKeyExp); 296 statement.setWhereClause(expression); 297 statement.setTable(getReferenceTable()); 298 getDeleteQuery().setSQLStatement(statement); 299 } 300 301 304 protected void initializeDirectKeyField(AbstractSession session) throws DescriptorException { 305 if (getDirectKeyField() == null) { 306 throw DescriptorException.directFieldNameNotSet(this); 307 } 308 309 getDirectKeyField().setTable(getReferenceTable()); 310 getDirectKeyField().setIndex(1); 311 } 312 313 317 protected void initializeInsertQuery(AbstractSession session) { 318 super.initializeInsertQuery(session); 319 getInsertQuery().getModifyRow().put(getDirectKeyField(), null); 320 } 321 322 protected void initializeSelectionStatement(AbstractSession session) { 323 SQLSelectStatement statement = new SQLSelectStatement(); 324 statement.addTable(getReferenceTable()); 325 statement.addField((DatabaseField)getDirectField().clone()); 326 statement.addField((DatabaseField)getDirectKeyField().clone()); 327 statement.setWhereClause(getSelectionCriteria()); 328 statement.normalize(session, null); 329 getSelectionQuery().setSQLStatement(statement); 330 } 331 332 336 public boolean isDirectMapMapping() { 337 return true; 338 } 339 340 346 public void mergeChangesIntoObject(Object target, ChangeRecord changeRecord, Object source, MergeManager mergeManager) { 347 DirectMapContainerPolicy containerPolicy = (DirectMapContainerPolicy)getContainerPolicy(); 348 Map valueOfTarget = null; 349 AbstractSession session = mergeManager.getSession(); 350 351 HashMap addObjects = ((DirectMapChangeRecord)changeRecord).getAddObjects(); 353 HashMap removeObjects = ((DirectMapChangeRecord)changeRecord).getRemoveObjects(); 354 355 if ((isAttributeValueInstantiated(target)) && (!changeRecord.getOwner().isNew())) { 357 valueOfTarget = (Map)getRealCollectionAttributeValueFromObject(target, session); 358 } else { 359 valueOfTarget = (Map)containerPolicy.containerInstance(addObjects.size()); 361 } 362 363 if (!isAttributeValueInstantiated(target)) { 364 if (mergeManager.shouldMergeChangesIntoDistributedCache()) { 365 return; 366 } 367 368 Object valueOfSource = getRealCollectionAttributeValueFromObject(source, session); 369 for (Object iterator = containerPolicy.iteratorFor(valueOfSource); 370 containerPolicy.hasNext(iterator);) { 371 Object key = containerPolicy.next(iterator, session); 372 containerPolicy.addInto(key, ((Map)valueOfSource).get(key), valueOfTarget, session); 373 } 374 375 } else { 376 synchronized (valueOfTarget) { 377 for (Iterator i = removeObjects.keySet().iterator(); i.hasNext(); ) { 379 Object keyToRemove = i.next(); 380 containerPolicy.removeFrom(keyToRemove, (Object )null, valueOfTarget, session); 381 } 382 383 for (Iterator i = addObjects.keySet().iterator(); i.hasNext(); ) { 384 Object keyToAdd = i.next(); 385 Object nextItem = addObjects.get(keyToAdd); 386 if (mergeManager.shouldMergeChangesIntoDistributedCache()) { 387 if (!containerPolicy.contains(nextItem, valueOfTarget, session)) { 389 containerPolicy.addInto(keyToAdd, nextItem, valueOfTarget, session); 390 } 391 } else { 392 containerPolicy.addInto(keyToAdd, nextItem, valueOfTarget, session); 393 } 394 } 395 } 396 } 397 setRealAttributeValueInObject(target, valueOfTarget); 398 } 399 400 404 public void mergeIntoObject(Object target, boolean isTargetUnInitialized, Object source, MergeManager mergeManager) { 405 if (isTargetUnInitialized) { 406 if (mergeManager.shouldMergeWorkingCopyIntoOriginal() && (!isAttributeValueInstantiated(source))) { 408 setAttributeValueInObject(target, getIndirectionPolicy().getOriginalIndirectionObject(getAttributeValueFromObject(source), mergeManager.getSession())); 409 return; 410 } 411 } 412 if (!shouldMergeCascadeReference(mergeManager)) { 413 return; 415 } 416 if (mergeManager.shouldMergeOriginalIntoWorkingCopy()) { 417 if (!isAttributeValueInstantiated(target)) { 418 return; 421 } 422 } else if (!isAttributeValueInstantiated(source)) { 423 return; 426 } 427 428 Map valueOfSource = (Map)getRealCollectionAttributeValueFromObject(source, mergeManager.getSession()); 429 430 DirectMapContainerPolicy containerPolicy = (DirectMapContainerPolicy)getContainerPolicy(); 431 432 Object valueOfTarget = getRealCollectionAttributeValueFromObject(target, mergeManager.getSession()); 434 Object newContainer = containerPolicy.containerInstance(containerPolicy.sizeFor(valueOfSource)); 435 436 boolean fireChangeEvents = false; 437 valueOfTarget = newContainer; 438 439 for (Object sourceValuesIterator = containerPolicy.iteratorFor(valueOfSource); 440 containerPolicy.hasNext(sourceValuesIterator);) { 441 Object sourceKey = containerPolicy.next(sourceValuesIterator, mergeManager.getSession()); 442 containerPolicy.addInto(sourceKey, valueOfSource.get(sourceKey), valueOfTarget, mergeManager.getSession()); 443 } 444 445 setRealAttributeValueInObject(target, valueOfTarget); 447 } 448 449 453 public void postInsert(WriteObjectQuery query) throws DatabaseException { 454 Object objects; 455 AbstractRecord databaseRow = new DatabaseRecord(); 456 457 if (isReadOnly()) { 458 return; 459 } 460 461 objects = getRealCollectionAttributeValueFromObject(query.getObject(), query.getSession()); 462 DirectMapContainerPolicy containerPolicy = (DirectMapContainerPolicy)getContainerPolicy(); 463 if (containerPolicy.isEmpty(objects)) { 464 return; 465 } 466 467 prepareTranslationRow(query.getTranslationRow(), query.getObject(), query.getSession()); 468 for (int index = 0; index < getReferenceKeyFields().size(); index++) { 470 DatabaseField referenceKey = (DatabaseField)getReferenceKeyFields().elementAt(index); 471 DatabaseField sourceKey = (DatabaseField)getSourceKeyFields().elementAt(index); 472 Object sourceKeyValue = query.getTranslationRow().get(sourceKey); 473 databaseRow.put(referenceKey, sourceKeyValue); 474 } 475 476 Object keyIter = containerPolicy.iteratorFor(objects); 478 while (containerPolicy.hasNext(keyIter)) { 479 Object key = containerPolicy.next(keyIter, query.getSession()); 480 Object value = containerPolicy.valueFromKey(key, objects); 481 if (getKeyConverter() != null) { 482 key = getKeyConverter().convertObjectValueToDataValue(key, query.getSession()); 483 } 484 if (getValueConverter() != null) { 485 value = getValueConverter().convertObjectValueToDataValue(value, query.getSession()); 486 } 487 databaseRow.put(getDirectKeyField(), key); 488 databaseRow.put(getDirectField(), value); 489 if (query.shouldCascadeOnlyDependentParts()) { 491 Object [] event = new Object [3]; 493 event[0] = Insert; 494 event[1] = getInsertQuery(); 495 event[2] = databaseRow.clone(); 496 query.getSession().getCommitManager().addDataModificationEvent(this, event); 497 } else { 498 query.getSession().executeQuery(getInsertQuery(), databaseRow); 499 } 500 } 501 } 502 503 507 protected void postUpdateWithChangeSet(WriteObjectQuery writeQuery) throws DatabaseException { 508 509 ObjectChangeSet changeSet = writeQuery.getObjectChangeSet(); 510 DirectMapChangeRecord changeRecord = (DirectMapChangeRecord)changeSet.getChangesForAttributeNamed(this.getAttributeName()); 511 if (changeRecord == null){ 512 return; 513 } 514 for (int index = 0; index < getReferenceKeyFields().size(); index++) { 515 DatabaseField referenceKey = (DatabaseField)getReferenceKeyFields().elementAt(index); 516 DatabaseField sourceKey = (DatabaseField)getSourceKeyFields().elementAt(index); 517 Object sourceKeyValue = writeQuery.getTranslationRow().get(sourceKey); 518 writeQuery.getTranslationRow().put(referenceKey, sourceKeyValue); 519 } 520 for (Iterator iterator = changeRecord.getRemoveObjects().keySet().iterator(); iterator.hasNext();){ 521 Object key = iterator.next(); 522 AbstractRecord thisRow = (AbstractRecord)writeQuery.getTranslationRow().clone(); 523 if (getKeyConverter() != null){ 524 key = getKeyConverter().convertObjectValueToDataValue(key, writeQuery.getSession()); 525 } 526 thisRow.add(getDirectKeyField(), key); 527 Object [] event = new Object [3]; 529 event[0] = Delete; 530 event[1] = getDeleteQuery(); 531 event[2] = thisRow; 532 writeQuery.getSession().getCommitManager().addDataModificationEvent(this, event); 533 } 534 for (Iterator iterator = changeRecord.getAddObjects().keySet().iterator(); iterator.hasNext();){ 535 Object key = iterator.next(); 536 AbstractRecord thisRow = (AbstractRecord)writeQuery.getTranslationRow().clone(); 537 Object value = changeRecord.getAddObjects().get(key); 538 if (getKeyConverter() != null){ 539 key = getKeyConverter().convertObjectValueToDataValue(key, writeQuery.getSession()); 540 } 541 if (getValueConverter() != null){ 542 value = getValueConverter().convertObjectValueToDataValue(value, writeQuery.getSession()); 543 } 544 thisRow.add(getDirectKeyField(), key); 545 thisRow.add(getDirectField(), value); 546 Object [] event = new Object [3]; 548 event[0] = Insert; 549 event[1] = getInsertQuery(); 550 event[2] = thisRow; 551 writeQuery.getSession().getCommitManager().addDataModificationEvent(this, event); 552 } 553 } 554 555 560 public void removeFromCollectionChangeRecord(Object newKey, Object newValue, ObjectChangeSet objectChangeSet, UnitOfWorkImpl uow) throws DescriptorException { 561 DirectMapChangeRecord collectionChangeRecord = (DirectMapChangeRecord)objectChangeSet.getChangesForAttributeNamed(this.getAttributeName()); 562 if (collectionChangeRecord == null) { 563 collectionChangeRecord = new DirectMapChangeRecord(objectChangeSet); 564 collectionChangeRecord.setAttribute(getAttributeName()); 565 collectionChangeRecord.setMapping(this); 566 objectChangeSet.addChange(collectionChangeRecord); 567 } 568 collectionChangeRecord.addRemoveChange(newKey, newValue); 569 } 570 571 574 public void setDirectKeyField(DatabaseField keyField) { 575 directKeyField = keyField; 576 } 577 578 583 public void setDirectKeyFieldName(String fieldName) { 584 setDirectKeyField(new DatabaseField(fieldName)); 585 } 586 587 592 public void updateChangeRecord(Object clone, Object newValue, Object oldValue, ObjectChangeSet objectChangeSet, UnitOfWorkImpl uow) throws DescriptorException { 593 DirectMapChangeRecord collectionChangeRecord = (DirectMapChangeRecord)objectChangeSet.getChangesForAttributeNamed(this.getAttributeName()); 594 if (collectionChangeRecord == null) { 595 collectionChangeRecord = new DirectMapChangeRecord(objectChangeSet); 596 collectionChangeRecord.setAttribute(getAttributeName()); 597 collectionChangeRecord.setMapping(this); 598 objectChangeSet.addChange(collectionChangeRecord); 599 } 600 if (collectionChangeRecord.getOriginalCollection() == null){ 601 collectionChangeRecord.setOriginalCollection(oldValue); 602 } 603 collectionChangeRecord.setLatestCollection(newValue); 604 605 objectChangeSet.deferredDetectionRequiredOn(getAttributeName()); 606 } 607 608 616 public void useMapClass(Class concreteClass) { 617 if (!Helper.classImplementsInterface(concreteClass, ClassConstants.Map_Class)) { 618 throw DescriptorException.illegalContainerClass(concreteClass); 619 } 620 DirectMapContainerPolicy policy = new DirectMapContainerPolicy(concreteClass); 621 setContainerPolicy(policy); 622 } 623 624 632 public void useTransparentMap() { 633 setIndirectionPolicy(new TransparentIndirectionPolicy()); 634 useMapClass(ClassConstants.IndirectMap_Class); 635 } 636 637 644 public void setKeyClass(Class keyClass) { 645 TypeConversionConverter converter = new TypeConversionConverter(this); 646 converter.setObjectClass(keyClass); 647 setKeyConverter(converter); 648 } 649 650 656 public Class getKeyClass() { 657 if (!(getKeyConverter() instanceof TypeConversionConverter)) { 658 return null; 659 } 660 return ((TypeConversionConverter)getKeyConverter()).getObjectClass(); 661 } 662 663 670 public void setValueClass(Class valueClass) { 671 TypeConversionConverter converter = new TypeConversionConverter(this); 672 converter.setObjectClass(valueClass); 673 setValueConverter(converter); 674 } 675 676 681 public void simpleAddToCollectionChangeRecord(Object referenceKey, Object objectToAdd, ObjectChangeSet changeSet, AbstractSession session) { 682 DirectMapChangeRecord collectionChangeRecord = (DirectMapChangeRecord)changeSet.getChangesForAttributeNamed(getAttributeName()); 683 if (collectionChangeRecord == null) { 684 collectionChangeRecord = new DirectMapChangeRecord(changeSet); 685 collectionChangeRecord.setAttribute(getAttributeName()); 686 collectionChangeRecord.setMapping(this); 687 collectionChangeRecord.getAddObjects().put(referenceKey, objectToAdd); 688 changeSet.addChange(collectionChangeRecord); 689 } else { 690 if (collectionChangeRecord.getRemoveObjects().containsKey(referenceKey)) { 691 collectionChangeRecord.getRemoveObjects().remove(referenceKey); 692 } else { 693 collectionChangeRecord.getAddObjects().put(referenceKey, objectToAdd); 694 } 695 } 696 } 697 698 703 public void simpleRemoveFromCollectionChangeRecord(Object referenceKey, Object objectToRemove, ObjectChangeSet changeSet, AbstractSession session) { 704 DirectMapChangeRecord collectionChangeRecord = (DirectMapChangeRecord)changeSet.getChangesForAttributeNamed(getAttributeName()); 705 if (collectionChangeRecord == null) { 706 collectionChangeRecord = new DirectMapChangeRecord(changeSet); 707 collectionChangeRecord.setAttribute(getAttributeName()); 708 collectionChangeRecord.setMapping(this); 709 collectionChangeRecord.getRemoveObjects().put(referenceKey, objectToRemove); 710 changeSet.addChange(collectionChangeRecord); 711 } else { 712 if (collectionChangeRecord.getAddObjects().containsKey(referenceKey)) { 713 collectionChangeRecord.getAddObjects().remove(referenceKey); 714 } else { 715 collectionChangeRecord.getRemoveObjects().put(referenceKey, objectToRemove); 716 } 717 } 718 } 719 720 726 public Class getValueClass() { 727 if (!(getValueConverter() instanceof TypeConversionConverter)) { 728 return null; 729 } 730 return ((TypeConversionConverter)getValueConverter()).getObjectClass(); 731 } 732 733 737 public Object extractResultFromBatchQuery(DatabaseQuery query, AbstractRecord databaseRow, AbstractSession session, AbstractRecord argumentRow) { 738 Hashtable referenceDataByKey = null; 740 ContainerPolicy mappingContainerPolicy = getContainerPolicy(); 741 synchronized (query) { 742 referenceDataByKey = (Hashtable)query.getProperty("batched objects"); 743 mappingContainerPolicy = getContainerPolicy(); 744 if (referenceDataByKey == null) { 745 Vector rows = (Vector)session.executeQuery(query, argumentRow); 746 747 referenceDataByKey = new Hashtable(); 748 749 for (Enumeration rowsEnum = rows.elements(); rowsEnum.hasMoreElements();) { 750 AbstractRecord referenceRow = (AbstractRecord)rowsEnum.nextElement(); 751 Object referenceKey = referenceRow.get(getDirectKeyField()); 752 Object referenceValue = referenceRow.get(getDirectField()); 753 CacheKey eachCacheKey = new CacheKey(extractKeyFromReferenceRow(referenceRow, session)); 754 755 Object container = referenceDataByKey.get(eachCacheKey); 756 if (container == null) { 757 container = mappingContainerPolicy.containerInstance(); 758 referenceDataByKey.put(eachCacheKey, container); 759 } 760 761 if (getKeyConverter() != null) { 763 referenceKey = getKeyConverter().convertDataValueToObjectValue(referenceKey, query.getSession()); 764 } 765 766 if (getValueConverter() != null) { 768 referenceValue = getValueConverter().convertDataValueToObjectValue(referenceValue, query.getSession()); 769 } 770 771 mappingContainerPolicy.addInto(referenceKey, referenceValue, container, query.getSession()); 772 } 773 774 query.setProperty("batched objects", referenceDataByKey); 775 } 776 } 777 Object result = referenceDataByKey.get(new CacheKey(extractPrimaryKeyFromRow(databaseRow, session))); 778 779 if (result == null) { 781 return mappingContainerPolicy.containerInstance(); 782 } else { 783 return result; 784 } 785 } 786 } 787 | Popular Tags |