/**
   * INTERNAL: The mapping is initialized with the given session. This mapping is fully initialized
   * after this.
   */
  public void initialize(AbstractSession session) throws DescriptorException {
    // modified so that reference class on composite mappings is no longer mandatory
    String referenceClassName = getReferenceClassName();
    if (this.referenceClass == null && referenceClassName != null) {
      if (!referenceClassName.equals(XMLConstants.UNKNOWN_OR_TRANSIENT_CLASS)) {
        setReferenceClass(
            session
                .getDatasourcePlatform()
                .getConversionManager()
                .convertClassNameToClass(referenceClassName));
      }
    }
    initializeReferenceDescriptorAndField(session);
    ContainerPolicy cp = getContainerPolicy();
    if (cp != null) {
      if (cp.getContainerClass() == null) {
        Class cls =
            session
                .getDatasourcePlatform()
                .getConversionManager()
                .convertClassNameToClass(cp.getContainerClassName());
        cp.setContainerClass(cls);
      }
      if (cp instanceof MapContainerPolicy) {
        initializeMapContainerPolicy(session, (MapContainerPolicy) cp);
      }
    }

    if (null != getContainerAccessor()) {
      getContainerAccessor().initializeAttributes(this.referenceClass);
    }
  }
  /** INTERNAL: Get a value from the object and set that in the respective field of the row. */
  @Override
  public Object valueFromObject(Object object, DatabaseField field, AbstractSession session) {
    // First check if the value can be obtained from the value holder's row.
    AbstractRecord referenceRow =
        getIndirectionPolicy().extractReferenceRow(getAttributeValueFromObject(object));
    if (referenceRow != null) {
      Object value = referenceRow.get(field);

      // Must ensure the classification to get a cache hit.
      try {
        value = session.getDatasourcePlatform().convertObject(value, getFieldClassification(field));
      } catch (ConversionException e) {
        throw ConversionException.couldNotBeConverted(this, getDescriptor(), e);
      }

      return value;
    }

    // 2.5.1.6 PWK.  added to support batch reading on variable one to ones
    Object referenceObject = getRealAttributeValueFromObject(object, session);
    String queryKeyName = (String) getSourceToTargetQueryKeyNames().get(field);
    ClassDescriptor objectDescriptor = session.getDescriptor(referenceObject.getClass());
    DatabaseField targetField =
        objectDescriptor.getObjectBuilder().getTargetFieldForQueryKeyName(queryKeyName);

    if (targetField == null) {
      return null;
    }

    return objectDescriptor
        .getObjectBuilder()
        .extractValueFromObjectForField(referenceObject, targetField, session);
  }
