public Store getExistingBackingStoreForMember(AbstractMemberMetaData mmd) { return backingStoreByMemberName.get(mmd.getFullFieldName()); }
/** * Accessor for the JavaTypeMapping that is handling the field of the specified name. Returns the * first one that matches. * * @param fieldName Name of the field * @return The java type mapping */ public JavaTypeMapping getMappingForFullFieldName(String fieldName) { Set fields = fieldMappingsMap.keySet(); for (Object field : fields) { AbstractMemberMetaData fmd = (AbstractMemberMetaData) field; if (fmd.getFullFieldName().equals(fieldName)) { return fieldMappingsMap.get(fmd); } } return null; }
/** * Accessor for the JavaTypeMapping that is handling the member of the specified name. * Returns the first one that matches. * @param memberName Name of the field/property * @return The java type mapping */ protected JavaTypeMapping getMappingForMemberName(String memberName) { Iterator<Map.Entry<AbstractMemberMetaData, JavaTypeMapping>> memberMapEntryIter = memberMappingsMap.entrySet().iterator(); while (memberMapEntryIter.hasNext()) { Map.Entry<AbstractMemberMetaData, JavaTypeMapping> memberMapEntry = memberMapEntryIter.next(); AbstractMemberMetaData mmd = memberMapEntry.getKey(); if (mmd.getFullFieldName().equals(memberName)) { return memberMapEntry.getValue(); } } return null; }
/** * Utility to output any error message. * @param method The method that failed. * @return The localised failure message **/ protected String failureMessage(String method) { return Localiser.msg("041005", getClass().getName(), method, mapping.getMemberMetaData().getFullFieldName()); } }
public void initialize(AbstractMemberMetaData mmd, Table table, ClassLoaderResolver clr) { super.initialize(mmd, table, clr); folderName = mmd.getValueForExtension(EXTENSION_SERIALIZE_TO_FOLDER); File folder = new File(folderName); if (!folder.exists()) { NucleusLogger.PERSISTENCE.debug("Creating folder for persistence data for field " + mmd.getFullFieldName() + " : folder=" + folderName); folder.mkdir(); } }
public String toString() { if (mmd != null) { return "SQLTableMapping: tbl=" + table + " class=" + (cmd != null ? cmd.getFullClassName() : "null") + " mapping=" + mapping + " member=" + mmd.getFullFieldName(); } return "SQLTableMapping: tbl=" + table + " class=" + (cmd != null ? cmd.getFullClassName() : "null") + " mapping=" + mapping; } }
public ArrayRDBMSMapping(JavaTypeMapping mapping, RDBMSStoreManager storeMgr, Column column) { super(storeMgr, mapping); this.column = column; initialize(); // PostgreSQL will have a type like "INT ARRAY" or "TEXT ARRAY", so this finds the element SQL type String arrayTypeName = column.getTypeName(); if (arrayTypeName.indexOf("array") > 0) { arrayElemSqlType = arrayTypeName.substring(0, arrayTypeName.indexOf("array")).trim(); } else if (arrayTypeName.indexOf("ARRAY") > 0) { arrayElemSqlType = arrayTypeName.substring(0, arrayTypeName.indexOf("ARRAY")).trim(); } else { throw new NucleusUserException("Do not support handling of type=" + arrayTypeName + " for member=" + mapping.getMemberMetaData().getFullFieldName()); } }
public void addSchemaCallback(String className, AbstractMemberMetaData mmd) { Collection coll = (Collection)schemaCallbacks.get(className); if (coll == null || !coll.contains(mmd)) { schemaCallbacks.put(className, mmd); } else { NucleusLogger.DATASTORE_SCHEMA.debug("RDBMSStoreManager.addSchemaCallback called for " + mmd.getFullFieldName() + " on class=" + className + " but already registered"); } }
/** * Utility to add the mapping for a field/property to the managed list. * @param fieldMapping The mapping for the field/property */ protected void addMemberMapping(JavaTypeMapping fieldMapping) { AbstractMemberMetaData mmd = fieldMapping.getMemberMetaData(); logMapping(mmd.getFullFieldName(), fieldMapping); memberMappingsMap.put(mmd, fieldMapping); // Update highest field number if this is higher int absoluteFieldNumber = mmd.getAbsoluteFieldNumber(); if (absoluteFieldNumber > highestMemberNumber) { highestMemberNumber = absoluteFieldNumber; } }
/** * Ensures that the given value is not null. Throws * {@link NullPointerException} with a helpful error message if it is. */ private Object checkAssignmentToNotNullField(Object val, int fieldNumber) { if (val != null) { // not null so no problem return val; } // Put together a really helpful error message AbstractMemberMetaData mmd = getMetaData(fieldNumber); String propertyName = getPropertyNameForMember(mmd); final String msg = String.format(ILLEGAL_NULL_ASSIGNMENT_ERROR_FORMAT, datastoreEntity.getKind(), datastoreEntity.getKey(), propertyName, mmd.getFullFieldName()); throw new NullPointerException(msg); }
private void checkSettingToNullValue(AbstractMemberMetaData mmd, Object value) { if (value == null) { if (mmd.getNullValue() == NullValue.EXCEPTION) { // JDO spec 18.15, throw XXXUserException when trying to store null and have handler set to EXCEPTION throw new NucleusUserException("Field/Property " + mmd.getFullFieldName() + " is null, but is mandatory as it's described in the jdo metadata"); } ColumnMetaData[] colmds = mmd.getColumnMetaData(); if (colmds != null && colmds.length > 0) { if (colmds[0].getAllowsNull() == Boolean.FALSE) { // Column specifically marked as not-nullable throw new NucleusDataStoreException("Field/Property " + mmd.getFullFieldName() + " is null, but the column is specified as not-nullable"); } } } }
/** * Constructor for SCO data. Takes in the meta data for the field, and the table it is mapped to. * @param mmd MetaData for the field. * @param table Table definition */ public RDBMSStoreData(AbstractMemberMetaData mmd, Table table) { super(mmd.getFullFieldName(), mmd, Type.SCO, null); if (table == null) { throw new NullPointerException("table should not be null"); } this.table = table; this.tableName = table.toString(); this.tableOwner = true; this.tableIdentifier = table.getIdentifier(); String interfaceName = table.getStoreManager().getMetaDataManager().isPersistentInterface(mmd.getType().getName()) ? mmd.getType().getName() : null; if (interfaceName != null) { this.interfaceName = interfaceName; } }
/** * Method to check if an element is already persistent, or is managed by a different * persistence manager. If not persistent, this will persist it. * @param ec ExecutionContext * @param element The element * @param fieldValues any initial field values to use if persisting the element * @return Whether the element was persisted during this call */ protected boolean validateElementForWriting(ExecutionContext ec, Object element, FieldValues fieldValues) { // Check the element type for this collection if (!storeMgr.getNucleusContext().getMetaDataManager().isPersistentInterface(elementType) && !validateElementType(ec.getClassLoaderResolver(), element)) { throw new ClassCastException(LOCALISER.msg("056033", element.getClass().getName(), ownerMemberMetaData.getFullFieldName(), elementType)); } return SCOUtils.validateObjectForWriting(ec, element, fieldValues); }
private void verifyRelatedKeyIsOfProperType( AbstractMemberMetaData ammd, Key key, AbstractClassMetaData acmd) { String keyKind = key.getKind(); String fieldKind = getIdentifierFactory().newDatastoreContainerIdentifier(acmd).getIdentifierName(); if (!keyKind.equals(fieldKind)) { throw new org.datanucleus.exceptions.NucleusFatalUserException(query.getSingleStringQuery() + ": Field " + ammd.getFullFieldName() + " maps to kind " + fieldKind + " but" + " parameter value contains Key of kind " + keyKind ); } }
public void initialize(AbstractMemberMetaData mmd, Table table, ClassLoaderResolver clr, TypeConverter conv) { if (mmd.getTypeConverterName() != null) { // Use specified converter (if found) converter = table.getStoreManager().getNucleusContext().getTypeManager().getTypeConverterForName(mmd.getTypeConverterName()); if (converter == null) { throw new NucleusUserException(Localiser.msg("044062", mmd.getFullFieldName(), mmd.getTypeConverterName())); } } else if (conv != null) { converter = conv; } else { throw new NucleusUserException("Unable to initialise mapping of type " + getClass().getName() + " for field " + mmd.getFullFieldName() + " since no TypeConverter was provided"); } super.initialize(mmd, table, clr); }
/** * Constructs a duplicate column name exception. * @param tableName Name of the table being initialized. * @param col1 Column we already have * @param col2 Column that we tried to create */ public DuplicateColumnException(String tableName, Column col1, Column col2) { super(Localiser.msg("020007", col1.getIdentifier(), tableName, col1.getMemberMetaData() == null ? Localiser.msg("020008") : (col1.getMemberMetaData() != null ? col1.getMemberMetaData().getFullFieldName() : null), col2.getMemberMetaData() == null ? Localiser.msg("020008") : (col2.getMemberMetaData() != null ? col2.getMemberMetaData().getFullFieldName() : null))); this.conflictingColumn = col2; setFatal(); }
private Object lookupParent(AbstractMemberMetaData mmd, JavaTypeMapping mapping, boolean allowNullParent) { Key parentKey = datastoreEntity.getParent(); if (parentKey == null) { if (!allowNullParent) { String childClass = getObjectProvider().getClassMetaData().getFullClassName(); throw new NucleusFatalUserException("Field " + mmd.getFullFieldName() + " should be able to " + "provide a reference to its parent but the entity does not have a parent. " + "Did you perhaps try to establish an instance of " + childClass + " as " + "the child of an instance of " + mmd.getTypeName() + " after the child had already been " + "persisted?"); } else { return null; } } return mapping.getObject(ec, parentKey, NOT_USED); }
protected RelationByDnStrategy(StoreManager storeMgr, ObjectProvider sm, AbstractMemberMetaData mmd, Attributes attributes) { super(sm, mmd, attributes); this.fieldNumber = mmd.getAbsoluteFieldNumber(); this.storeMgr = storeMgr; this.clr = ec.getClassLoaderResolver(); this.effectiveClassMetaData = LDAPUtils.getEffectiveClassMetaData(mmd, ec.getMetaDataManager()); this.mappingMetaData = new RelationByDnMetaData(mmd, ec.getMetaDataManager()); if (mappingMetaData.getOwnerAttributeName() == null) { // Sanity check on metadata throw new NucleusUserException("Member " + mmd.getFullFieldName() + " stores multiple values and has owner LDAP attribute as NULL. The metadata is incorrect and needs to set this."); } }
private void verifyOneToManyOrderBy(AbstractMemberMetaData ammd, AbstractClassMetaData childAcmd) { OrderMetaData omd = ammd.getOrderMetaData(); OrderMetaData.FieldOrder[] fieldOrders = omd.getFieldOrders(); if (fieldOrders == null) { return; } for (OrderMetaData.FieldOrder fieldOrder : omd.getFieldOrders()) { String propertyName = fieldOrder.getFieldName(); AbstractMemberMetaData orderField = childAcmd.getMetaDataForMember(propertyName); if (orderField.hasExtension(DatastoreManager.PK_ID) || orderField.hasExtension(DatastoreManager.PK_NAME)) { throw new InvalidMetaDataException(GAE_LOCALISER, "AppEngine.MetaData.OrderPartOfPK", ammd.getFullFieldName(), propertyName); } } }
public void storeStringField(int fieldNumber, String value) { StatementMappingIndex mapIdx = stmtMappings.getMappingForMemberPosition(fieldNumber); if (value == null && mapIdx.getMapping().getMemberMetaData().getNullValue() == NullValue.EXCEPTION) { throw new NucleusUserException(Localiser.msg("052400", mapIdx.getMapping().getMemberMetaData().getFullFieldName())); } for (int i=0;i<mapIdx.getNumberOfParameterOccurrences();i++) { // Set this value for all occurrences of this parameter mapIdx.getMapping().setString(ec, statement, mapIdx.getParameterPositionsForOccurrence(i), value); } }