public String getName() { return mmd.getName(); }
if (mmd.hasCollection()) Collection coll = (Collection) fieldValuesForOwner.get(mmd.getAbsoluteFieldNumber()); if (coll == null) Class instanceType = SCOUtils.getContainerInstanceType(mmd.getType(), mmd.getOrderMetaData() != null); coll = (Collection<Object>) instanceType.newInstance(); fieldValuesForOwner.put(mmd.getAbsoluteFieldNumber(), coll); else if (mmd.hasArray()) Object arr = fieldValuesForOwner.get(mmd.getAbsoluteFieldNumber()); if (arr == null) arr = Array.newInstance(mmd.getType().getComponentType(), 1); Array.set(arr, 0, element); Object array = Array.newInstance(mmd.getType().getComponentType(), currentSize+1); for (int i=0;i<currentSize;i++)
String fieldTypeName = mmd.getTypeName(); if (mmd.getFieldTypes() != null && mmd.getFieldTypes().length == 1) fieldTypeName = mmd.getFieldTypes()[0]; if (mmd.hasCollection()) fieldTypeName = mmd.getCollection().getElementType(); else if (mmd.hasArray()) fieldTypeName = mmd.getArray().getElementType(); else if (mmd.hasMap()) fieldTypeName = mmd.getMap().getKeyType(); fieldTypeName = mmd.getMap().getValueType();
@Override public boolean useBackedSCOWrapperForMember(AbstractMemberMetaData mmd, ExecutionContext ec) { if ((mmd.hasCollection() || mmd.hasMap()) && mmd.hasExtension(MetaData.EXTENSION_MEMBER_TYPE_CONVERTER_NAME)) { // The only case where we don't use backed wrappers is for a Collection/Map that is using a converter for the whole field (so storing as a single column) return false; } return true; }
public static boolean isEmbeddedField(AbstractMemberMetaData mmd) { return mmd.getEmbeddedMetaData() != null || (mmd.getElementMetaData() != null && mmd.getElementMetaData().getEmbeddedMetaData() != null); }
/** * Initialize this JavaTypeMapping with the given DatastoreAdapter for the given metadata. * @param mmd FieldMetaData for the field to be mapped (if any) * @param table The datastore container storing this mapping (if any) * @param clr the ClassLoaderResolver */ public void initialize(AbstractMemberMetaData mmd, Table table, ClassLoaderResolver clr) { initialize(mmd, table, clr, mmd.getEmbeddedMetaData(), mmd.getTypeName(), ObjectProvider.EMBEDDED_PC); }
ClassLoaderResolver clr = ec.getClassLoaderResolver(); AbstractMemberMetaData mmd = op.getClassMetaData().getMetaDataForManagedMemberAtAbsolutePosition(fieldNumber); RelationType relationType = mmd.getRelationType(clr); if (relationType == RelationType.NONE) else if (mmd.getEmbeddedMetaData() != null) final AbstractClassMetaData cmd = ec.getMetaDataManager().getMetaDataForClass(mmd.getType(), clr); final NodeList nList = ((Element) node).getElementsByTagName(mmd.getName()); if (nList.getLength() == 1) AbstractMemberMetaData relatedMmd = mmd.getRelatedMemberMetaDataForObject(clr, op.getObject(), related); relatedSM.replaceField(relatedMmd.getAbsoluteFieldNumber(), op.getObject()); if (mmd.hasCollection()) AbstractClassMetaData cmd2 = ec.getMetaDataManager().getMetaDataForClass(mmd.getCollection().getElementType(), clr); if (cmd2 == null) throw new NucleusUserException("Cannot find metadata for element type " + mmd.getCollection().getElementType() + " for field=" + mmd.getFullFieldName()); AbstractMemberMetaData relatedMmd = relatedSM.getClassMetaData().getMetaDataForMember(mmd.getMappedBy()); relatedSM.replaceField(relatedMmd.getAbsoluteFieldNumber(), op.getObject()); else if (mmd.hasArray()) else if (mmd.hasMap())
for (int i=0;i<mmds.length;i++) int relationType = mmds[i].getRelationType(clr); Attribute attr = null; switch (relationType) if (mmds[i].hasCollection()) if (List.class.isAssignableFrom(mmds[i].getType())) else if (Set.class.isAssignableFrom(mmds[i].getType())) else if (mmds[i].hasMap()) else if (mmds[i].hasArray()) if (mmds[i].getType().isArray()) attributes.put(mmds[i].getName(), attr);
@Override public Object fetch() { RelationType relType = mmd.getRelationType(clr); if (relType == RelationType.ONE_TO_ONE_UNI || relType == RelationType.ONE_TO_ONE_BI) { Set<String> objectClasses = LDAPUtils.getObjectClassesForClass(effectiveClassMetaData); if (objectClasses.isEmpty()) { // embedded into the current entry return fetchEmbedded(); } // embedded as child-entry return fetchFromChild(); } else if (relType == RelationType.ONE_TO_MANY_UNI || relType == RelationType.ONE_TO_MANY_BI) { if (mmd.hasCollection()) { Class instanceType = mmd.getType(); instanceType = org.datanucleus.store.types.SCOUtils.getContainerInstanceType(instanceType, mmd.getOrderMetaData() != null); Collection<Object> coll = fetchFromChildren(instanceType); return SCOUtils.wrapSCOField(op, fieldNumber, coll, true); } } // TODO Localise this throw new NucleusException("Cant obtain value for field " + mmd.getFullFieldName() + " since type=" + mmd.getTypeName() + " is not supported for this datastore"); }
RelationType relType = mmd.getRelationType(clr); if (RelationType.isRelationSingleValued(relType)) mmd.setDependent(true); return getHierarchicalMappedChild(mmd, op); if (mmd.hasCollection()) Collection<Object> coll = getHierarchicalMappedChildren(mmd.getCollection().getElementType(), mmd.getMappedBy(), mmd, op); return SCOUtils.wrapSCOField(op, fieldNumber, coll, true); throw new NucleusException("Cant obtain value for field " + mmd.getFullFieldName() + " since type=" + mmd.getTypeName() + " is not supported for this datastore");
RelationType relationType = mmd.getRelationType(clr); if (relationType == RelationType.ONE_TO_ONE_UNI || relationType == RelationType.ONE_TO_ONE_BI) EmbeddedMetaData embeddedMetaData = mmd.getEmbeddedMetaData(); insertAsChild(value, embeddedMetaData); if (mmd.hasCollection()) EmbeddedMetaData embeddedMetaData = mmd.getElementMetaData().getEmbeddedMetaData(); Collection c = (Collection) value; for (Object pc : c) throw new NucleusException("Field " + mmd.getFullFieldName() + " cannot be persisted because type=" + mmd.getTypeName() + " with relation type " + mmd.getRelationType(clr) + " is not supported for this datastore");
public Type<E> getElementType() { if (mmd.hasCollection()) { Class elementCls = owner.model.getClassLoaderResolver().classForName(mmd.getCollection().getElementType()); return owner.model.getType(elementCls); } else if (mmd.hasArray()) { Class elementCls = owner.model.getClassLoaderResolver().classForName(mmd.getArray().getElementType()); return owner.model.getType(elementCls); } return null; } }
private Object fetchEmbeddedObject(AbstractMemberMetaData ammd) { if (objectProvider == null) return null; AbstractClassMetaData cmd = storeManager.getMetaDataManager().getMetaDataForClass(ammd.getType(), ec.getClassLoaderResolver()); Object obj = null; try { obj = ec.getClassLoaderResolver().classForName(cmd.getFullClassName(), true).newInstance(); for (AbstractMemberMetaData eammd : ammd.getEmbeddedMetaData().getMemberMetaData()) { PersistenceUtils.setFieldValue(ammd.getType(), cmd, cmd.getAbsolutePositionOfMember(eammd.getName()), obj, fetchObjectField(eammd, null)); } ec.findObjectProviderForEmbedded(obj, objectProvider, ammd); } catch (Exception e) { throw new NucleusUserException(e.getMessage(), e); } return obj; } }
/** * Method to prepare a field mapping for use in the datastore. * This creates the column in the table. */ protected void prepareDatastoreMapping() { if (containerIsStoredInSingleColumn()) { // Serialised collections/maps/arrays should just create a (typically BLOB) column as normal in the owning table MappingManager mmgr = storeMgr.getMappingManager(); ColumnMetaData colmd = null; ColumnMetaData[] colmds = mmd.getColumnMetaData(); if (colmds != null && colmds.length > 0) { // Try the field column info colmd = colmds[0]; } else if (mmd.hasCollection() || mmd.hasArray()) { // Fallback to the element column info colmds = (mmd.getElementMetaData() != null) ? mmd.getElementMetaData().getColumnMetaData() : null; if (colmds != null && colmds.length > 0) { colmd = colmds[0]; } } Column col = mmgr.createColumn(this, getJavaTypeForDatastoreMapping(0), colmd); mmgr.createDatastoreMapping(this, mmd, 0, col); } }
private JavaTypeMapping addOrderMapping(AbstractMemberMetaData fmd, JavaTypeMapping orderMapping) { boolean needsOrderMapping = false; OrderMetaData omd = fmd.getOrderMetaData(); if (fmd.hasArray()) { // Array field always has the index mapping needsOrderMapping = true; } else if (List.class.isAssignableFrom(fmd.getType())) { // List field needsOrderMapping = !(omd != null && !omd.isIndexedList()); } else if (java.util.Collection.class.isAssignableFrom(fmd.getType()) && omd != null && omd.isIndexedList() && omd.getMappedBy() == null) { // Collection field with <order> and is indexed list so needs order mapping needsOrderMapping = true; } if (needsOrderMapping) { // if the field is list or array type, add index column if (orderMapping == null) { // Create new order mapping since we need one and we aren't using a shared FK orderMapping = addOrderColumn(fmd); } if (!MetaDataUtils.readRelatedKeysFromParent(storeMgr, fmd)) { getExternalOrderMappings().put(fmd, orderMapping); } } return orderMapping; }
Object fetchRelationField(ClassLoaderResolver clr, AbstractMemberMetaData mmd) { Object value = null; int relationType = mmd.getRelationType(clr); if (Relation.isRelationMultiValued(relationType)) { String propName = getPropertyNameForMember(mmd); if (datastoreEntity.hasProperty(propName)) { if (mmd.hasCollection()) { } else if (mmd.hasArray()) { } else if (mmd.hasMap()) { MetaData other = mmd.getRelatedMemberMetaData(clr)[0].getParent(); MetaData parent = mmd.getParent(); boolean allowNullParent = (other == parent && datastoreEntity.getKey().getParent() == null); return lookupParent(mmd, mapping, allowNullParent);
RelationType relType = mmd.getRelationType(clr); if (RelationType.isRelationSingleValued(relType)) if (mmd.hasCollection()) throw new NucleusException("Field " + mmd.getFullFieldName() + " cannot be persisted because type=" + mmd.getTypeName() + " with relation type " + mmd.getRelationType(clr) + " is not supported for this datastore"); throw new NucleusException("Field " + mmd.getFullFieldName() + " cannot be persisted because type=" + mmd.getTypeName() + " is not supported for this datastore");
/** * Constructor. * @param enhancer ClassEnhancer * @param fmd MetaData for the field we are generating for */ public JdoGetViaCheck(ClassEnhancer enhancer, AbstractMemberMetaData fmd) { super(enhancer, enhancer.getGetMethodPrefixMethodName() + fmd.getName(), (fmd.isPublic() ? Opcodes.ACC_PUBLIC : 0) | (fmd.isProtected() ? Opcodes.ACC_PROTECTED : 0) | (fmd.isPrivate() ? Opcodes.ACC_PRIVATE : 0) | Opcodes.ACC_STATIC, fmd.getType(), null, null); argTypes = new Class[] {getClassEnhancer().getClassEnhanced()}; argNames = new String[] {"objPC"}; this.fmd = fmd; }
if (mmd != null && mmd.isSerialized()) else if (mmd != null && mmd.hasCollection() && SCOUtils.collectionHasSerialisedElements(mmd)) else if (mmd != null && mmd.hasMap() && SCOUtils.mapHasSerialisedKeysAndValues(mmd)) else if (mmd != null && mmd.hasArray() && SCOUtils.arrayIsStoredInSingleColumn(mmd, storeMgr.getMetaDataManager()))
@Override public Class getJavaType() { return mmd.getType(); }