Ejemplo n.º 3
0
  /** Set the value on the underlying POJO, unwrapping values as necessary. */
  public void setDeclaredProperty(int propertyIndex, Object value) {
    SDOProperty declaredProperty =
        (SDOProperty) dataObject.getType().getDeclaredProperties().get(propertyIndex);
    if (declaredProperty.getType().isChangeSummaryType()) {
      return;
    }

    Mapping mapping = this.getJAXBMappingForProperty(declaredProperty);

    Object newValue = value;
    Object oldValue = mapping.getAttributeAccessor().getAttributeValueFromObject(entity);

    if (declaredProperty.getType().isDataType()) {
      if (!declaredProperty.isMany()) {
        AbstractSession session =
            ((JAXBContext) jaxbHelperContext.getJAXBContext()).getXMLContext().getSession(entity);
        XMLDirectMapping directMapping = (XMLDirectMapping) mapping;
        if (directMapping.hasConverter()) {
          newValue = directMapping.getConverter().convertDataValueToObjectValue(newValue, session);
        } else {
          CoreField field = mapping.getField();
          newValue =
              session
                  .getDatasourcePlatform()
                  .getConversionManager()
                  .convertObject(
                      newValue,
                      descriptor.getObjectBuilder().getFieldClassification((XMLField) field));
        }
      }
      mapping.setAttributeValueInObject(entity, newValue);
    } else if (declaredProperty.isMany()) {
      // Get a ListWrapper and set it's current elements
      ListWrapper listWrapper = (ListWrapper) getDeclaredProperty(propertyIndex);
      listWrapper.addAll((List) newValue);
    } else {
      // OLD VALUE
      if (mapping.isAbstractCompositeObjectMapping()) {
        XMLCompositeObjectMapping compositeMapping = (XMLCompositeObjectMapping) mapping;
        if (oldValue != null && compositeMapping.getContainerAccessor() != null) {
          compositeMapping.getContainerAccessor().setAttributeValueInObject(oldValue, null);
        }
      }

      // NEW VALUE
      newValue = jaxbHelperContext.unwrap((DataObject) value);
      mapping.getAttributeAccessor().setAttributeValueInObject(entity, newValue);
      if (mapping.isAbstractCompositeObjectMapping()) {
        XMLCompositeObjectMapping compositeMapping = (XMLCompositeObjectMapping) mapping;
        if (value != null && compositeMapping.getContainerAccessor() != null) {
          compositeMapping.getContainerAccessor().setAttributeValueInObject(newValue, entity);
        }
      }
    }
  }
  /** INTERNAL: Return the implementor for a specified type */
  protected Object getImplementorForType(Object type, AbstractSession session) {
    if (type == null) {
      return getTypeIndicatorTranslation().get(Helper.getNullWrapper());
    }

    // Must ensure the type is the same, i.e. Integer != BigDecimal.
    try {
      type = session.getDatasourcePlatform().convertObject(type, getTypeField().getType());
    } catch (ConversionException e) {
      throw ConversionException.couldNotBeConverted(this, getDescriptor(), e);
    }

    return getTypeIndicatorTranslation().get(type);
  }
 /**
  * INTERNAL: The mapping is initialized with the given session. This mapping is fully initialized
  * after this.
  */
 public void initialize(AbstractSession session) throws DescriptorException {
   super.initialize(session);
   ContainerPolicy cp = getContainerPolicy();
   if (cp != null) {
     if (cp.getContainerClass() == null) {
       Class cls =
           session
               .getDatasourcePlatform()
               .getConversionManager()
               .convertClassNameToClass(cp.getContainerClassName());
       cp.setContainerClass(cls);
     }
   }
 }
 /**
  * INTERNAL: Extract the primary key values from the row, then create an
  * org.eclipse.persistence.internal.oxm.Reference instance and stored it on the session's
  * org.eclipse.persistence.internal.oxm.ReferenceResolver.
  */
 public Object readFromRowIntoObject(
     AbstractRecord databaseRow,
     JoinedAttributeManager joinManager,
     Object targetObject,
     ObjectBuildingQuery sourceQuery,
     AbstractSession executionSession)
     throws DatabaseException {
   ClassDescriptor descriptor = sourceQuery.getSession().getClassDescriptor(getReferenceClass());
   ContainerPolicy cp = this.getContainerPolicy();
   Vector pkFieldNames = referenceDescriptor.getPrimaryKeyFieldNames();
   Vector primaryKeyValues = new Vector();
   primaryKeyValues.setSize(pkFieldNames.size());
   HashMap primaryKeyMap = new HashMap();
   // for each source xmlField, get the value from the row and store
   for (Iterator fieldIt = getFields().iterator(); fieldIt.hasNext(); ) {
     XMLField fld = (XMLField) fieldIt.next();
     XMLField tgtFld = (XMLField) getSourceToTargetKeyFieldAssociations().get(fld);
     Object fieldValue = databaseRow.getValues(fld);
     if ((fieldValue == null)
         || (fieldValue instanceof String)
         || !(fieldValue instanceof Vector)) {
       return cp.containerInstance();
     }
     // fix for bug# 5687430
     // need to get the actual type of the target (i.e. int, String, etc.)
     // and use the converted value when checking the cache.
     XMLConversionManager xmlConversionManager =
         (XMLConversionManager) executionSession.getDatasourcePlatform().getConversionManager();
     Vector newValues = new Vector();
     for (Iterator valIt = ((Vector) fieldValue).iterator(); valIt.hasNext(); ) {
       for (StringTokenizer stok = new StringTokenizer((String) valIt.next());
           stok.hasMoreTokens(); ) {
         Object value =
             xmlConversionManager.convertObject(
                 stok.nextToken(), descriptor.getTypedField(tgtFld).getType());
         if (value != null) {
           newValues.add(value);
         }
       }
     }
     primaryKeyMap.put(tgtFld.getXPath(), newValues);
   }
   // store the Reference instance on the resolver for use during mapping resolution phase
   ReferenceResolver resolver = ReferenceResolver.getInstance(sourceQuery.getSession());
   if (resolver != null) {
     resolver.addReference(new Reference(this, targetObject, referenceClass, primaryKeyMap));
   }
   return null;
 }
  private Object convertToSimpleTypeIfPresent(
      Object objectToAdd, AbstractRecord nestedRow, AbstractSession executionSession) {
    String stringValue = null;

    Element theElement = ((Element) ((DOMRecord) nestedRow).getDOM());
    Node textchild = theElement.getFirstChild();

    if ((textchild != null) && (textchild.getNodeType() == Node.TEXT_NODE)) {
      stringValue = ((Text) textchild).getNodeValue();
      if (stringValue != null
          && getKeepAsElementPolicy() != UnmarshalKeepAsElementPolicy.KEEP_UNKNOWN_AS_ELEMENT
          && getKeepAsElementPolicy() != UnmarshalKeepAsElementPolicy.KEEP_ALL_AS_ELEMENT) {
        objectToAdd = stringValue;
      }
    }
    if ((stringValue == null) || stringValue.length() == 0) {
      return objectToAdd;
    }

    String type =
        theElement.getAttributeNS(
            javax.xml.XMLConstants.W3C_XML_SCHEMA_INSTANCE_NS_URI,
            XMLConstants.SCHEMA_TYPE_ATTRIBUTE);
    if ((null != type) && type.length() > 0) {
      XPathFragment typeFragment = new XPathFragment(type);
      String namespaceURI =
          ((DOMRecord) nestedRow).resolveNamespacePrefix(typeFragment.getPrefix());
      typeFragment.setNamespaceURI(namespaceURI);
      QName schemaTypeQName = new QName(namespaceURI, typeFragment.getLocalName());
      ConversionManager conversionManager =
          (ConversionManager) executionSession.getDatasourcePlatform().getConversionManager();
      Class theClass = conversionManager.javaType(schemaTypeQName);
      if (theClass != null) {
        objectToAdd = conversionManager.convertObject(stringValue, theClass, schemaTypeQName);
      }
    }
    return objectToAdd;
  }
  /**
   * INTERNAL: Create (if necessary) and populate a reference object that will be used during the
   * mapping reference resolution phase after unmarshalling is complete.
   *
   * @param record
   * @param xmlField
   * @param object
   * @param session
   * @return
   */
  public void buildReference(
      UnmarshalRecord record, XMLField xmlField, Object object, AbstractSession session) {
    ReferenceResolver resolver = ReferenceResolver.getInstance(session);
    if (resolver == null) {
      return;
    }

    Object srcObject = record.getCurrentObject();
    Reference reference = resolver.getReference(this, srcObject);
    // if reference is null, create a new instance and set it on the resolver
    if (reference == null) {
      reference = new Reference(this, srcObject, getReferenceClass(), new HashMap());
      resolver.addReference(reference);
    }

    XMLField tgtFld = (XMLField) getSourceToTargetKeyFieldAssociations().get(xmlField);
    String tgtXPath = tgtFld.getXPath();
    Vector pks;
    HashMap primaryKeyMap = reference.getPrimaryKeyMap();
    if (primaryKeyMap.containsKey(tgtXPath)) {
      pks = (Vector) primaryKeyMap.get(tgtXPath);
    } else {
      pks = new Vector();
      primaryKeyMap.put(tgtXPath, pks);
    }

    ClassDescriptor descriptor = session.getClassDescriptor(getReferenceClass());
    Class type = descriptor.getTypedField(tgtFld).getType();
    XMLConversionManager xmlConversionManager =
        (XMLConversionManager) session.getDatasourcePlatform().getConversionManager();
    for (StringTokenizer stok = new StringTokenizer((String) object); stok.hasMoreTokens(); ) {
      Object value = xmlConversionManager.convertObject(stok.nextToken(), type);
      if (value != null) {
        pks.add(value);
      }
    }
  }
 protected String getValueToWrite(QName schemaType, Object value, AbstractSession session) {
   return (String)
       ((XMLConversionManager) session.getDatasourcePlatform().getConversionManager())
           .convertObject(value, ClassConstants.STRING, schemaType);
 }
Ejemplo n.º 10
0
 /** INTERNAL: */
 public void validationAfterDescriptorInitialization(AbstractSession session) {
   Hashtable mapped = new Hashtable();
   for (int operation = INSERT; operation <= UPDATE; operation++) {
     if ((main[operation][MAPPED] != null) && !main[operation][MAPPED].isEmpty()) {
       Iterator it = main[operation][MAPPED].iterator();
       while (it.hasNext()) {
         DatabaseField field = (DatabaseField) it.next();
         mapped.put(field, field);
       }
     }
   }
   if (!mapped.isEmpty()) {
     for (Enumeration fields = getDescriptor().getFields().elements();
         fields.hasMoreElements(); ) {
       DatabaseField fieldInDescriptor = (DatabaseField) fields.nextElement();
       DatabaseField fieldInMain = (DatabaseField) mapped.get(fieldInDescriptor);
       if (fieldInMain != null) {
         if (fieldInMain.getType() == null) {
           if (getDescriptor().isReturnTypeRequiredForReturningPolicy()) {
             session
                 .getIntegrityChecker()
                 .handleError(
                     DescriptorException.returningPolicyMappedFieldTypeNotSet(
                         fieldInMain.getName(), getDescriptor()));
           }
         } else if (isThereATypeConflict(fieldInMain, fieldInDescriptor)) {
           session
               .getIntegrityChecker()
               .handleError(
                   DescriptorException.returningPolicyAndDescriptorFieldTypeConflict(
                       fieldInMain.getName(),
                       fieldInMain.getType().getName(),
                       fieldInDescriptor.getType().getName(),
                       getDescriptor()));
         }
       }
     }
   }
   if (!(session.getDatasourcePlatform() instanceof DatabasePlatform)) {
     // don't attempt further diagnostics on non-relational platforms
     return;
   }
   WriteObjectQuery[] query = {
     getDescriptor().getQueryManager().getInsertQuery(),
     getDescriptor().getQueryManager().getUpdateQuery()
   };
   String[] queryTypeName = {"InsertObjectQuery", "UpdateObjectQuery"};
   for (int operation = INSERT; operation <= UPDATE; operation++) {
     if ((main[operation][ALL] != null) && !main[operation][ALL].isEmpty()) {
       // this operation requires some fields to be returned
       if ((query[operation] == null) || (query[operation].getDatasourceCall() == null)) {
         if (!session.getPlatform().canBuildCallWithReturning()) {
           session
               .getIntegrityChecker()
               .handleError(
                   DescriptorException.noCustomQueryForReturningPolicy(
                       queryTypeName[operation],
                       Helper.getShortClassName(session.getPlatform()),
                       getDescriptor()));
         }
       } else if (query[operation].getDatasourceCall() instanceof StoredProcedureCall) {
         // SQLCall with custom SQL calculates its outputRowFields later (in prepare() method) -
         // that's why SQLCall can't be verified here.
         DatabaseCall customCall = (DatabaseCall) query[operation].getDatasourceCall();
         Enumeration outputRowFields = customCall.getOutputRowFields().elements();
         Collection notFoundInOutputRow = createCollection();
         notFoundInOutputRow.addAll(main[operation][ALL]);
         while (outputRowFields.hasMoreElements()) {
           notFoundInOutputRow.remove(outputRowFields.nextElement());
         }
         if (!notFoundInOutputRow.isEmpty()) {
           Iterator it = notFoundInOutputRow.iterator();
           while (it.hasNext()) {
             DatabaseField field = (DatabaseField) it.next();
             session
                 .getIntegrityChecker()
                 .handleError(
                     DescriptorException.customQueryAndReturningPolicyFieldConflict(
                         field.getName(), queryTypeName[operation], getDescriptor()));
           }
         }
       }
     }
   }
 }
  public Object valueFromRow(
      AbstractRecord row,
      JoinedAttributeManager joinManager,
      ObjectBuildingQuery query,
      AbstractSession executionSession) {
    ContainerPolicy cp = this.getContainerPolicy();

    Object fieldValue = row.getValues(this.getField());
    if (fieldValue == null) {
      if (reuseContainer) {
        Object currentObject = ((XMLRecord) row).getCurrentObject();
        Object container = getAttributeAccessor().getAttributeValueFromObject(currentObject);
        return container != null ? container : cp.containerInstance();
      } else {
        return cp.containerInstance();
      }
    }

    Vector fieldValues = this.getDescriptor().buildDirectValuesFromFieldValue(fieldValue);
    if (fieldValues == null) {
      if (reuseContainer) {
        Object currentObject = ((XMLRecord) row).getCurrentObject();
        Object container = getAttributeAccessor().getAttributeValueFromObject(currentObject);
        return container != null ? container : cp.containerInstance();
      } else {
        return cp.containerInstance();
      }
    }

    Object result = null;
    if (reuseContainer) {
      Object currentObject = ((XMLRecord) row).getCurrentObject();
      Object container = getAttributeAccessor().getAttributeValueFromObject(currentObject);
      result = container != null ? container : cp.containerInstance();
    } else {
      result = cp.containerInstance(fieldValues.size());
    }

    for (Enumeration stream = fieldValues.elements(); stream.hasMoreElements(); ) {
      Object element = stream.nextElement();

      // PERF: Direct variable access.
      // Object value = row.get(field);
      // Object fieldValue = null;
      XMLUnmarshaller unmarshaller = ((XMLRecord) row).getUnmarshaller();
      if (element instanceof String) {
        if (this.isSwaRef() && (unmarshaller.getAttachmentUnmarshaller() != null)) {
          fieldValue =
              unmarshaller.getAttachmentUnmarshaller().getAttachmentAsDataHandler((String) element);
        } else if (!this.isSwaRef()) {
          // should be base64
          byte[] bytes =
              ((XMLConversionManager)
                      executionSession.getDatasourcePlatform().getConversionManager())
                  .convertSchemaBase64ToByteArray(element);
          fieldValue = bytes;
        }
      } else {
        // this was an element, so do the XOP/SWAREF/Inline binary cases for an element
        XMLRecord record = (XMLRecord) element;
        record.setSession(executionSession);

        if ((unmarshaller.getAttachmentUnmarshaller() != null)
            && unmarshaller.getAttachmentUnmarshaller().isXOPPackage()
            && !this.isSwaRef()
            && !this.shouldInlineBinaryData()) {
          // look for the include element:
          String xpath = XMLConstants.EMPTY_STRING;

          //  need a prefix for XOP
          String prefix = null;
          NamespaceResolver descriptorResolver =
              ((XMLDescriptor) getDescriptor()).getNamespaceResolver();
          if (descriptorResolver != null) {
            prefix = descriptorResolver.resolveNamespaceURI(XMLConstants.XOP_URL);
          }
          if (prefix == null) {
            prefix = XMLConstants.XOP_PREFIX;
          }
          NamespaceResolver tempResolver = new NamespaceResolver();
          tempResolver.put(prefix, XMLConstants.XOP_URL);
          xpath = prefix + XMLConstants.COLON + INCLUDE + "/@href";
          XMLField field = new XMLField(xpath);
          field.setNamespaceResolver(tempResolver);
          String includeValue = (String) record.get(field);
          if (element != null && includeValue != null) {
            if ((getAttributeElementClass() == ClassConstants.ABYTE)
                || (getAttributeElementClass() == ClassConstants.APBYTE)) {
              fieldValue =
                  unmarshaller.getAttachmentUnmarshaller().getAttachmentAsByteArray(includeValue);
            } else {
              fieldValue =
                  unmarshaller.getAttachmentUnmarshaller().getAttachmentAsDataHandler(includeValue);
            }
          } else {
            // If we didn't find the Include element, check for inline
            fieldValue = record.get(XMLConstants.TEXT);
            // should be a base64 string
            fieldValue =
                ((XMLConversionManager)
                        executionSession.getDatasourcePlatform().getConversionManager())
                    .convertSchemaBase64ToByteArray(fieldValue);
          }
        } else if ((unmarshaller.getAttachmentUnmarshaller() != null) && isSwaRef()) {
          String refValue = (String) record.get(XMLConstants.TEXT);
          if (refValue != null) {
            fieldValue =
                unmarshaller.getAttachmentUnmarshaller().getAttachmentAsDataHandler(refValue);
          }
        } else {
          fieldValue = record.get(XMLConstants.TEXT);
          // should be a base64 string
          fieldValue =
              ((XMLConversionManager)
                      executionSession.getDatasourcePlatform().getConversionManager())
                  .convertSchemaBase64ToByteArray(fieldValue);
        }
      }
      Object attributeValue = fieldValue;
      if (getValueConverter() != null) {
        if (getValueConverter() instanceof XMLConverter) {
          attributeValue =
              ((XMLConverter) getValueConverter())
                  .convertDataValueToObjectValue(fieldValue, executionSession, unmarshaller);
        } else {
          attributeValue =
              getValueConverter().convertDataValueToObjectValue(fieldValue, executionSession);
        }
      }

      cp.addInto(attributeValue, result, query.getSession());
    }
    return result;
  }
  public Object getValueToWrite(
      Object value,
      Object parent,
      XMLRecord record,
      XMLField field,
      XMLField includeField,
      AbstractSession session) {
    XMLMarshaller marshaller = record.getMarshaller();
    Object element = value;
    boolean isAttribute = ((XMLField) getField()).getLastXPathFragment().isAttribute();
    if (getValueConverter() != null) {
      Converter converter = getValueConverter();
      if (converter instanceof XMLConverter) {
        element =
            ((XMLConverter) converter)
                .convertObjectValueToDataValue(element, session, record.getMarshaller());
      } else {
        element = converter.convertObjectValueToDataValue(element, session);
      }
    }

    if (isAttribute) {
      if (isSwaRef() && (marshaller.getAttachmentMarshaller() != null)) {
        // should be a DataHandler here
        try {
          String id =
              marshaller.getAttachmentMarshaller().addSwaRefAttachment((DataHandler) element);
          element = id;
        } catch (ClassCastException cce) {
          throw XMLMarshalException.invalidSwaRefAttribute(getAttributeClassification().getName());
        }
      } else {
        // inline case
        XMLBinaryDataHelper.EncodedData data =
            XMLBinaryDataHelper.getXMLBinaryDataHelper()
                .getBytesForBinaryValue(
                    element, record.getMarshaller(), mimeTypePolicy.getMimeType(parent));
        String base64Value =
            ((XMLConversionManager) session.getDatasourcePlatform().getConversionManager())
                .buildBase64StringFromBytes(data.getData());
        element = base64Value;
      }
    } else {
      if (record.isXOPPackage() && !isSwaRef() && !shouldInlineBinaryData()) {
        // write as attachment
        String c_id = XMLConstants.EMPTY_STRING;
        byte[] bytes = null;
        if ((getAttributeElementClass() == ClassConstants.ABYTE)
            || (getAttributeElementClass() == ClassConstants.APBYTE)) {
          if (getAttributeElementClass() == ClassConstants.ABYTE) {
            element =
                session
                    .getDatasourcePlatform()
                    .getConversionManager()
                    .convertObject(element, ClassConstants.APBYTE);
          }
          bytes = (byte[]) element;
          c_id =
              marshaller
                  .getAttachmentMarshaller()
                  .addMtomAttachment(
                      bytes,
                      0,
                      bytes.length,
                      this.mimeTypePolicy.getMimeType(parent),
                      field.getLastXPathFragment().getLocalName(),
                      field.getLastXPathFragment().getNamespaceURI());
        } else if (getAttributeElementClass()
            == XMLBinaryDataHelper.getXMLBinaryDataHelper().DATA_HANDLER) {
          c_id =
              marshaller
                  .getAttachmentMarshaller()
                  .addMtomAttachment(
                      (DataHandler) element,
                      field.getLastXPathFragment().getLocalName(),
                      field.getLastXPathFragment().getNamespaceURI());
          if (c_id == null) {
            XMLBinaryDataHelper.EncodedData data =
                XMLBinaryDataHelper.getXMLBinaryDataHelper()
                    .getBytesForBinaryValue(
                        element, marshaller, this.mimeTypePolicy.getMimeType(parent));
            bytes = data.getData();
          }
        } else {
          XMLBinaryDataHelper.EncodedData data =
              XMLBinaryDataHelper.getXMLBinaryDataHelper()
                  .getBytesForBinaryValue(
                      element, marshaller, this.mimeTypePolicy.getMimeType(parent));
          bytes = data.getData();
          c_id =
              marshaller
                  .getAttachmentMarshaller()
                  .addMtomAttachment(
                      bytes,
                      0,
                      bytes.length,
                      data.getMimeType(),
                      field.getLastXPathFragment().getLocalName(),
                      field.getLastXPathFragment().getNamespaceURI());
        }

        if (c_id == null) {
          element = bytes;
        } else {
          DOMRecord include = new DOMRecord(field.getLastXPathFragment().getLocalName());
          include.setSession(session);
          include.put(includeField, c_id);
          element = include;

          // Need to call setAttributeNS on the record, unless the xop prefix
          // is defined on the descriptor's resolver already
          NamespaceResolver resolver = ((XMLField) getField()).getNamespaceResolver();
          if (resolver == null || resolver.resolveNamespaceURI(XMLConstants.XOP_URL) == null) {
            resolver = new NamespaceResolver();
            resolver.put(XMLConstants.XOP_PREFIX, XMLConstants.XOP_URL);
            String xpath = XMLConstants.XOP_PREFIX + XMLConstants.COLON + INCLUDE;
            XMLField incField = new XMLField(xpath);
            incField.setNamespaceResolver(resolver);
            Object obj = include.getIndicatingNoEntry(incField);
            if (obj != null && obj instanceof DOMRecord) {
              if (((DOMRecord) obj).getDOM().getNodeType() == Node.ELEMENT_NODE) {
                ((Element) ((DOMRecord) obj).getDOM())
                    .setAttributeNS(
                        XMLConstants.XMLNS_URL,
                        XMLConstants.XMLNS + XMLConstants.COLON + XMLConstants.XOP_PREFIX,
                        XMLConstants.XOP_URL);
              }
            }
          }
        }
      } else if (isSwaRef() && (marshaller.getAttachmentMarshaller() != null)) {
        // element should be a data-handler
        try {
          String c_id =
              marshaller.getAttachmentMarshaller().addSwaRefAttachment((DataHandler) element);
          element = c_id;
        } catch (Exception ex) {
        }
      } else {
        // inline
        if (!((getAttributeElementClass() == ClassConstants.ABYTE)
            || (getAttributeElementClass() == ClassConstants.APBYTE))) {
          element =
              XMLBinaryDataHelper.getXMLBinaryDataHelper()
                  .getBytesForBinaryValue(
                      element, marshaller, this.mimeTypePolicy.getMimeType(parent))
                  .getData();
        }
      }
    }
    return element;
  }