Changeset 3981

Timestamp:

2010-04-09 07:06:33 (3 years ago)

Author:

evert

Message:

Generate ids for fielddescriptors
Use names instead of ids in Records
Introduced mixins

Location:

projects/lily/trunk

Files:

• indexer/src/test/java/org/lilycms/indexer/test/IndexerTest.java (modified) (2 diffs)
• repository/api/src/main/java/org/lilycms/repository/api/FieldDescriptor.java (modified) (3 diffs)
• repository/api/src/main/java/org/lilycms/repository/api/Record.java (modified) (1 diff)
• repository/api/src/main/java/org/lilycms/repository/api/RecordType.java (modified) (2 diffs)
• repository/api/src/main/java/org/lilycms/repository/api/Repository.java (modified) (1 diff)
• repository/api/src/main/java/org/lilycms/repository/api/TypeManager.java (modified) (5 diffs)
• repository/impl/src/main/java/org/lilycms/repository/impl/FieldDescriptorImpl.java (modified) (7 diffs)
• repository/impl/src/main/java/org/lilycms/repository/impl/HBaseRepository.java (modified) (14 diffs)
• repository/impl/src/main/java/org/lilycms/repository/impl/HBaseTypeManager.java (modified) (30 diffs)
• repository/impl/src/main/java/org/lilycms/repository/impl/RecordImpl.java (modified) (12 diffs)
• repository/impl/src/main/java/org/lilycms/repository/impl/RecordTypeImpl.java (modified) (10 diffs)
• repository/impl/src/test/java/org/lilycms/repository/impl/test/HBaseRepositoryTest.java (modified) (36 diffs)
• repository/impl/src/test/java/org/lilycms/repository/impl/test/TypeManagerFieldDescriptorTest.java (modified) (6 diffs)
• repository/impl/src/test/java/org/lilycms/repository/impl/test/TypeManagerFieldGroupTest.java (modified) (6 diffs)
• repository/impl/src/test/java/org/lilycms/repository/impl/test/TypeManagerRecordTypeTest.java (modified) (2 diffs)
• repository/impl/src/test/java/org/lilycms/repository/impl/test/ValueTypeTest.java (modified) (2 diffs)

projects/lily/trunk/indexer/src/test/java/org/lilycms/indexer/test/IndexerTest.java

@@ -24 +24 @@
 import org.lilycms.queue.api.QueueListener;
 import org.lilycms.queue.api.QueueMessage;
+import org.lilycms.repository.api.FieldDescriptor;
 import org.lilycms.repository.api.FieldGroup;
 import org.lilycms.repository.api.IdGenerator;
@@ -76 +77 @@
         // Create a record type
         ValueType stringValueType = typeManager.getValueType("STRING", false, false);
-        typeManager.createFieldDescriptor(typeManager.newFieldDescriptor("field1", stringValueType, "field1GN"));
-        typeManager.createFieldDescriptor(typeManager.newFieldDescriptor("field2", stringValueType, "field2GN"));
-        typeManager.createFieldDescriptor(typeManager.newFieldDescriptor("field3", stringValueType, "field3GN"));
+        FieldDescriptor fieldDescriptor1 = typeManager.createFieldDescriptor(typeManager.newFieldDescriptor(stringValueType, "field1"));
+        FieldDescriptor fieldDescriptor2 = typeManager.createFieldDescriptor(typeManager.newFieldDescriptor(stringValueType, "field2"));
+        FieldDescriptor fieldDescriptor3 = typeManager.createFieldDescriptor(typeManager.newFieldDescriptor(stringValueType, "field3"));
         FieldGroup fieldGroup1 = typeManager.newFieldGroup("fieldGroup1");
-        fieldGroup1.setFieldGroupEntry(typeManager.newFieldGroupEntry("field1", Long.valueOf(1), true, "alias1"));
-        fieldGroup1.setFieldGroupEntry(typeManager.newFieldGroupEntry("field2", Long.valueOf(1), true, "alias2"));
-        fieldGroup1.setFieldGroupEntry(typeManager.newFieldGroupEntry("field3", Long.valueOf(1), true, "alias3"));
+        fieldGroup1.setFieldGroupEntry(typeManager.newFieldGroupEntry(fieldDescriptor1.getId(), Long.valueOf(1), true, "alias1"));
+        fieldGroup1.setFieldGroupEntry(typeManager.newFieldGroupEntry(fieldDescriptor2.getId(), Long.valueOf(1), true, "alias2"));
+        fieldGroup1.setFieldGroupEntry(typeManager.newFieldGroupEntry(fieldDescriptor3.getId(), Long.valueOf(1), true, "alias3"));
         fieldGroup1 = typeManager.createFieldGroup(fieldGroup1);
 
-        typeManager.createFieldDescriptor(typeManager.newFieldDescriptor("nvfield1", stringValueType, "nvfield1GN"));
+        FieldDescriptor nvFieldDescriptor1 = typeManager.createFieldDescriptor(typeManager.newFieldDescriptor(stringValueType, "nvfield1"));
         FieldGroup fieldGroup2 = typeManager.newFieldGroup("fieldGroup2");
-        fieldGroup2.setFieldGroupEntry(typeManager.newFieldGroupEntry("nvfield1", Long.valueOf(1), true, "nvalias1"));
+        fieldGroup2.setFieldGroupEntry(typeManager.newFieldGroupEntry(nvFieldDescriptor1.getId(), Long.valueOf(1), true, "nvalias1"));
         fieldGroup2 = typeManager.createFieldGroup(fieldGroup2);
         

projects/lily/trunk/repository/api/src/main/java/org/lilycms/repository/api/FieldDescriptor.java

@@ -30 +30 @@
  */
 public interface FieldDescriptor {
+
+    void setId(String string);
     /**
      * The id of the {@link FieldDescriptor} is also the id to be used by the corresponding {@link Field}
@@ -51 +53 @@
      * The name can be chose by the user.
      */
-    void setGlobalName(String name);
+    void setName(String name);
     
     /**
      * @return the global unique name of the {@link FieldDescriptor}
      */
-    String getGlobalName();
+    String getName();
     
     /**
@@ -72 +74 @@
 
     FieldDescriptor clone();
+
 }

projects/lily/trunk/repository/api/src/main/java/org/lilycms/repository/api/Record.java

@@ -60 +60 @@
     Long getRecordTypeVersion(Scope scope);
     
-    void setField(Scope scope, String fieldId, Object value);
+    void setField(Scope scope, String fieldName, Object value);
 
-    Object getField(Scope scope, String fieldId) throws FieldNotFoundException;
+    Object getField(Scope scope, String fieldName) throws FieldNotFoundException;
 
     Map<String, Object> getFields(Scope scope);
 
-    void addFieldsToDelete(Scope scope, List<String> fieldIds);
+    void addFieldsToDelete(Scope scope, List<String> fieldNames);
     
-    void removeFieldsToDelete(Scope scope, List<String> fieldIds);
+    void removeFieldsToDelete(Scope scope, List<String> fieldNames);
 
     List<String> getFieldsToDelete(Scope scope);

projects/lily/trunk/repository/api/src/main/java/org/lilycms/repository/api/RecordType.java

@@ -15 +15 @@
  */
 package org.lilycms.repository.api;
+
+import java.util.Map;
 
 import org.lilycms.repository.api.Record.Scope;
@@ -46 +48 @@
     Long getFieldGroupVersion(Scope scope);
     
+    void addMixin(String recordTypeId, Long recordTypeVersion);
+    
+    void removeMixin(String recordTypeId);
+    
+    Map<String, Long> getMixins();
+    
     RecordType clone();
     

projects/lily/trunk/repository/api/src/main/java/org/lilycms/repository/api/Repository.java

@@ -90 +90 @@
     Record read(RecordId recordId) throws RecordNotFoundException, RecordTypeNotFoundException, FieldGroupNotFoundException, FieldDescriptorNotFoundException, RepositoryException;
 
-    Record read(RecordId recordId, List<String> nonVersionableFieldIds, List<String> versionableFieldIds, List<String> versionableMutableFieldIds) throws RecordNotFoundException, RecordTypeNotFoundException, FieldGroupNotFoundException, FieldDescriptorNotFoundException, RepositoryException;
+    Record read(RecordId recordId, List<String> nonVersionableFieldNames, List<String> versionableFieldNames, List<String> versionableMutableFieldNames) throws RecordNotFoundException, RecordTypeNotFoundException, FieldGroupNotFoundException, FieldDescriptorNotFoundException, RepositoryException;
 
     Record read(RecordId recordId, Long version) throws RecordNotFoundException, RecordTypeNotFoundException, FieldGroupNotFoundException, FieldDescriptorNotFoundException, RepositoryException;
 
-    Record read(RecordId recordId, Long version, List<String> nonVersionableFieldIds, List<String> versionableFieldIds, List<String> versionableMutableFieldIds) throws RecordNotFoundException, RecordTypeNotFoundException, FieldGroupNotFoundException, FieldDescriptorNotFoundException, RepositoryException;
+    Record read(RecordId recordId, Long version, List<String> nonVersionableFieldNames, List<String> versionableFieldNames, List<String> versionableMutableFieldNames) throws RecordNotFoundException, RecordTypeNotFoundException, FieldGroupNotFoundException, FieldDescriptorNotFoundException, RepositoryException;
 
     /**

projects/lily/trunk/repository/api/src/main/java/org/lilycms/repository/api/TypeManager.java

@@ -18 +18 @@
 import java.util.List;
 
+import org.lilycms.repository.api.Record.Scope;
+
 
 /**
@@ -34 +36 @@
      * @throws RecordTypeExistsException when a recordType with the same id already exists on the repository 
      * @throws FieldGroupNotFoundException when the recordType refers to a non-existing {@link FieldGroup}
+     * @throws RecordTypeNotFoundException when a mixin of the recordType refers to a non-existing {@link RecordType} 
      * @throws RepositoryException when an unexpected exception occurs on the repository
      */
-    RecordType createRecordType(RecordType recordType) throws RecordTypeExistsException, FieldGroupNotFoundException, RepositoryException;
+    RecordType createRecordType(RecordType recordType) throws RecordTypeExistsException, FieldGroupNotFoundException, RecordTypeNotFoundException, RepositoryException;
     
     /**
@@ -117 +120 @@
      * Creates a new {@link FieldDescriptor} object.
      */
+    FieldDescriptor newFieldDescriptor(ValueType valueType, String name);
+    
     FieldDescriptor newFieldDescriptor(String id, ValueType valueType, String globalName);
     
@@ -122 +127 @@
      * Creates a {@link FieldDescriptor} on the repository with the properties defined in the {@link FieldDescriptor} object.
      * @return a {@link FieldDescriptor} object containing the updated version number of the fieldDescriptor
-     * @throws FieldDescriptorExistsException if a fieldDescriptor with the same id already exists on the repository 
      * @throws RepositoryException when an unexpected exception occurs on the repository
      */
-    FieldDescriptor createFieldDescriptor(FieldDescriptor fieldDescriptor) throws FieldDescriptorExistsException, RepositoryException;
+    FieldDescriptor createFieldDescriptor(FieldDescriptor fieldDescriptor) throws RepositoryException;
 
     /**
@@ -161 +165 @@
      */
     ValueType getValueType(String primitiveValueTypeName, boolean multiValue, boolean hierarchical);
+
+    FieldDescriptor getFieldDescriptor(Scope scope, String name, RecordType recordType) throws FieldGroupNotFoundException, FieldDescriptorNotFoundException, RecordTypeNotFoundException, RepositoryException;
+   
 }

projects/lily/trunk/repository/impl/src/main/java/org/lilycms/repository/impl/FieldDescriptorImpl.java

@@ -22 +22 @@
 public class FieldDescriptorImpl implements FieldDescriptor {
 
-    private final String id;
+    private String id;
     private Long version;
     private ValueType valueType;
-    private String globalName;
+    private String name;
 
     /**
@@ -31 +31 @@
      * @use {@link TypeManager#newFieldDescriptor} instead
      */
-    public FieldDescriptorImpl(String id, ValueType valueType, String globalName) {
+    public FieldDescriptorImpl(String id, ValueType valueType, String name) {
         this.id = id;
         this.valueType = valueType;
-        this.globalName = globalName;
+        this.name = name;
     }
 
-    public String getGlobalName() {
-        return globalName;
+    public String getName() {
+        return name;
     }
 
@@ -53 +53 @@
     }
 
-    public void setGlobalName(String name) {
-        this.globalName = name;
+    public void setId(String id) {
+        this.id = id;
+    }
+    
+    public void setName(String name) {
+        this.name = name;
     }
 
@@ -66 +70 @@
     
     public FieldDescriptor clone() {
-        FieldDescriptorImpl clone = new FieldDescriptorImpl(this.id, this.valueType, this.globalName);
+        FieldDescriptorImpl clone = new FieldDescriptorImpl(this.id, this.valueType, this.name);
         clone.version = this.version;
         return clone;
@@ -75 +79 @@
         final int prime = 31;
         int result = 1;
-        result = prime * result + ((globalName == null) ? 0 : globalName.hashCode());
+        result = prime * result + ((name == null) ? 0 : name.hashCode());
         result = prime * result + ((id == null) ? 0 : id.hashCode());
         result = prime * result + ((valueType == null) ? 0 : valueType.hashCode());
@@ -91 +95 @@
             return false;
         FieldDescriptorImpl other = (FieldDescriptorImpl) obj;
-        if (globalName == null) {
-            if (other.globalName != null)
+        if (name == null) {
+            if (other.name != null)
                 return false;
-        } else if (!globalName.equals(other.globalName))
+        } else if (!name.equals(other.name))
             return false;
         if (id == null) {
@@ -116 +120 @@
     @Override
     public String toString() {
-        return "FieldDescriptorImpl [id=" + id + ", version=" + version + ", globalName=" + globalName
+        return "FieldDescriptorImpl [id=" + id + ", version=" + version + ", name=" + name
                         + ", valueType=" + valueType + "]";
     }

projects/lily/trunk/repository/impl/src/main/java/org/lilycms/repository/impl/HBaseRepository.java

@@ -37 +37 @@
 import org.lilycms.repository.api.FieldDescriptor;
 import org.lilycms.repository.api.FieldDescriptorNotFoundException;
-import org.lilycms.repository.api.FieldGroup;
-import org.lilycms.repository.api.FieldGroupEntry;
 import org.lilycms.repository.api.FieldGroupNotFoundException;
 import org.lilycms.repository.api.IdGenerator;
@@ -80 +78 @@
     private final TypeManager typeManager;
     private final IdGenerator idGenerator;
+    private Map<Scope, byte[]> columnFamilies = new HashMap<Scope, byte[]>();
+    private Map<Scope, byte[]> systemColumnFamilies = new HashMap<Scope, byte[]>();
+    private Map<Scope, byte[]> recordTypeIdColumnNames = new HashMap<Scope, byte[]>();
+    private Map<Scope, byte[]> recordTypeVersionColumnNames = new HashMap<Scope, byte[]>();
 
     public HBaseRepository(TypeManager typeManager, IdGenerator idGenerator, Configuration configuration)
@@ -101 +103 @@
             recordTable = new HTable(configuration, RECORD_TABLE);
         }
+        columnFamilies.put(Scope.NON_VERSIONABLE, NON_VERSIONABLE_COLUMN_FAMILY);
+        columnFamilies.put(Scope.VERSIONABLE, VERSIONABLE_COLUMN_FAMILY);
+        columnFamilies.put(Scope.VERSIONABLE_MUTABLE, VERSIONABLE_MUTABLE_COLUMN_FAMILY);
+        systemColumnFamilies.put(Scope.NON_VERSIONABLE, NON_VERSIONABLE_SYSTEM_COLUMN_FAMILY);
+        systemColumnFamilies.put(Scope.VERSIONABLE, VERSIONABLE_SYSTEM_COLUMN_FAMILY);
+        systemColumnFamilies.put(Scope.VERSIONABLE_MUTABLE, VERSIONABLE_SYSTEM_COLUMN_FAMILY);
+        recordTypeIdColumnNames.put(Scope.NON_VERSIONABLE, NON_VERSIONABLE_RECORDTYPEID_COLUMN_NAME);
+        recordTypeIdColumnNames.put(Scope.VERSIONABLE, VERSIONABLE_RECORDTYPEID_COLUMN_NAME);
+        recordTypeIdColumnNames.put(Scope.VERSIONABLE_MUTABLE, VERSIONABLE_MUTABLE_RECORDTYPEID_COLUMN_NAME);
+        recordTypeVersionColumnNames.put(Scope.NON_VERSIONABLE, NON_VERSIONABLE_RECORDTYPEVERSION_COLUMN_NAME);
+        recordTypeVersionColumnNames.put(Scope.VERSIONABLE, VERSIONABLE_RECORDTYPEVERSION_COLUMN_NAME);
+        recordTypeVersionColumnNames.put(Scope.VERSIONABLE_MUTABLE, VERSIONABLE_MUTABLE_RECORDTYPEVERSION_COLUMN_NAME);
+        
     }
 
@@ -209 +224 @@
         boolean changed = false;
         boolean versionableChanged = false;
-        if (putNonVersionableFields(record, originalRecord, recordType, put)) {
+        if (putFields(Scope.NON_VERSIONABLE, record, originalRecord, recordType, null, put)) {
             changed = true;
         }
-        if (putVersionableFields(record, originalRecord, recordType, version, put)) {
+        if (putFields(Scope.VERSIONABLE, record, originalRecord, recordType, version, put)) {
             changed = true;
             versionableChanged = true;
         }
-        if (putVersionableMutableFields(record, originalRecord, recordType, version, put)) {
+        if (putFields(Scope.VERSIONABLE_MUTABLE, record, originalRecord, recordType, version, put)) {
             changed = true;
             versionableChanged = true;
@@ -236 +251 @@
     }
 
-    private boolean putNonVersionableFields(Record record, Record originalRecord, RecordType recordType, Put put)
-                    throws FieldGroupNotFoundException, FieldDescriptorNotFoundException, RepositoryException {
-        if (putUpdateAndDeleteFieldGroupFields(record.getFields(Scope.NON_VERSIONABLE), record
-                        .getFieldsToDelete(Scope.NON_VERSIONABLE), originalRecord.getFields(Scope.NON_VERSIONABLE),
-                        recordType.getFieldGroupId(Scope.NON_VERSIONABLE), recordType
-                                        .getFieldGroupVersion(Scope.NON_VERSIONABLE), NON_VERSIONABLE_COLUMN_FAMILY,
-                        null, put)) {
-            put.add(NON_VERSIONABLE_SYSTEM_COLUMN_FAMILY, NON_VERSIONABLE_RECORDTYPEID_COLUMN_NAME, Bytes
-                            .toBytes(recordType.getId()));
-            put.add(NON_VERSIONABLE_SYSTEM_COLUMN_FAMILY, NON_VERSIONABLE_RECORDTYPEVERSION_COLUMN_NAME, Bytes
-                            .toBytes(recordType.getVersion()));
-            record.setRecordType(Scope.NON_VERSIONABLE, recordType.getId(), recordType.getVersion());
+    private boolean putFields(Scope scope, Record record, Record originalRecord, RecordType recordType, Long version, Put put)
+                    throws FieldGroupNotFoundException, FieldDescriptorNotFoundException, RecordTypeNotFoundException, RepositoryException {
+        if (putUpdateAndDeleteFieldGroupFields(record.getFields(scope), record.getFieldsToDelete(scope), originalRecord
+                        .getFields(scope), scope, recordType, 
+                        columnFamilies.get(scope), version, put)) {
+            if (version == null) {
+                put.add(systemColumnFamilies.get(scope), recordTypeIdColumnNames.get(scope), Bytes.toBytes(recordType.getId()));
+                put.add(systemColumnFamilies.get(scope), recordTypeVersionColumnNames.get(scope), Bytes.toBytes(recordType
+                                .getVersion()));
+            } else {
+                put.add(systemColumnFamilies.get(scope), recordTypeIdColumnNames.get(scope), version, Bytes.toBytes(recordType.getId()));
+                put.add(systemColumnFamilies.get(scope), recordTypeVersionColumnNames.get(scope), version, Bytes.toBytes(recordType
+                                .getVersion()));
+
+            }
+            record.setRecordType(scope, recordType.getId(), recordType.getVersion());
             return true;
         }
         return false;
     }
-
-    private boolean putVersionableFields(Record record, Record originalRecord, RecordType recordType, Long version,
-                    Put put) throws FieldGroupNotFoundException, FieldDescriptorNotFoundException, RepositoryException {
-        if (putUpdateAndDeleteFieldGroupFields(record.getFields(Scope.VERSIONABLE), record
-                        .getFieldsToDelete(Scope.VERSIONABLE), originalRecord.getFields(Scope.VERSIONABLE), recordType
-                        .getFieldGroupId(Scope.VERSIONABLE), recordType.getFieldGroupVersion(Scope.VERSIONABLE),
-                        VERSIONABLE_COLUMN_FAMILY, version, put)) {
-            put.add(VERSIONABLE_SYSTEM_COLUMN_FAMILY, VERSIONABLE_RECORDTYPEID_COLUMN_NAME, version, Bytes
-                            .toBytes(recordType.getId()));
-            put.add(VERSIONABLE_SYSTEM_COLUMN_FAMILY, VERSIONABLE_RECORDTYPEVERSION_COLUMN_NAME, version, Bytes
-                            .toBytes(recordType.getVersion()));
-            record.setRecordType(Scope.VERSIONABLE, recordType.getId(), recordType.getVersion());
-            return true;
-        }
-        return false;
-    }
-
-    private boolean putVersionableMutableFields(Record record, Record originalRecord, RecordType recordType,
-                    Long version, Put put) throws FieldGroupNotFoundException, FieldDescriptorNotFoundException,
-                    RepositoryException {
-        if (putUpdateAndDeleteFieldGroupFields(record.getFields(Scope.VERSIONABLE_MUTABLE), record
-                        .getFieldsToDelete(Scope.VERSIONABLE_MUTABLE), originalRecord
-                        .getFields(Scope.VERSIONABLE_MUTABLE), recordType.getFieldGroupId(Scope.VERSIONABLE_MUTABLE),
-                        recordType.getFieldGroupVersion(Scope.VERSIONABLE_MUTABLE), VERSIONABLE_MUTABLE_COLUMN_FAMILY,
-                        version, put)) {
-            put.add(VERSIONABLE_SYSTEM_COLUMN_FAMILY, VERSIONABLE_MUTABLE_RECORDTYPEID_COLUMN_NAME, version, Bytes
-                            .toBytes(recordType.getId()));
-            put.add(VERSIONABLE_SYSTEM_COLUMN_FAMILY, VERSIONABLE_MUTABLE_RECORDTYPEVERSION_COLUMN_NAME, version, Bytes
-                            .toBytes(recordType.getVersion()));
-            record.setRecordType(Scope.VERSIONABLE_MUTABLE, recordType.getId(), recordType.getVersion());
-            return true;
-        }
-        return false;
-    }
-
+    
     private boolean putUpdateAndDeleteFieldGroupFields(Map<String, Object> fields, List<String> fieldsToDelete,
-                    Map<String, Object> originalFields, String fieldGroupId, Long fieldGroupVersion,
+                    Map<String, Object> originalFields, Scope scope, RecordType recordType,
                     byte[] columnFamily, Long version, Put put) throws FieldGroupNotFoundException,
-                    FieldDescriptorNotFoundException, RepositoryException {
+                    FieldDescriptorNotFoundException, RecordTypeNotFoundException, RepositoryException {
         // Update fields
-        boolean updated = putUpdateFieldGroupFields(fields, originalFields, fieldGroupId, fieldGroupVersion,
-                        columnFamily, version, put);
+        boolean updated = putUpdateFields(scope, fields, originalFields, version, recordType, put);
         // Delete fields
-        boolean deleted = putDeleteFieldgroupFields(fieldsToDelete, originalFields, columnFamily, version, put);
+        boolean deleted = putDeleteFields(scope, fieldsToDelete, originalFields, version, recordType, put);
         return updated || deleted;
     }
 
-    private boolean putUpdateFieldGroupFields(Map<String, Object> fields, Map<String, Object> originalFields,
-                    String fieldGroupId, Long fieldGroupVersion, byte[] columnFamily, Long version, Put put)
-                    throws FieldGroupNotFoundException, RepositoryException, FieldDescriptorNotFoundException {
+    private boolean putUpdateFields(Scope scope, Map<String, Object> fields, Map<String, Object> originalFields, Long version, RecordType recordType, Put put)
+                    throws FieldGroupNotFoundException, FieldDescriptorNotFoundException, RecordTypeNotFoundException, RepositoryException {
         boolean changed = false;
         for (Entry<String, Object> field : fields.entrySet()) {
-            String fieldId = field.getKey();
+            String fieldName = field.getKey();
             Object newValue = field.getValue();
-            Object originalValue = originalFields.get(fieldId);
+            Object originalValue = originalFields.get(fieldName);
             if (((newValue == null) && (originalValue != null)) || !newValue.equals(originalValue)) {
-                byte[] fieldIdAsBytes = Bytes.toBytes(fieldId);
-                byte[] encodedFieldValue = encodeFieldValue(fieldGroupId, fieldGroupVersion, fieldId, newValue);
+                FieldDescriptor fieldDescriptor = typeManager.getFieldDescriptor(scope, fieldName, recordType);
+                byte[] fieldIdAsBytes = Bytes.toBytes(fieldDescriptor.getId());
+                byte[] encodedFieldValue = encodeFieldValue(fieldDescriptor, newValue);
 
                 if (version != null) {
-                    put.add(columnFamily, fieldIdAsBytes, version, encodedFieldValue);
+                    put.add(columnFamilies.get(scope), fieldIdAsBytes, version, encodedFieldValue);
                 } else {
-                    put.add(columnFamily, fieldIdAsBytes, encodedFieldValue);
+                    put.add(columnFamilies.get(scope), fieldIdAsBytes, encodedFieldValue);
                 }
                 changed = true;
@@ -322 +306 @@
     }
 
-    private byte[] encodeFieldValue(String fieldGroupId, Long fieldGroupVersion, String fieldId, Object fieldValue)
-                    throws FieldGroupNotFoundException, RepositoryException, FieldDescriptorNotFoundException {
-        FieldGroup fieldGroup = typeManager.getFieldGroup(fieldGroupId, fieldGroupVersion);
-        FieldGroupEntry fieldGroupEntry = fieldGroup.getFieldGroupEntry(fieldId);
-        FieldDescriptor fieldDescriptor = typeManager.getFieldDescriptor(fieldGroupEntry.getFieldDescriptorId(),
-                        fieldGroupEntry.getFieldDescriptorVersion());
+    private byte[] encodeFieldValue(FieldDescriptor fieldDescriptor, Object fieldValue)
+                    throws FieldGroupNotFoundException, FieldDescriptorNotFoundException, RecordTypeNotFoundException, RepositoryException {
         ValueType valueType = fieldDescriptor.getValueType();
 
@@ -336 +316 @@
     }
 
-    private boolean putDeleteFieldgroupFields(List<String> fieldsToDelete, Map<String, Object> originalFields,
-                    byte[] columnFamily, Long version, Put put) {
+    private boolean putDeleteFields(Scope scope, List<String> fieldsToDelete, Map<String, Object> originalFields, Long version, RecordType recordType, Put put) throws FieldGroupNotFoundException, FieldDescriptorNotFoundException, RecordTypeNotFoundException, RepositoryException {
         boolean changed = false;
         for (String fieldToDelete : fieldsToDelete) {
             if (originalFields.get(fieldToDelete) != null) {
+                FieldDescriptor fieldDescriptor = typeManager.getFieldDescriptor(scope, fieldToDelete, recordType);
+                byte[] fieldIdAsBytes = Bytes.toBytes(fieldDescriptor.getId());
                 if (version != null) {
-                    put.add(columnFamily, Bytes.toBytes(fieldToDelete), version,
-                                    new byte[] { EncodingUtil.DELETE_FLAG });
+                    put.add(columnFamilies.get(scope), fieldIdAsBytes, version, new byte[] { EncodingUtil.DELETE_FLAG });
                 } else {
-                    put.add(columnFamily, Bytes.toBytes(fieldToDelete), new byte[] { EncodingUtil.DELETE_FLAG });
+                    put.add(columnFamilies.get(scope), fieldIdAsBytes, new byte[] { EncodingUtil.DELETE_FLAG });
                 }
                 changed = true;
@@ -385 +365 @@
 
         Put put = new Put(record.getId().toBytes());
-        Map<String, Object> fieldsToUpdate = record.getFields(Scope.VERSIONABLE_MUTABLE);
+        Scope scope = Scope.VERSIONABLE_MUTABLE;
+        Map<String, Object> fieldsToUpdate = record.getFields(scope);
         Map<String, Object> originalFields = originalRecord
-                        .getFields(Scope.VERSIONABLE_MUTABLE);
-        String fieldGroupId = recordType.getFieldGroupId(Scope.VERSIONABLE_MUTABLE);
-        Long fieldGroupVersion = recordType.getFieldGroupVersion(Scope.VERSIONABLE_MUTABLE);
-        boolean updated = putUpdateFieldGroupFields(fieldsToUpdate, originalFields, fieldGroupId,
-                        fieldGroupVersion, VERSIONABLE_MUTABLE_COLUMN_FAMILY,
-                        version, put);
-        List<String> fieldsToDelete = record.getFieldsToDelete(Scope.VERSIONABLE_MUTABLE);
+                        .getFields(scope);
+        boolean updated = putUpdateFields(scope, fieldsToUpdate, originalFields, version, 
+                        recordType, put);
+        List<String> fieldsToDelete = record.getFieldsToDelete(scope);
         Map<String, Object> originalNextFields = new HashMap<String, Object>();
         if (originalNextRecord != null) {
-            originalNextFields.putAll(originalNextRecord.getFields(Scope.VERSIONABLE_MUTABLE));
-        }
-        boolean deleted = putDeleteMutableFieldgroupFields(fieldsToDelete,
-                        originalFields, originalNextFields, fieldGroupId, fieldGroupVersion,
-                        VERSIONABLE_MUTABLE_COLUMN_FAMILY, version, put);
+            originalNextFields.putAll(originalNextRecord.getFields(scope));
+        }
+        boolean deleted = putDeleteMutableFields(fieldsToDelete,
+                        originalFields, originalNextFields, scope, recordType,
+                        columnFamilies.get(scope), version, put);
         if (updated || deleted) {
-            put.add(VERSIONABLE_SYSTEM_COLUMN_FAMILY, VERSIONABLE_MUTABLE_RECORDTYPEID_COLUMN_NAME, version, Bytes
+            put.add(systemColumnFamilies.get(scope), recordTypeIdColumnNames.get(scope), version, Bytes
                             .toBytes(recordType.getId()));
-            put.add(VERSIONABLE_SYSTEM_COLUMN_FAMILY, VERSIONABLE_MUTABLE_RECORDTYPEVERSION_COLUMN_NAME, version, Bytes
+            put.add(systemColumnFamilies.get(scope), recordTypeVersionColumnNames.get(scope), version, Bytes
                             .toBytes(recordType.getVersion()));
             try {
@@ -412 +390 @@
                                 + "> on HBase table", e);
             }
-            newRecord.setRecordType(Scope.VERSIONABLE_MUTABLE, recordType.getId(), recordType.getVersion());
+            newRecord.setRecordType(scope, recordType.getId(), recordType.getVersion());
         }
         return newRecord;
     }
 
-    private boolean putDeleteMutableFieldgroupFields(List<String> fieldsToDelete, Map<String, Object> originalFields,
-                    Map<String, Object> originalNextFields, String fieldGroupId, Long fieldGroupVersion,
+    private boolean putDeleteMutableFields(List<String> fieldsToDelete, Map<String, Object> originalFields,
+                    Map<String, Object> originalNextFields, Scope scope, RecordType recordType,
                     byte[] columnFamily, Long version, Put put) throws FieldGroupNotFoundException,
-                    RepositoryException, FieldDescriptorNotFoundException {
+                    FieldDescriptorNotFoundException, RecordTypeNotFoundException, RepositoryException {
         boolean changed = false;
         for (String fieldToDelete : fieldsToDelete) {
             Object originalValue = originalFields.get(fieldToDelete);
             if (originalValue != null) {
-                put.add(columnFamily, Bytes.toBytes(fieldToDelete), version, new byte[] { EncodingUtil.DELETE_FLAG });
+                FieldDescriptor fieldDescriptor = typeManager.getFieldDescriptor(scope, fieldToDelete, recordType);
+                byte[] fieldIdBytes = Bytes.toBytes(fieldDescriptor.getId());
+                put.add(columnFamily, fieldIdBytes, version, new byte[] { EncodingUtil.DELETE_FLAG });
                 if (originalValue.equals(originalNextFields.get(fieldToDelete))) {
-                    byte[] encodedValue = encodeFieldValue(fieldGroupId, fieldGroupVersion, fieldToDelete,
-                                    originalValue);
-                    put.add(columnFamily, Bytes.toBytes(fieldToDelete), version + 1, encodedValue);
+                    byte[] encodedValue = encodeFieldValue(fieldDescriptor, originalValue);
+                    put.add(columnFamily, fieldIdBytes, version + 1, encodedValue);
                 }
                 changed = true;
@@ -501 +480 @@
     }
 
-    private Pair<String, Long> extractNonVersionableRecordType(Result result, Record record) {
-        return new Pair<String, Long>(Bytes.toString(result.getValue(NON_VERSIONABLE_SYSTEM_COLUMN_FAMILY,
-                        NON_VERSIONABLE_RECORDTYPEID_COLUMN_NAME)), Bytes.toLong(result.getValue(
-                        NON_VERSIONABLE_SYSTEM_COLUMN_FAMILY, NON_VERSIONABLE_RECORDTYPEVERSION_COLUMN_NAME)));
-    }
-
-    private Pair<String, Long> extractVersionableRecordType(Result result, Long version, Record record) {
+    private Pair<String, Long> extractRecordType(Scope scope, Result result, Long version, Record record) {
         if (version == null) {
             // Get latest version
-            return new Pair<String, Long>(Bytes.toString(result.getValue(VERSIONABLE_SYSTEM_COLUMN_FAMILY,
-                            VERSIONABLE_RECORDTYPEID_COLUMN_NAME)), Bytes.toLong(result.getValue(
-                            VERSIONABLE_SYSTEM_COLUMN_FAMILY, VERSIONABLE_RECORDTYPEVERSION_COLUMN_NAME)));
+            return new Pair<String, Long>(Bytes.toString(result.getValue(systemColumnFamilies.get(scope),
+                            recordTypeIdColumnNames.get(scope))), Bytes.toLong(result.getValue(
+                            systemColumnFamilies.get(scope), recordTypeVersionColumnNames.get(scope))));
 
         } else {
@@ -518 +491 @@
             NavigableMap<byte[], NavigableMap<byte[], NavigableMap<Long, byte[]>>> allVersionsMap = result.getMap();
             NavigableMap<byte[], NavigableMap<Long, byte[]>> versionableSystemCFversions = allVersionsMap
-                            .get(VERSIONABLE_SYSTEM_COLUMN_FAMILY);
-            return extractVersionRecordType(version, versionableSystemCFversions, VERSIONABLE_RECORDTYPEID_COLUMN_NAME,
-                            VERSIONABLE_RECORDTYPEVERSION_COLUMN_NAME);
-        }
-    }
-
-    private Pair<String, Long> extractVersionableMutableRecordType(Result result, Long version, Record record) {
-        if (version == null) {
-            // Get latest version
-            return new Pair<String, Long>(Bytes.toString(result.getValue(VERSIONABLE_SYSTEM_COLUMN_FAMILY,
-                            VERSIONABLE_MUTABLE_RECORDTYPEID_COLUMN_NAME)), Bytes.toLong(result.getValue(
-                            VERSIONABLE_SYSTEM_COLUMN_FAMILY, VERSIONABLE_MUTABLE_RECORDTYPEVERSION_COLUMN_NAME)));
-        } else {
-            // Get on version
-            NavigableMap<byte[], NavigableMap<byte[], NavigableMap<Long, byte[]>>> allVersionsMap = result.getMap();
-            NavigableMap<byte[], NavigableMap<Long, byte[]>> versionableSystemCFversions = allVersionsMap
-                            .get(VERSIONABLE_SYSTEM_COLUMN_FAMILY);
-            return extractVersionRecordType(version, versionableSystemCFversions,
-                            VERSIONABLE_MUTABLE_RECORDTYPEID_COLUMN_NAME,
-                            VERSIONABLE_MUTABLE_RECORDTYPEVERSION_COLUMN_NAME);
+                            .get(systemColumnFamilies.get(scope));
+            return extractVersionRecordType(version, versionableSystemCFversions, recordTypeIdColumnNames.get(scope),
+                            recordTypeVersionColumnNames.get(scope));
         }
     }
@@ -598 +554 @@
         }
         String fieldId = Bytes.toString(key);
-        ValueType valueType = typeManager.getFieldDescriptor(fieldId, null).getValueType();
+        FieldDescriptor fieldDescriptor = typeManager.getFieldDescriptor(fieldId, null);
+        ValueType valueType = fieldDescriptor.getValueType();
         Object value = valueType.fromBytes(EncodingUtil.stripPrefix(prefixedValue));
-        return new Pair<String, Object>(fieldId, value);
+        return new Pair<String, Object>(fieldDescriptor.getName(), value);
     }
 
     private void addFieldsToGet(Get get, List<String> nonVersionableFieldIds, List<String> versionableFieldIds,
                     List<String> versionableMutableFieldIds) throws RecordNotFoundException, RepositoryException {
-        boolean added = false;
-        added |= addFieldsToGet(get, nonVersionableFieldIds, NON_VERSIONABLE_COLUMN_FAMILY);
-        added |= addFieldsToGet(get, versionableFieldIds, VERSIONABLE_COLUMN_FAMILY);
-        added |= addFieldsToGet(get, versionableMutableFieldIds, VERSIONABLE_MUTABLE_COLUMN_FAMILY);
-        if (added) {
+        boolean addedVersionable =  addFieldsToGet(get, nonVersionableFieldIds, NON_VERSIONABLE_COLUMN_FAMILY);
+        boolean addedNonVersionable = addFieldsToGet(get, versionableFieldIds, VERSIONABLE_COLUMN_FAMILY);
+        boolean addedVersionableMutable = addFieldsToGet(get, versionableMutableFieldIds, VERSIONABLE_MUTABLE_COLUMN_FAMILY);
+        if (addedVersionable || addedNonVersionable || addedVersionableMutable) {
             addSystemColumnsToGet(get);
         }
@@ -639 +595 @@
     private boolean extractFields(Result result, Long version, Record record) throws RecordTypeNotFoundException,
                     FieldGroupNotFoundException, FieldDescriptorNotFoundException, RepositoryException {
-        boolean retrieved = false;
-        retrieved |= extractNonVersionableFields(result, record);
-        retrieved |= extractVersionableFields(result, version, record);
-        retrieved |= extractVersionableMutableFields(result, version, record);
-        return retrieved;
-    }
-
-    private boolean extractNonVersionableFields(Result result, Record record) throws RecordTypeNotFoundException,
-                    RepositoryException, FieldGroupNotFoundException, FieldDescriptorNotFoundException {
-        boolean retrieved = false;
-        Pair<String, Long> recordTypePair = extractNonVersionableRecordType(result, record);
-        String recordTypeId = recordTypePair.getV1();
-        Long recordTypeVersion = recordTypePair.getV2();
-        // If there is no recordType, there can't be any fields
-        if (recordTypeId != null) {
-            List<Pair<String, Object>> fields = extractFields(result.getFamilyMap(NON_VERSIONABLE_COLUMN_FAMILY));
-            if (!fields.isEmpty()) {
-                for (Pair<String, Object> field : fields) {
-                    record.setField(Scope.NON_VERSIONABLE, field.getV1(), field.getV2());
-                }
-                record.setRecordType(Scope.NON_VERSIONABLE, recordTypeId, recordTypeVersion);
-                retrieved = true;
-            }
-        }
-        return retrieved;
-    }
-
-    private boolean extractVersionableFields(Result result, Long version, Record record)
+        boolean nvExtracted = extractFields(Scope.NON_VERSIONABLE, result, null, record);
+        boolean vExtracted = extractFields(Scope.VERSIONABLE, result, version, record);
+        boolean vmExtracted = extractFields(Scope.VERSIONABLE_MUTABLE, result, version, record);
+        return nvExtracted || vExtracted || vmExtracted;
+    }
+
+    private boolean extractFields(Scope scope, Result result, Long version, Record record)
                     throws RecordTypeNotFoundException, RepositoryException, FieldGroupNotFoundException,
                     FieldDescriptorNotFoundException {
         boolean retrieved = false;
-        Pair<String, Long> recordTypePair = extractVersionableRecordType(result, version, record);
+        Pair<String, Long> recordTypePair = extractRecordType(scope, result, version, record);
         String recordTypeId = recordTypePair.getV1();
         Long recordTypeVersion = recordTypePair.getV2();
@@ -677 +612 @@
             List<Pair<String, Object>> fields;
             if (version == null) {
-                fields = extractFields(result.getFamilyMap(VERSIONABLE_COLUMN_FAMILY));
+                fields = extractFields(result.getFamilyMap(columnFamilies.get(scope)));
             } else {
-                fields = extractVersionFields(version, result.getMap().get(VERSIONABLE_COLUMN_FAMILY));
+                fields = extractVersionFields(version, result.getMap().get(columnFamilies.get(scope)));
             }
             if (!fields.isEmpty()) {
                 for (Pair<String, Object> field : fields) {
-                    record.setField(Scope.VERSIONABLE, field.getV1(), field.getV2());
-                }
-                record.setRecordType(Scope.VERSIONABLE, recordTypeId, recordTypeVersion);
-                retrieved = true;
-            }
-        }
-        return retrieved;
-    }
-
-    private boolean extractVersionableMutableFields(Result result, Long version, Record record)
-                    throws RecordTypeNotFoundException, RepositoryException, FieldGroupNotFoundException,
-                    FieldDescriptorNotFoundException {
-        boolean retrieved = false;
-        Pair<String, Long> recordTypePair = extractVersionableMutableRecordType(result, version, record);
-        String recordTypeId = recordTypePair.getV1();
-        Long recordTypeVersion = recordTypePair.getV2();
-        // If there is no recordType, there can't be any fields
-        if (recordTypeId != null) {
-            List<Pair<String, Object>> fields;
-            if (version == null) {
-                fields = extractFields(result.getFamilyMap(VERSIONABLE_MUTABLE_COLUMN_FAMILY));
-            } else {
-                fields = extractVersionFields(version, result.getMap().get(VERSIONABLE_MUTABLE_COLUMN_FAMILY));
-            }
-            if (!fields.isEmpty()) {
-                for (Pair<String, Object> field : fields) {
-                    record.setField(Scope.VERSIONABLE_MUTABLE, field.getV1(), field.getV2());
-                }
-                record.setRecordType(Scope.VERSIONABLE_MUTABLE, recordTypeId, recordTypeVersion);
+                    record.setField(scope, field.getV1(), field.getV2());
+                }
+                record.setRecordType(scope, recordTypeId, recordTypeVersion);
                 retrieved = true;
             }

projects/lily/trunk/repository/impl/src/main/java/org/lilycms/repository/impl/HBaseTypeManager.java

@@ -22 +22 @@
 import java.util.Map;
 import java.util.NavigableMap;
+import java.util.UUID;
 import java.util.Map.Entry;
 
@@ -35 +36 @@
 import org.apache.hadoop.hbase.util.Bytes;
 import org.lilycms.repository.api.FieldDescriptor;
-import org.lilycms.repository.api.FieldDescriptorExistsException;
 import org.lilycms.repository.api.FieldDescriptorNotFoundException;
 import org.lilycms.repository.api.FieldDescriptorUpdateException;
@@ -59 +59 @@
     private static final byte[] NON_VERSIONABLE_COLUMN_FAMILY = Bytes.toBytes("nonVersionableCF");
     private static final byte[] VERSIONABLE_COLUMN_FAMILY = Bytes.toBytes("versionableCF");
+    private static final byte[] MIXIN_COLUMN_FAMILY = Bytes.toBytes("mixinCF");
 
     private static final byte[] CURRENT_VERSION_COLUMN_NAME = Bytes.toBytes("$currentVersion");
@@ -66 +67 @@
     private static final byte[] RECORDTYPE_VERSIONABLEMUTABLEFIELDGROUP_COLUMN_NAME = Bytes
                     .toBytes("$versionableMutableFG");
-    private static final byte[] FIELDDESCRIPTOR_GLOBALNAME_COLUMN_NAME = Bytes.toBytes("$globalName");
+    private static final byte[] FIELDDESCRIPTOR_NAME_COLUMN_NAME = Bytes.toBytes("$globalName");
     private static final byte[] FIELDDESCRIPTOR_VALUETYPE_COLUMN_NAME = Bytes.toBytes("$valueType");
 
@@ -82 +83 @@
             tableDescriptor.addFamily(new HColumnDescriptor(VERSIONABLE_COLUMN_FAMILY, HConstants.ALL_VERSIONS, "none",
                             false, true, HConstants.FOREVER, false));
+            tableDescriptor.addFamily(new HColumnDescriptor(MIXIN_COLUMN_FAMILY, HConstants.ALL_VERSIONS, "none",
+                            false, true, HConstants.FOREVER, false));
             admin.createTable(tableDescriptor);
             typeTable = new HTable(configuration, TYPE_TABLE);
@@ -94 +97 @@
 
     public RecordType createRecordType(RecordType recordType) throws RecordTypeExistsException,
-                    FieldGroupNotFoundException, RepositoryException {
+                    FieldGroupNotFoundException, RecordTypeNotFoundException, RepositoryException {
         ArgumentValidator.notNull(recordType, "recordType");
         RecordType newRecordType = recordType.clone();
@@ -106 +109 @@
             Put put = new Put(rowId);
             put.add(NON_VERSIONABLE_COLUMN_FAMILY, CURRENT_VERSION_COLUMN_NAME, Bytes.toBytes(recordTypeVersion));
+
             String fieldGroupId = recordType.getFieldGroupId(Scope.NON_VERSIONABLE);
             if (fieldGroupId != null) {
-                newRecordType.setFieldGroupVersion(Scope.NON_VERSIONABLE, putFieldGroupOnRecordType(recordTypeVersion, put,
-                                fieldGroupId, recordType.getFieldGroupVersion(Scope.NON_VERSIONABLE),
+                newRecordType.setFieldGroupVersion(Scope.NON_VERSIONABLE, putFieldGroupOnRecordType(recordTypeVersion,
+                                put, fieldGroupId, recordType.getFieldGroupVersion(Scope.NON_VERSIONABLE),
                                 RECORDTYPE_NONVERSIONABLEFIELDGROUP_COLUMN_NAME));
             }
@@ -122 +126 @@
             fieldGroupId = recordType.getFieldGroupId(Scope.VERSIONABLE_MUTABLE);
             if (fieldGroupId != null) {
-                newRecordType.setFieldGroupVersion(Scope.VERSIONABLE_MUTABLE, putFieldGroupOnRecordType(recordTypeVersion, put,
-                                fieldGroupId, recordType.getFieldGroupVersion(Scope.VERSIONABLE_MUTABLE),
+                newRecordType.setFieldGroupVersion(Scope.VERSIONABLE_MUTABLE, putFieldGroupOnRecordType(
+                                recordTypeVersion, put, fieldGroupId, recordType
+                                                .getFieldGroupVersion(Scope.VERSIONABLE_MUTABLE),
                                 RECORDTYPE_VERSIONABLEMUTABLEFIELDGROUP_COLUMN_NAME));
+            }
+
+            Map<String, Long> mixins = recordType.getMixins();
+            for (Entry<String, Long> mixin : mixins.entrySet()) {
+                newRecordType.addMixin(mixin.getKey(), putMixinOnRecordType(recordTypeVersion, put, mixin.getKey(), mixin.getValue()));
             }
 
@@ -150 +160 @@
         // non-versionable field group
         Pair<Boolean, Long> updateResult = updateFieldGroupOnRecordType(put, newRecordTypeVersion, recordType
-                        .getFieldGroupId(Scope.NON_VERSIONABLE), recordType.getFieldGroupVersion(Scope.NON_VERSIONABLE),
-                        latestRecordType.getFieldGroupId(Scope.NON_VERSIONABLE), latestRecordType
+                        .getFieldGroupId(Scope.NON_VERSIONABLE),
+                        recordType.getFieldGroupVersion(Scope.NON_VERSIONABLE), latestRecordType
+                                        .getFieldGroupId(Scope.NON_VERSIONABLE), latestRecordType
                                         .getFieldGroupVersion(Scope.NON_VERSIONABLE),
                         RECORDTYPE_NONVERSIONABLEFIELDGROUP_COLUMN_NAME);
         if (updateResult.getV1()) {
-            recordTypeChanged =true;
+            recordTypeChanged = true;
             newRecordType.setFieldGroupVersion(Scope.NON_VERSIONABLE, updateResult.getV2());
         }
 
         // versionable field group
-        updateResult = updateFieldGroupOnRecordType(put, newRecordTypeVersion, recordType.getFieldGroupId(Scope.VERSIONABLE),
-                        recordType.getFieldGroupVersion(Scope.VERSIONABLE), latestRecordType.getFieldGroupId(Scope.VERSIONABLE),
-                        latestRecordType.getFieldGroupVersion(Scope.VERSIONABLE),
+        updateResult = updateFieldGroupOnRecordType(put, newRecordTypeVersion, recordType
+                        .getFieldGroupId(Scope.VERSIONABLE), recordType.getFieldGroupVersion(Scope.VERSIONABLE),
+                        latestRecordType.getFieldGroupId(Scope.VERSIONABLE), latestRecordType
+                                        .getFieldGroupVersion(Scope.VERSIONABLE),
                         RECORDTYPE_VERSIONABLEFIELDGROUP_COLUMN_NAME);
         if (updateResult.getV1()) {
@@ -171 +183 @@
         // versionable mutable field group
         updateResult = updateFieldGroupOnRecordType(put, newRecordTypeVersion, recordType
-                        .getFieldGroupId(Scope.VERSIONABLE_MUTABLE), recordType.getFieldGroupVersion(Scope.VERSIONABLE_MUTABLE),
-                        latestRecordType.getFieldGroupId(Scope.VERSIONABLE_MUTABLE), latestRecordType
-                                        .getFieldGroupVersion(Scope.VERSIONABLE_MUTABLE),
+                        .getFieldGroupId(Scope.VERSIONABLE_MUTABLE), recordType
+                        .getFieldGroupVersion(Scope.VERSIONABLE_MUTABLE), latestRecordType
+                        .getFieldGroupId(Scope.VERSIONABLE_MUTABLE), latestRecordType
+                        .getFieldGroupVersion(Scope.VERSIONABLE_MUTABLE),
                         RECORDTYPE_VERSIONABLEMUTABLEFIELDGROUP_COLUMN_NAME);
         if (updateResult.getV1()) {
@@ -179 +192 @@
             newRecordType.setFieldGroupVersion(Scope.VERSIONABLE_MUTABLE, updateResult.getV2());
         }
+        
+        boolean mixinsChanged = updateMixins(put, newRecordTypeVersion, recordType, latestRecordType);
+        recordTypeChanged |= mixinsChanged;
 
         if (recordTypeChanged) {
@@ -221 +237 @@
     }
     
-    public RecordType removeFieldGroups(String recordTypeId, boolean nonVersionable, boolean versionable, boolean versionableMutable) throws RecordTypeNotFoundException, RepositoryException {
+    private Long putMixinOnRecordType(Long recordTypeVersion, Put put, String mixinId, Long mixinVersion) throws RecordTypeNotFoundException, RepositoryException {
+        Long newMixinVersion = getRecordType(mixinId, mixinVersion).getVersion();
+        put.add(MIXIN_COLUMN_FAMILY, Bytes.toBytes(mixinId), recordTypeVersion, Bytes.toBytes(newMixinVersion));
+        return newMixinVersion;
+    }
+    
+    private boolean updateMixins(Put put, Long newRecordTypeVersion, RecordType recordType, RecordType latestRecordType) {
+        boolean changed = false;
+        Map<String, Long> latestMixins = latestRecordType.getMixins();
+        // Update mixins
+        for (Entry<String, Long> entry : recordType.getMixins().entrySet()) {
+            String mixinId = entry.getKey();
+            Long mixinVersion = entry.getValue();
+            if (!mixinVersion.equals(latestMixins.get(mixinId))) {
+                put.add(MIXIN_COLUMN_FAMILY, Bytes.toBytes(mixinId), newRecordTypeVersion, Bytes.toBytes(mixinVersion));
+                changed = true;
+            }
+            latestMixins.remove(mixinId);
+        }
+        // Remove remaining mixins
+        for (Entry<String, Long> entry : latestMixins.entrySet()) {
+            put.add(MIXIN_COLUMN_FAMILY, Bytes.toBytes(entry.getKey()), newRecordTypeVersion, new byte[] { EncodingUtil.DELETE_FLAG });
+            changed = true;
+        }
+        return changed;
+    }
+
+    public RecordType removeFieldGroups(String recordTypeId, boolean nonVersionable, boolean versionable,
+                    boolean versionableMutable) throws RecordTypeNotFoundException, RepositoryException {
         RecordType recordType = getRecordType(recordTypeId, null);
         Long version = recordType.getVersion() + 1;
@@ -228 +272 @@
         if (nonVersionable) {
             if (recordType.getFieldGroupId(Scope.NON_VERSIONABLE) != null) {
-                put.add(VERSIONABLE_COLUMN_FAMILY, RECORDTYPE_NONVERSIONABLEFIELDGROUP_COLUMN_NAME, new byte[]{EncodingUtil.DELETE_FLAG});
+                put.add(VERSIONABLE_COLUMN_FAMILY, RECORDTYPE_NONVERSIONABLEFIELDGROUP_COLUMN_NAME,
+                                new byte[] { EncodingUtil.DELETE_FLAG });
                 recordType.setFieldGroupId(Scope.NON_VERSIONABLE, null);
-                recordType.setFieldGroupVersion(Scope.NON_VERSIONABLE,null);
+                recordType.setFieldGroupVersion(Scope.NON_VERSIONABLE, null);
                 changed = true;
             }
@@ -236 +281 @@
         if (versionable) {
             if (recordType.getFieldGroupId(Scope.VERSIONABLE) != null) {
-                put.add(VERSIONABLE_COLUMN_FAMILY, RECORDTYPE_VERSIONABLEFIELDGROUP_COLUMN_NAME, new byte[]{EncodingUtil.DELETE_FLAG});
+                put.add(VERSIONABLE_COLUMN_FAMILY, RECORDTYPE_VERSIONABLEFIELDGROUP_COLUMN_NAME,
+                                new byte[] { EncodingUtil.DELETE_FLAG });
                 recordType.setFieldGroupId(Scope.VERSIONABLE, null);
                 recordType.setFieldGroupVersion(Scope.VERSIONABLE, null);
@@ -244 +290 @@
         if (versionableMutable) {
             if (recordType.getFieldGroupId(Scope.VERSIONABLE_MUTABLE) != null) {
-                put.add(VERSIONABLE_COLUMN_FAMILY, RECORDTYPE_VERSIONABLEMUTABLEFIELDGROUP_COLUMN_NAME, new byte[]{EncodingUtil.DELETE_FLAG});
+                put.add(VERSIONABLE_COLUMN_FAMILY, RECORDTYPE_VERSIONABLEMUTABLEFIELDGROUP_COLUMN_NAME,
+                                new byte[] { EncodingUtil.DELETE_FLAG });
                 recordType.setFieldGroupId(Scope.VERSIONABLE_MUTABLE, null);
                 recordType.setFieldGroupVersion(Scope.VERSIONABLE_MUTABLE, null);
@@ -255 +302 @@
                 typeTable.put(put);
             } catch (IOException e) {
-                throw new RepositoryException("Exception occured while removing fieldGroups from recordType <" + recordTypeId
-                                + "> on HBase", e);
+                throw new RepositoryException("Exception occured while removing fieldGroups from recordType <"
+                                + recordTypeId + "> on HBase", e);
             }
             recordType.setVersion(version);
@@ -306 +353 @@
             recordType.setFieldGroupVersion(Scope.VERSIONABLE_MUTABLE, fieldGroup.getV2());
         }
+        
+        extractMixins(result, version, recordType);
         return recordType;
     }
@@ -331 +380 @@
         return fieldGroup;
     }
+    
+    private void extractMixins(Result result, Long version, RecordType recordType) {
+        if (version != null) {
+            NavigableMap<byte[], NavigableMap<byte[], NavigableMap<Long, byte[]>>> allVersionsMap = result.getMap();
+            NavigableMap<byte[], NavigableMap<Long, byte[]>> mixinVersionsMap = allVersionsMap.get(MIXIN_COLUMN_FAMILY);
+            if (mixinVersionsMap != null) {
+                for (Entry<byte[], NavigableMap<Long, byte[]>> entry : mixinVersionsMap.entrySet()) {
+                    String mixinId = Bytes.toString(entry.getKey());
+                    Entry<Long, byte[]> ceilingEntry = entry.getValue().ceilingEntry(version);
+                    if (ceilingEntry != null) {
+                        if (!EncodingUtil.isDeletedField(ceilingEntry.getValue())) {
+                            recordType.addMixin(mixinId, Bytes.toLong(ceilingEntry.getValue()));
+                        }
+                    }
+                }
+            }
+        } else {
+            NavigableMap<byte[], byte[]> mixinMap = result.getFamilyMap(MIXIN_COLUMN_FAMILY);
+            if (mixinMap != null) {
+                for (Entry<byte[], byte[]> entry : mixinMap.entrySet()) {
+                    if (!EncodingUtil.isDeletedField(entry.getValue())) {
+                        recordType.addMixin(Bytes.toString(entry.getKey()), Bytes.toLong(entry.getValue()));
+                    }
+                }
+            }
+        }
+    }
 
     private byte[] encodeFieldGroup(String fieldGroupId, Long fieldGroupVersion) {
@@ -438 +514 @@
         return newFieldGroupEntry;
     }
-    
-    public FieldGroup removeFieldDescriptors(String fieldGroupId, List<String> fieldDescriptorIds) throws FieldGroupNotFoundException, RepositoryException{
+
+    public FieldGroup removeFieldDescriptors(String fieldGroupId, List<String> fieldDescriptorIds)
+                    throws FieldGroupNotFoundException, RepositoryException {
         FieldGroup fieldGroup = getFieldGroup(fieldGroupId, null);
         Put put = new Put(Bytes.toBytes(fieldGroupId));
@@ -448 +525 @@
                 // Ignore
             } else {
-                put.add(VERSIONABLE_COLUMN_FAMILY, Bytes.toBytes(fieldDescriptorId), version, new byte[]{EncodingUtil.DELETE_FLAG});
+                put.add(VERSIONABLE_COLUMN_FAMILY, Bytes.toBytes(fieldDescriptorId), version,
+                                new byte[] { EncodingUtil.DELETE_FLAG });
                 fieldGroup.removeFieldGroupEntry(fieldDescriptorId);
                 changed = true;
@@ -456 +534 @@
             put.add(NON_VERSIONABLE_COLUMN_FAMILY, CURRENT_VERSION_COLUMN_NAME, Bytes.toBytes(version));
             try {
-            typeTable.put(put);
+                typeTable.put(put);
             } catch (IOException e) {
-                throw new RepositoryException("Exception occured while removing fieldDescriptor <"+fieldGroupId+"> from fieldGroup <" + fieldGroup.getId()
-                                + "> on HBase", e);
+                throw new RepositoryException("Exception occured while removing fieldDescriptor <" + fieldGroupId
+                                + "> from fieldGroup <" + fieldGroup.getId() + "> on HBase", e);
             }
             fieldGroup.setVersion(version);
@@ -467 +545 @@
 
     public FieldGroup getFieldGroup(String id, Long version) throws FieldGroupNotFoundException, RepositoryException {
+        ArgumentValidator.notNull(id, "id");
         FieldGroup fieldGroup = new FieldGroupImpl(id);
         byte[] rowId = Bytes.toBytes(id);
@@ -495 +574 @@
                 Entry<Long, byte[]> ceilingEntry = entry.getValue().ceilingEntry(version);
                 if (ceilingEntry != null) {
-                    FieldGroupEntry decodedFieldGroupEntry = decodeFieldGroupEntry(ceilingEntry.getValue(), fieldDescriptorId);
+                    FieldGroupEntry decodedFieldGroupEntry = decodeFieldGroupEntry(ceilingEntry.getValue(),
+                                    fieldDescriptorId);
                     if (decodedFieldGroupEntry != null) {
                         fieldGroup.setFieldGroupEntry(decodedFieldGroupEntry);
@@ -546 +626 @@
     }
 
-    public FieldDescriptor newFieldDescriptor(String id, ValueType valueType, String globalName) {
-        ArgumentValidator.notNull(id, "id");
+    
+    public FieldDescriptor newFieldDescriptor(ValueType valueType, String name) {
+        return newFieldDescriptor(null, valueType, name);
+    }
+    
+    public FieldDescriptor newFieldDescriptor(String id, ValueType valueType, String name) {
         ArgumentValidator.notNull(valueType, "valueType");
-        ArgumentValidator.notNull(globalName, "globalName");
-        return new FieldDescriptorImpl(id, valueType, globalName);
+        ArgumentValidator.notNull(name, "name");
+        return new FieldDescriptorImpl(id, valueType, name);
     }
 
     public FieldDescriptor createFieldDescriptor(FieldDescriptor fieldDescriptor)
-                    throws FieldDescriptorExistsException, RepositoryException {
+                    throws RepositoryException {
         ArgumentValidator.notNull(fieldDescriptor, "fieldDescriptor");
         FieldDescriptor result;
-        byte[] rowId = Bytes.toBytes(fieldDescriptor.getId());
+        // TODO use IdGenerator
+        UUID uuid = UUID.randomUUID();
+        byte[] rowId;
+        rowId = fieldDescriptorIdToBytes(uuid);
         Long version = Long.valueOf(1);
         try {
-            if (typeTable.exists(new Get(rowId))) {
-                throw new FieldDescriptorExistsException(fieldDescriptor);
-            }
             Put put = new Put(rowId);
             put.add(NON_VERSIONABLE_COLUMN_FAMILY, CURRENT_VERSION_COLUMN_NAME, Bytes.toBytes(version));
             put.add(NON_VERSIONABLE_COLUMN_FAMILY, FIELDDESCRIPTOR_VALUETYPE_COLUMN_NAME, fieldDescriptor
                             .getValueType().toBytes());
-            put.add(VERSIONABLE_COLUMN_FAMILY, FIELDDESCRIPTOR_GLOBALNAME_COLUMN_NAME, version, Bytes
-                            .toBytes(fieldDescriptor.getGlobalName()));
+            put.add(VERSIONABLE_COLUMN_FAMILY, FIELDDESCRIPTOR_NAME_COLUMN_NAME, version, Bytes
+                            .toBytes(fieldDescriptor.getName()));
             typeTable.put(put);
         } catch (IOException e) {
@@ -575 +659 @@
         }
         result = fieldDescriptor.clone();
+        result.setId(uuid.toString());
         result.setVersion(version);
         return result;
+    }
+
+    private byte[] fieldDescriptorIdToBytes(UUID id) {
+        byte[] rowId;
+        rowId = new byte[16];
+        Bytes.putLong(rowId, 0, id.getMostSignificantBits());
+        Bytes.putLong(rowId, 8, id.getLeastSignificantBits());
+        return rowId;
+    }
+    
+    private byte[] fieldDescriptorIdToBytes(String id) {
+        UUID uuid = UUID.fromString(id);
+        byte[] rowId;
+        rowId = new byte[16];
+        Bytes.putLong(rowId, 0, uuid.getMostSignificantBits());
+        Bytes.putLong(rowId, 8, uuid.getLeastSignificantBits());
+        return rowId;
     }
 
@@ -588 +690 @@
         }
         Long version = latestFieldDescriptor.getVersion();
-        if (!fieldDescriptor.getGlobalName().equals(latestFieldDescriptor.getGlobalName())) {
+        if (!fieldDescriptor.getName().equals(latestFieldDescriptor.getName())) {
             version = version + 1;
-            Put put = new Put(Bytes.toBytes(fieldDescriptor.getId()));
-            put.add(VERSIONABLE_COLUMN_FAMILY, FIELDDESCRIPTOR_GLOBALNAME_COLUMN_NAME, version, Bytes
-                            .toBytes(fieldDescriptor.getGlobalName()));
+            Put put = new Put(fieldDescriptorIdToBytes(fieldDescriptor.getId()));
+            put.add(VERSIONABLE_COLUMN_FAMILY, FIELDDESCRIPTOR_NAME_COLUMN_NAME, version, Bytes
+                            .toBytes(fieldDescriptor.getName()));
             put.add(NON_VERSIONABLE_COLUMN_FAMILY, CURRENT_VERSION_COLUMN_NAME, Bytes.toBytes(version));
             try {
@@ -610 +712 @@
         ArgumentValidator.notNull(id, "id");
         Result result;
-        Get get = new Get(Bytes.toBytes(id));
+        Get get = new Get(fieldDescriptorIdToBytes(id));
         if (version != null) {
             get.setMaxVersions();
@@ -626 +728 @@
         Long currentVersion = Bytes.toLong(nonVersionableColumnFamily.get(CURRENT_VERSION_COLUMN_NAME));
         Long retrievedVersion;
-        String globalName;
+        String name;
         if (version != null) {
             if (version > currentVersion) {
@@ -635 +737 @@
                             .get(VERSIONABLE_COLUMN_FAMILY);
             NavigableMap<Long, byte[]> globalNameVersionsMap = versionableVersionsMap
-                            .get(FIELDDESCRIPTOR_GLOBALNAME_COLUMN_NAME);
-            globalName = Bytes.toString(globalNameVersionsMap.floorEntry(version).getValue());
+                            .get(FIELDDESCRIPTOR_NAME_COLUMN_NAME);
+            name = Bytes.toString(globalNameVersionsMap.floorEntry(version).getValue());
             retrievedVersion = version;
         } else {
             NavigableMap<byte[], byte[]> versionableColumnFamily = result.getFamilyMap(VERSIONABLE_COLUMN_FAMILY);
-            globalName = Bytes.toString(versionableColumnFamily.get(FIELDDESCRIPTOR_GLOBALNAME_COLUMN_NAME));
+            name = Bytes.toString(versionableColumnFamily.get(FIELDDESCRIPTOR_NAME_COLUMN_NAME));
             retrievedVersion = currentVersion;
         }
         ValueType valueType = ValueTypeImpl.fromBytes(nonVersionableColumnFamily
                         .get(FIELDDESCRIPTOR_VALUETYPE_COLUMN_NAME), this);
-        FieldDescriptor fieldDescriptor = new FieldDescriptorImpl(id, valueType, globalName);
+        FieldDescriptor fieldDescriptor = new FieldDescriptorImpl(id, valueType, name);
         fieldDescriptor.setVersion(retrievedVersion);
         return fieldDescriptor;
@@ -672 +774 @@
         return new ValueTypeImpl(primitiveValueTypes.get(primitiveValueTypeName), multivalue, hierarchy);
     }
+    
+    // TODO cache these things on the RecordType itself?
+    public FieldDescriptor getFieldDescriptor(Scope scope, String name, RecordType recordType) throws FieldGroupNotFoundException, FieldDescriptorNotFoundException, RecordTypeNotFoundException, RepositoryException {
+        ArgumentValidator.notNull(scope, "scope");
+        ArgumentValidator.notNull(name, "name");
+        ArgumentValidator.notNull(recordType, "recordType");
+        String fieldGroupId = recordType.getFieldGroupId(scope);
+        Long fieldGroupVersion = recordType.getFieldGroupVersion(scope);
+        if (fieldGroupId != null) {
+            FieldGroup fieldGroup = getFieldGroup(fieldGroupId, fieldGroupVersion);
+            for (FieldGroupEntry fieldGroupEntry : fieldGroup.getFieldGroupEntries()) {
+                String fieldDescriptorId = fieldGroupEntry.getFieldDescriptorId();
+                Long fieldDescriptorVersion = fieldGroupEntry.getFieldDescriptorVersion();
+                FieldDescriptor fieldDescriptor = getFieldDescriptor(fieldDescriptorId, fieldDescriptorVersion);
+                if (name.equals(fieldDescriptor.getName())) {
+                    return fieldDescriptor;
+                }
+            }
+        }
+        for (Entry<String, Long> entry : recordType.getMixins().entrySet()) {
+            RecordType mixin = getRecordType(entry.getKey(), entry.getValue());
+            try {
+                FieldDescriptor fieldDescriptor = getFieldDescriptor(scope, name, mixin);
+                return fieldDescriptor;
+            } catch (FieldDescriptorNotFoundException exception) {
+                // skip
+            }
+        }
+        throw new FieldDescriptorNotFoundException(name, null);
+    }
 
 }

projects/lily/trunk/repository/impl/src/main/java/org/lilycms/repository/impl/RecordImpl.java

@@ -28 +28 @@
 public class RecordImpl implements Record {
     private RecordId id;
-    private Map<String, Object> nonVersionableFields = new HashMap<String, Object>();
-    private Map<String, Object> versionableFields = new HashMap<String, Object>();
-    private Map<String, Object> versionableMutableFields = new HashMap<String, Object>();
+    private Map<Scope, Map<String, Object>> fields = new HashMap<Scope, Map<String, Object>>();
     private String recordTypeId;
     private Long recordTypeVersion;
-    private String nonVersionableRecordTypeId;
-    private Long nonVersionableRecordTypeVersion;
-    private String versionableRecordTypeId;
-    private Long versionableRecordTypeVersion;
-    private String versionableMutableRecordTypeId;
-    private Long versionableMutableRecordTypeVersion;
+    private Map<Scope, String> recordTypeIds = new HashMap<Scope, String>();
+    private Map<Scope, Long> recordTypeVersions = new HashMap<Scope, Long>();
     private Long version;
-    private List<String> nonVersionableFieldsToDelete = new ArrayList<String>();
-    private List<String> versionableFieldsToDelete = new ArrayList<String>();
-    private List<String> versionableMutableFieldsToDelete = new ArrayList<String>();
+    private Map<Scope, List<String>> fieldsToDelete = new HashMap<Scope, List<String>>();
 
     /**
@@ -49 +41 @@
      */
     public RecordImpl() {
-    }
-    
+        initialize();
+    }
+
     /**
      * This constructor should not be called directly.
@@ -57 +50 @@
     public RecordImpl(RecordId id) {
         this.id = id;
+        initialize();
+    }
+
+    private void initialize() {
+        for (Scope scope : Scope.values()) {
+            fields.put(scope, new HashMap<String, Object>());
+            fieldsToDelete.put(scope, new ArrayList<String>());
+        }
     }
 
@@ -89 +90 @@
     
     public void setRecordType(Scope scope, String id, Long version) {
-        switch (scope) {
-        case NON_VERSIONABLE:
-            this.nonVersionableRecordTypeId = id;
-            this.nonVersionableRecordTypeVersion = version;
-            break;
-        case VERSIONABLE:
-            this.versionableRecordTypeId = id;
-            this.versionableRecordTypeVersion = version;
-            break;
-        case VERSIONABLE_MUTABLE:
-            this.versionableMutableRecordTypeId = id;
-            this.versionableMutableRecordTypeVersion = version;
-            break;
-        default:
-            break;
-        }
+        recordTypeIds.put(scope, id);
+        recordTypeVersions.put(scope, version);
     }
     
     public String getRecordTypeId(Scope scope) {
-        switch (scope) {
-        case NON_VERSIONABLE:
-            return nonVersionableRecordTypeId;
-        case VERSIONABLE:
-            return versionableRecordTypeId;
-        case VERSIONABLE_MUTABLE:
-            return versionableMutableRecordTypeId;
-        default:
-            return null;
-        }
+        return recordTypeIds.get(scope);
     }
     
     public Long getRecordTypeVersion(Scope scope) {
-        switch (scope) {
-        case NON_VERSIONABLE:
-            return nonVersionableRecordTypeVersion;
-        case VERSIONABLE:
-            return versionableRecordTypeVersion;
-        case VERSIONABLE_MUTABLE:
-            return versionableMutableRecordTypeVersion;
-        default:
-            return null;
-        }
-    }
-    
-    public void setField(Scope scope, String fieldId, Object value) {
-        switch (scope) {
-        case NON_VERSIONABLE:
-            this.nonVersionableFields.put(fieldId, value);
-            break;
-        case VERSIONABLE:
-            this.versionableFields.put(fieldId, value);
-            break;
-        case VERSIONABLE_MUTABLE:
-            this.versionableMutableFields.put(fieldId, value);
-            break;
-        default:
-            break;
-        }
-    }
-    
-    public Object getField(Scope scope, String fieldId) throws FieldNotFoundException {
-        Object field = null;
-        switch (scope) {
-        case NON_VERSIONABLE:
-            field = nonVersionableFields.get(fieldId);
-            break;
-        case VERSIONABLE:
-            field = versionableFields.get(fieldId);
-            break;
-        case VERSIONABLE_MUTABLE:
-            field = versionableMutableFields.get(fieldId);
-            break;
-        default:
-            break;
-        }
+        return recordTypeVersions.get(scope);
+    }
+    
+    public void setField(Scope scope, String name, Object value) {
+        fields.get(scope).put(name, value);
+    }
+    
+    public Object getField(Scope scope, String name) throws FieldNotFoundException {
+        Object field = fields.get(scope).get(name);
         if (field == null) {
-            throw new FieldNotFoundException(fieldId);
+            throw new FieldNotFoundException(name);
         }
         return field;
@@ -171 +115 @@
 
     public Map<String, Object> getFields(Scope scope) {
-        switch (scope) {
-        case NON_VERSIONABLE:
-            return nonVersionableFields;
-        case VERSIONABLE:
-            return versionableFields;
-        case VERSIONABLE_MUTABLE:
-            return versionableMutableFields;
-        default:
-            return null;
-        }
+        return fields.get(scope);
     }
 
     public List<String> getFieldsToDelete(Scope scope) {
-        switch (scope) {
-        case NON_VERSIONABLE:
-            return nonVersionableFieldsToDelete;
-        case VERSIONABLE:
-            return versionableFieldsToDelete;
-        case VERSIONABLE_MUTABLE:
-            return versionableMutableFieldsToDelete;
-        default:
-            return null;
-        }
-    }
-
-    public void addFieldsToDelete(Scope scope, List<String> fieldIds) {
-        switch (scope) {
-        case NON_VERSIONABLE:
-            this.nonVersionableFieldsToDelete .addAll(fieldIds);
-            break;
-        case VERSIONABLE:
-            this.versionableFieldsToDelete .addAll(fieldIds);
-            break;
-        case VERSIONABLE_MUTABLE:
-            this.versionableMutableFieldsToDelete .addAll(fieldIds);
-            break;
-        default:
-            break;
-        }
-    }
-
-    public void removeFieldsToDelete(Scope scope, List<String> fieldIds) {
-        switch (scope) {
-        case NON_VERSIONABLE:
-            this.nonVersionableFieldsToDelete .removeAll(fieldIds);
-            break;
-        case VERSIONABLE:
-            this.versionableFieldsToDelete .removeAll(fieldIds);
-            break;
-        case VERSIONABLE_MUTABLE:
-            this.versionableMutableFieldsToDelete .removeAll(fieldIds);
-            break;
-        default:
-            break;
-        }
+        return fieldsToDelete.get(scope);
+    }
+
+    public void addFieldsToDelete(Scope scope, List<String> names) {
+        fieldsToDelete.get(scope).addAll(names);
+    }
+
+    public void removeFieldsToDelete(Scope scope, List<String> names) {
+        fieldsToDelete.get(scope).removeAll(names);
     }
 
@@ -234 +136 @@
         record.recordTypeId = recordTypeId;
         record.recordTypeVersion = recordTypeVersion;
-        record.nonVersionableRecordTypeId = nonVersionableRecordTypeId;
-        record.nonVersionableRecordTypeVersion = nonVersionableRecordTypeVersion;
-        record.versionableRecordTypeId = versionableRecordTypeId;
-        record.versionableRecordTypeVersion = versionableRecordTypeVersion;
-        record.versionableMutableRecordTypeId = versionableMutableRecordTypeId;
-        record.versionableMutableRecordTypeVersion = versionableMutableRecordTypeVersion;
-        record.nonVersionableFields.putAll(nonVersionableFields);
-        record.versionableFields.putAll(versionableFields);
-        record.versionableMutableFields.putAll(versionableMutableFields);
-        record.nonVersionableFieldsToDelete.addAll(nonVersionableFieldsToDelete);
-        record.versionableFieldsToDelete.addAll(versionableFieldsToDelete);
-        record.versionableMutableFieldsToDelete.addAll(versionableMutableFieldsToDelete);
+        record.recordTypeIds.putAll(recordTypeIds);
+        record.recordTypeVersions.putAll(recordTypeVersions);
+        for (Scope scope : Scope.values()) {
+            record.fields.get(scope).putAll(fields.get(scope));
+            record.fieldsToDelete.get(scope).addAll(fieldsToDelete.get(scope));
+        }
         return record;
     }
@@ -253 +149 @@
         final int prime = 31;
         int result = 1;
+        result = prime * result + ((fields == null) ? 0 : fields.hashCode());
+        result = prime * result + ((fieldsToDelete == null) ? 0 : fieldsToDelete.hashCode());
         result = prime * result + ((id == null) ? 0 : id.hashCode());
-        result = prime * result + ((nonVersionableFields == null) ? 0 : nonVersionableFields.hashCode());
-        result = prime * result
-                        + ((nonVersionableFieldsToDelete == null) ? 0 : nonVersionableFieldsToDelete.hashCode());
-        result = prime * result + ((nonVersionableRecordTypeId == null) ? 0 : nonVersionableRecordTypeId.hashCode());
-        result = prime * result
-                        + ((nonVersionableRecordTypeVersion == null) ? 0 : nonVersionableRecordTypeVersion.hashCode());
         result = prime * result + ((recordTypeId == null) ? 0 : recordTypeId.hashCode());
+        result = prime * result + ((recordTypeIds == null) ? 0 : recordTypeIds.hashCode());
         result = prime * result + ((recordTypeVersion == null) ? 0 : recordTypeVersion.hashCode());
+        result = prime * result + ((recordTypeVersions == null) ? 0 : recordTypeVersions.hashCode());
         result = prime * result + ((version == null) ? 0 : version.hashCode());
-        result = prime * result + ((versionableFields == null) ? 0 : versionableFields.hashCode());
-        result = prime * result + ((versionableFieldsToDelete == null) ? 0 : versionableFieldsToDelete.hashCode());
-        result = prime * result + ((versionableMutableFields == null) ? 0 : versionableMutableFields.hashCode());
-        result = prime
-                        * result
-                        + ((versionableMutableFieldsToDelete == null) ? 0 : versionableMutableFieldsToDelete.hashCode());
-        result = prime * result
-                        + ((versionableMutableRecordTypeId == null) ? 0 : versionableMutableRecordTypeId.hashCode());
-        result = prime
-                        * result
-                        + ((versionableMutableRecordTypeVersion == null) ? 0 : versionableMutableRecordTypeVersion
-                                        .hashCode());
-        result = prime * result + ((versionableRecordTypeId == null) ? 0 : versionableRecordTypeId.hashCode());
-        result = prime * result
-                        + ((versionableRecordTypeVersion == null) ? 0 : versionableRecordTypeVersion.hashCode());
         return result;
     }
@@ -290 +169 @@
             return false;
         RecordImpl other = (RecordImpl) obj;
+        if (fields == null) {
+            if (other.fields != null)
+                return false;
+        } else if (!fields.equals(other.fields))
+            return false;
+        if (fieldsToDelete == null) {
+            if (other.fieldsToDelete != null)
+                return false;
+        } else if (!fieldsToDelete.equals(other.fieldsToDelete))
+            return false;
         if (id == null) {
             if (other.id != null)
@@ -295 +184 @@
         } else if (!id.equals(other.id))
             return false;
-        if (nonVersionableFields == null) {
-            if (other.nonVersionableFields != null)
-                return false;
-        } else if (!nonVersionableFields.equals(other.nonVersionableFields))
-            return false;
-        if (nonVersionableFieldsToDelete == null) {
-            if (other.nonVersionableFieldsToDelete != null)
-                return false;
-        } else if (!nonVersionableFieldsToDelete.equals(other.nonVersionableFieldsToDelete))
-            return false;
-        if (nonVersionableRecordTypeId == null) {
-            if (other.nonVersionableRecordTypeId != null)
-                return false;
-        } else if (!nonVersionableRecordTypeId.equals(other.nonVersionableRecordTypeId))
-            return false;
-        if (nonVersionableRecordTypeVersion == null) {
-            if (other.nonVersionableRecordTypeVersion != null)
-                return false;
-        } else if (!nonVersionableRecordTypeVersion.equals(other.nonVersionableRecordTypeVersion))
-            return false;
         if (recordTypeId == null) {
             if (other.recordTypeId != null)
@@ -320 +189 @@
         } else if (!recordTypeId.equals(other.recordTypeId))
             return false;
+        if (recordTypeIds == null) {
+            if (other.recordTypeIds != null)
+                return false;
+        } else if (!recordTypeIds.equals(other.recordTypeIds))
+            return false;
         if (recordTypeVersion == null) {
             if (other.recordTypeVersion != null)
@@ -325 +199 @@
         } else if (!recordTypeVersion.equals(other.recordTypeVersion))
             return false;
+        if (recordTypeVersions == null) {
+            if (other.recordTypeVersions != null)
+                return false;
+        } else if (!recordTypeVersions.equals(other.recordTypeVersions))
+            return false;
         if (version == null) {
             if (other.version != null)
                 return false;
         } else if (!version.equals(other.version))
-            return false;
-        if (versionableFields == null) {
-            if (other.versionableFields != null)
-                return false;
-        } else if (!versionableFields.equals(other.versionableFields))
-            return false;
-        if (versionableFieldsToDelete == null) {
-            if (other.versionableFieldsToDelete != null)
-                return false;
-        } else if (!versionableFieldsToDelete.equals(other.versionableFieldsToDelete))
-            return false;
-        if (versionableMutableFields == null) {
-            if (other.versionableMutableFields != null)
-                return false;
-        } else if (!versionableMutableFields.equals(other.versionableMutableFields))
-            return false;
-        if (versionableMutableFieldsToDelete == null) {
-            if (other.versionableMutableFieldsToDelete != null)
-                return false;
-        } else if (!versionableMutableFieldsToDelete.equals(other.versionableMutableFieldsToDelete))
-            return false;
-        if (versionableMutableRecordTypeId == null) {
-            if (other.versionableMutableRecordTypeId != null)
-                return false;
-        } else if (!versionableMutableRecordTypeId.equals(other.versionableMutableRecordTypeId))
-            return false;
-        if (versionableMutableRecordTypeVersion == null) {
-            if (other.versionableMutableRecordTypeVersion != null)
-                return false;
-        } else if (!versionableMutableRecordTypeVersion.equals(other.versionableMutableRecordTypeVersion))
-            return false;
-        if (versionableRecordTypeId == null) {
-            if (other.versionableRecordTypeId != null)
-                return false;
-        } else if (!versionableRecordTypeId.equals(other.versionableRecordTypeId))
-            return false;
-        if (versionableRecordTypeVersion == null) {
-            if (other.versionableRecordTypeVersion != null)
-                return false;
-        } else if (!versionableRecordTypeVersion.equals(other.versionableRecordTypeVersion))
             return false;
         return true;
@@ -376 +215 @@
     public String toString() {
         return "RecordImpl [id=" + id + ", version=" + version + ", recordTypeId=" + recordTypeId
-                        + ", recordTypeVersion=" + recordTypeVersion + ", nonVersionableRecordTypeId="
-                        + nonVersionableRecordTypeId + ", nonVersionableRecordTypeVersion="
-                        + nonVersionableRecordTypeVersion + ", versionableMutableRecordTypeId="
-                        + versionableMutableRecordTypeId + ", versionableMutableRecordTypeVersion="
-                        + versionableMutableRecordTypeVersion + ", versionableRecordTypeId=" + versionableRecordTypeId
-                        + ", versionableRecordTypeVersion=" + versionableRecordTypeVersion + ", nonVersionableFields="
-                        + nonVersionableFields + ", nonVersionableFieldsToDelete=" + nonVersionableFieldsToDelete
-                        + ", versionableFields=" + versionableFields + ", versionableFieldsToDelete="
-                        + versionableFieldsToDelete + ", versionableMutableFields=" + versionableMutableFields
-                        + ", versionableMutableFieldsToDelete=" + versionableMutableFieldsToDelete + "]";
+                        + ", recordTypeVersion=" + recordTypeVersion + ", recordTypeIds=" + recordTypeIds
+                        + ", recordTypeVersions=" + recordTypeVersions + ", fields=" + fields + ", fieldsToDelete="
+                        + fieldsToDelete + "]";
     }
 }

projects/lily/trunk/repository/impl/src/main/java/org/lilycms/repository/impl/RecordTypeImpl.java

@@ -16 +16 @@
 package org.lilycms.repository.impl;
 
+import java.util.HashMap;
+import java.util.Map;
+
 import org.lilycms.repository.api.RecordType;
 import org.lilycms.repository.api.TypeManager;
@@ -24 +27 @@
     private final String id;
     private Long version;
-    private String nonVersionableFieldGroupId;
-    private String versionableFieldGroupId;
-    private String versionableMutableFieldGroupId;
-    private Long nonVersionableFieldGroupVersion;
-    private Long versionableFieldGroupVersion;
-    private Long versionableMutableFieldGroupVersion;
+    private Map<Scope, String> fieldGroupIds;
+    private Map<Scope, Long> fieldGroupVersions;
+    private Map<String, Long> mixins;
 
     /**
@@ -37 +37 @@
     public RecordTypeImpl(String id) {
         this.id = id;
+        fieldGroupIds = new HashMap<Scope, String>();
+        fieldGroupIds.put(Scope.NON_VERSIONABLE, null);
+        fieldGroupIds.put(Scope.VERSIONABLE, null);
+        fieldGroupIds.put(Scope.VERSIONABLE_MUTABLE, null);
+        fieldGroupVersions = new HashMap<Scope, Long>();
+        fieldGroupVersions.put(Scope.NON_VERSIONABLE, null);
+        fieldGroupVersions.put(Scope.VERSIONABLE, null);
+        fieldGroupVersions.put(Scope.VERSIONABLE_MUTABLE, null);
+        mixins = new HashMap<String, Long>();
     }
     
@@ -52 +61 @@
 
     public String getFieldGroupId(Scope scope) {
-        switch (scope) {
-        case NON_VERSIONABLE:
-            return nonVersionableFieldGroupId;
-        case VERSIONABLE:
-            return versionableFieldGroupId;
-        case VERSIONABLE_MUTABLE:
-            return versionableMutableFieldGroupId;
-        default:
-            return null;
-        }
+        return fieldGroupIds.get(scope);
     }
 
     public Long getFieldGroupVersion(Scope scope) {
-        switch (scope) {
-        case NON_VERSIONABLE:
-            return nonVersionableFieldGroupVersion;
-        case VERSIONABLE:
-            return versionableFieldGroupVersion;
-        case VERSIONABLE_MUTABLE:
-            return versionableMutableFieldGroupVersion;
-        default:
-            return null;
-        }
+        return fieldGroupVersions.get(scope);
     }
 
     public void setFieldGroupId(Scope scope, String id) {
-        switch (scope) {
-        case NON_VERSIONABLE:
-            nonVersionableFieldGroupId = id;
-            break;
-        case VERSIONABLE:
-            versionableFieldGroupId = id;
-            break;
-        case VERSIONABLE_MUTABLE:
-            versionableMutableFieldGroupId = id;
-            break;
-        default:
-            break;
-        }
+        fieldGroupIds.put(scope, id);
     }
 
     public void setFieldGroupVersion(Scope scope, Long version) {
-        switch (scope) {
-        case NON_VERSIONABLE:
-            nonVersionableFieldGroupVersion = version;
-            break;
-        case VERSIONABLE:
-            versionableFieldGroupVersion = version;
-            break;
-        case VERSIONABLE_MUTABLE:
-            versionableMutableFieldGroupVersion = version;
-            break;
-        default:
-            break;
-        }
+        fieldGroupVersions.put(scope, version);
+    }
+    
+    public void addMixin(String recordTypeId, Long recordTypeVersion) {
+        mixins.put(recordTypeId, recordTypeVersion);
+    }
+    
+    public void removeMixin(String recordTypeId) {
+        mixins.remove(recordTypeId);
+    }
+    
+    public Map<String, Long> getMixins() {
+        return mixins;
     }
 
@@ -112 +91 @@
         RecordTypeImpl clone = new RecordTypeImpl(this.id);
         clone.version = this.version;
-        clone.nonVersionableFieldGroupId = this.nonVersionableFieldGroupId;
-        clone.nonVersionableFieldGroupVersion = this.nonVersionableFieldGroupVersion;
-        clone.versionableFieldGroupId = this.versionableFieldGroupId;
-        clone.versionableFieldGroupVersion = this.versionableFieldGroupVersion;
-        clone.versionableMutableFieldGroupId = this.versionableMutableFieldGroupId;
-        clone.versionableMutableFieldGroupVersion = this.versionableMutableFieldGroupVersion;
+        clone.fieldGroupIds.putAll(fieldGroupIds);
+        clone.fieldGroupVersions.putAll(fieldGroupVersions);
+        clone.mixins.putAll(mixins);
         return clone;
     }
@@ -125 +101 @@
         final int prime = 31;
         int result = 1;
+        result = prime * result + ((fieldGroupIds == null) ? 0 : fieldGroupIds.hashCode());
+        result = prime * result + ((fieldGroupVersions == null) ? 0 : fieldGroupVersions.hashCode());
         result = prime * result + ((id == null) ? 0 : id.hashCode());
-        result = prime * result + ((nonVersionableFieldGroupId == null) ? 0 : nonVersionableFieldGroupId.hashCode());
-        result = prime * result
-                        + ((nonVersionableFieldGroupVersion == null) ? 0 : nonVersionableFieldGroupVersion.hashCode());
+        result = prime * result + ((mixins == null) ? 0 : mixins.hashCode());
         result = prime * result + ((version == null) ? 0 : version.hashCode());
-        result = prime * result + ((versionableFieldGroupId == null) ? 0 : versionableFieldGroupId.hashCode());
-        result = prime * result
-                        + ((versionableFieldGroupVersion == null) ? 0 : versionableFieldGroupVersion.hashCode());
-        result = prime * result
-                        + ((versionableMutableFieldGroupId == null) ? 0 : versionableMutableFieldGroupId.hashCode());
-        result = prime
-                        * result
-                        + ((versionableMutableFieldGroupVersion == null) ? 0 : versionableMutableFieldGroupVersion
-                                        .hashCode());
         return result;
     }
@@ -151 +118 @@
             return false;
         RecordTypeImpl other = (RecordTypeImpl) obj;
+        if (fieldGroupIds == null) {
+            if (other.fieldGroupIds != null)
+                return false;
+        } else if (!fieldGroupIds.equals(other.fieldGroupIds))
+            return false;
+        if (fieldGroupVersions == null) {
+            if (other.fieldGroupVersions != null)
+                return false;
+        } else if (!fieldGroupVersions.equals(other.fieldGroupVersions))
+            return false;
         if (id == null) {
             if (other.id != null)
@@ -156 +133 @@
         } else if (!id.equals(other.id))
             return false;
-        if (nonVersionableFieldGroupId == null) {
-            if (other.nonVersionableFieldGroupId != null)
+        if (mixins == null) {
+            if (other.mixins != null)
                 return false;
-        } else if (!nonVersionableFieldGroupId.equals(other.nonVersionableFieldGroupId))
-            return false;
-        if (nonVersionableFieldGroupVersion == null) {
-            if (other.nonVersionableFieldGroupVersion != null)
-                return false;
-        } else if (!nonVersionableFieldGroupVersion.equals(other.nonVersionableFieldGroupVersion))
+        } else if (!mixins.equals(other.mixins))
             return false;
         if (version == null) {
@@ -171 +143 @@
         } else if (!version.equals(other.version))
             return false;
-        if (versionableFieldGroupId == null) {
-            if (other.versionableFieldGroupId != null)
-                return false;
-        } else if (!versionableFieldGroupId.equals(other.versionableFieldGroupId))
-            return false;
-        if (versionableFieldGroupVersion == null) {
-            if (other.versionableFieldGroupVersion != null)
-                return false;
-        } else if (!versionableFieldGroupVersion.equals(other.versionableFieldGroupVersion))
-            return false;
-        if (versionableMutableFieldGroupId == null) {
-            if (other.versionableMutableFieldGroupId != null)
-                return false;
-        } else if (!versionableMutableFieldGroupId.equals(other.versionableMutableFieldGroupId))
-            return false;
-        if (versionableMutableFieldGroupVersion == null) {
-            if (other.versionableMutableFieldGroupVersion != null)
-                return false;
-        } else if (!versionableMutableFieldGroupVersion.equals(other.versionableMutableFieldGroupVersion))
-            return false;
         return true;
     }
@@ -196 +148 @@
     @Override
     public String toString() {
-        return "RecordTypeImpl [id=" + id + ", version=" + version + ", nonVersionableFieldGroupId="
-                        + nonVersionableFieldGroupId + ", nonVersionableFieldGroupVersion="
-                        + nonVersionableFieldGroupVersion + ", versionableFieldGroupId=" + versionableFieldGroupId
-                        + ", versionableFieldGroupVersion=" + versionableFieldGroupVersion
-                        + ", versionableMutableFieldGroupId=" + versionableMutableFieldGroupId
-                        + ", versionableMutableFieldGroupVersion=" + versionableMutableFieldGroupVersion + "]";
+        return "RecordTypeImpl [id=" + id + ", version=" + version + ", fieldGroupIds=" + fieldGroupIds
+                        + ", fieldGroupVersions=" + fieldGroupVersions + ", mixins=" + mixins + "]";
     }
+
 }

projects/lily/trunk/repository/impl/src/test/java/org/lilycms/repository/impl/test/HBaseRepositoryTest.java

@@ -81 +81 @@
 
     private static void setupFieldDescriptors() throws Exception {
-        fieldDescriptor1 = typeManager.createFieldDescriptor(typeManager.newFieldDescriptor("FD1", typeManager.getValueType("STRING", false, false), "GN1"));
-        fieldDescriptor1B = typeManager.createFieldDescriptor(typeManager.newFieldDescriptor("FD1B", typeManager.getValueType("STRING", false, false), "GN1B"));
-        fieldDescriptor2 = typeManager.createFieldDescriptor(typeManager.newFieldDescriptor("FD2", typeManager.getValueType("INTEGER", false, false), "GN2"));
-        fieldDescriptor3 = typeManager.createFieldDescriptor(typeManager.newFieldDescriptor("FD3", typeManager.getValueType("BOOLEAN", false, false), "GN3"));
+        fieldDescriptor1 = typeManager.createFieldDescriptor(typeManager.newFieldDescriptor(typeManager.getValueType("STRING", false, false), "field1"));
+        fieldDescriptor1B = typeManager.createFieldDescriptor(typeManager.newFieldDescriptor(typeManager.getValueType("STRING", false, false), "field1B"));
+        fieldDescriptor2 = typeManager.createFieldDescriptor(typeManager.newFieldDescriptor(typeManager.getValueType("INTEGER", false, false), "field2"));
+        fieldDescriptor3 = typeManager.createFieldDescriptor(typeManager.newFieldDescriptor(typeManager.getValueType("BOOLEAN", false, false), "field3"));
     }
 
@@ -176 +176 @@
         
         assertEquals(Long.valueOf(1), createdRecord.getVersion());
-        assertEquals("value1", createdRecord.getField(Scope.NON_VERSIONABLE,fieldDescriptor1.getId()));
-        assertEquals(123, createdRecord.getField(Scope.VERSIONABLE,fieldDescriptor2.getId()));
-        assertTrue((Boolean)createdRecord.getField(Scope.VERSIONABLE_MUTABLE,fieldDescriptor3.getId()));
+        assertEquals("value1", createdRecord.getField(Scope.NON_VERSIONABLE,fieldDescriptor1.getName()));
+        assertEquals(123, createdRecord.getField(Scope.VERSIONABLE,fieldDescriptor2.getName()));
+        assertTrue((Boolean)createdRecord.getField(Scope.VERSIONABLE_MUTABLE,fieldDescriptor3.getName()));
         assertEquals(recordType1.getId(), createdRecord.getRecordTypeId());
         assertEquals(Long.valueOf(1), createdRecord.getRecordTypeVersion());
@@ -194 +194 @@
         Record record = repository.newRecord(recordId);
         record.setRecordType(recordType1.getId(), recordType1.getVersion());
-        record.setField(Scope.NON_VERSIONABLE,fieldDescriptor1.getId(), "value1");
-        record.setField(Scope.VERSIONABLE,fieldDescriptor2.getId(), 123);
-        record.setField(Scope.VERSIONABLE_MUTABLE,fieldDescriptor3.getId(), true);
+        record.setField(Scope.NON_VERSIONABLE,fieldDescriptor1.getName(), "value1");
+        record.setField(Scope.VERSIONABLE,fieldDescriptor2.getName(), 123);
+        record.setField(Scope.VERSIONABLE_MUTABLE,fieldDescriptor3.getName(), true);
         return repository.create(record);
     }
@@ -227 +227 @@
         Record record = repository.newRecord(idGenerator.newRecordId());
         record.setRecordType(recordType1.getId(), null);
-        record.setField(Scope.NON_VERSIONABLE,fieldDescriptor1.getId(), "value1");
+        record.setField(Scope.NON_VERSIONABLE,fieldDescriptor1.getName(), "value1");
         Record createdRecord = repository.create(record);
         assertEquals(recordType1.getId(), createdRecord.getRecordTypeId());
@@ -249 +249 @@
         Record variant = repository.newRecord(idGenerator.newRecordId(record.getId(), variantProperties ));
         variant.setRecordType(recordType1.getId(), null);
-        variant.setField(Scope.NON_VERSIONABLE,fieldDescriptor1.getId(), "value2");
-        variant.setField(Scope.VERSIONABLE,fieldDescriptor2.getId(), 567);
-        variant.setField(Scope.VERSIONABLE_MUTABLE,fieldDescriptor3.getId(), false);
+        variant.setField(Scope.NON_VERSIONABLE,fieldDescriptor1.getName(), "value2");
+        variant.setField(Scope.VERSIONABLE,fieldDescriptor2.getName(), 567);
+        variant.setField(Scope.VERSIONABLE_MUTABLE,fieldDescriptor3.getName(), false);
         
         Record createdVariant = repository.create(variant);
         
         assertEquals(Long.valueOf(1), createdVariant.getVersion());
-        assertEquals("value2", createdVariant.getField(Scope.NON_VERSIONABLE,fieldDescriptor1.getId()));
-        assertEquals(567, createdVariant.getField(Scope.VERSIONABLE,fieldDescriptor2.getId()));
-        assertFalse((Boolean)createdVariant.getField(Scope.VERSIONABLE_MUTABLE,fieldDescriptor3.getId()));
+        assertEquals("value2", createdVariant.getField(Scope.NON_VERSIONABLE,fieldDescriptor1.getName()));
+        assertEquals(567, createdVariant.getField(Scope.VERSIONABLE,fieldDescriptor2.getName()));
+        assertFalse((Boolean)createdVariant.getField(Scope.VERSIONABLE_MUTABLE,fieldDescriptor3.getName()));
         
         assertEquals(createdVariant, repository.read(variant.getId()));
@@ -267 +267 @@
         Record record = createDefaultRecord(idGenerator.newRecordId());
         Record updateRecord = record.clone();
-        updateRecord.setField(Scope.NON_VERSIONABLE,fieldDescriptor1.getId(), "value2");
-        updateRecord.setField(Scope.VERSIONABLE,fieldDescriptor2.getId(), 789);
-        updateRecord.setField(Scope.VERSIONABLE_MUTABLE,fieldDescriptor3.getId(), false);
+        updateRecord.setField(Scope.NON_VERSIONABLE,fieldDescriptor1.getName(), "value2");
+        updateRecord.setField(Scope.VERSIONABLE,fieldDescriptor2.getName(), 789);
+        updateRecord.setField(Scope.VERSIONABLE_MUTABLE,fieldDescriptor3.getName(), false);
         
         Record updatedRecord = repository.update(updateRecord);
         
         assertEquals(Long.valueOf(2), updatedRecord.getVersion());
-        assertEquals("value2", updatedRecord.getField(Scope.NON_VERSIONABLE,fieldDescriptor1.getId()));
-        assertEquals(789, updatedRecord.getField(Scope.VERSIONABLE,fieldDescriptor2.getId()));
-        assertEquals(false, updatedRecord.getField(Scope.VERSIONABLE_MUTABLE,fieldDescriptor3.getId()));
+        assertEquals("value2", updatedRecord.getField(Scope.NON_VERSIONABLE,fieldDescriptor1.getName()));
+        assertEquals(789, updatedRecord.getField(Scope.VERSIONABLE,fieldDescriptor2.getName()));
+        assertEquals(false, updatedRecord.getField(Scope.VERSIONABLE_MUTABLE,fieldDescriptor3.getName()));
         
         assertEquals(updatedRecord, repository.read(record.getId()));
@@ -286 +286 @@
         Record updateRecord = repository.newRecord(record.getId());
         updateRecord.setRecordType(record.getRecordTypeId(), record.getRecordTypeVersion());
-        updateRecord.setField(Scope.NON_VERSIONABLE,fieldDescriptor1.getId(), "value2");
+        updateRecord.setField(Scope.NON_VERSIONABLE,fieldDescriptor1.getName(), "value2");
         
         Record updatedRecord = repository.update(updateRecord);
         
         assertEquals(Long.valueOf(1), updatedRecord.getVersion());
-        assertEquals("value2", updatedRecord.getField(Scope.NON_VERSIONABLE,fieldDescriptor1.getId()));
+        assertEquals("value2", updatedRecord.getField(Scope.NON_VERSIONABLE,fieldDescriptor1.getName()));
+        try {
+            updatedRecord.getField(Scope.VERSIONABLE,fieldDescriptor2.getName());
+            fail();
+        } catch (FieldNotFoundException expected) {
+        }
+        try {
+            updatedRecord.getField(Scope.VERSIONABLE_MUTABLE,fieldDescriptor3.getName());
+            fail();
+        } catch (FieldNotFoundException expected) {
+        }
+        
+        updatedRecord = repository.read(record.getId());
+        assertEquals("value2", updatedRecord.getField(Scope.NON_VERSIONABLE,fieldDescriptor1.getName()));
+        assertEquals(123, updatedRecord.getField(Scope.VERSIONABLE,fieldDescriptor2.getName()));
+        assertEquals(true, updatedRecord.getField(Scope.VERSIONABLE_MUTABLE,fieldDescriptor3.getName()));
+    }
+    
+    @Test
+    public void testEmptyUpdate() throws Exception {
+        Record record = createDefaultRecord(idGenerator.newRecordId());
+        Record updateRecord = repository.newRecord(record.getId());
+        updateRecord.setRecordType(record.getRecordTypeId(), record.getRecordTypeVersion());
+        
+        Record updatedRecord = repository.update(updateRecord);
+        
+        assertEquals(Long.valueOf(1), updatedRecord.getVersion());
+        try {
+            updatedRecord.getField(Scope.NON_VERSIONABLE,fieldDescriptor1.getId());
+            fail();
+        } catch (FieldNotFoundException expected) {
+        }
         try {
             updatedRecord.getField(Scope.VERSIONABLE,fieldDescriptor2.getId());
@@ -303 +334 @@
         }
         
-        updatedRecord = repository.read(record.getId());
-        assertEquals("value2", updatedRecord.getField(Scope.NON_VERSIONABLE,fieldDescriptor1.getId()));
-        assertEquals(123, updatedRecord.getField(Scope.VERSIONABLE,fieldDescriptor2.getId()));
-        assertEquals(true, updatedRecord.getField(Scope.VERSIONABLE_MUTABLE,fieldDescriptor3.getId()));
-    }
-    
-    @Test
-    public void testEmptyUpdate() throws Exception {
-        Record record = createDefaultRecord(idGenerator.newRecordId());
-        Record updateRecord = repository.newRecord(record.getId());
-        updateRecord.setRecordType(record.getRecordTypeId(), record.getRecordTypeVersion());
+        assertEquals(record, repository.read(record.getId()));
+    }
+    
+    @Test
+    public void testIdempotentUpdate() throws Exception {
+        Record record = createDefaultRecord(idGenerator.newRecordId());
+        Record updateRecord = record.clone();
         
         Record updatedRecord = repository.update(updateRecord);
         
         assertEquals(Long.valueOf(1), updatedRecord.getVersion());
-        try {
-            updatedRecord.getField(Scope.NON_VERSIONABLE,fieldDescriptor1.getId());
-            fail();
-        } catch (FieldNotFoundException expected) {
-        }
-        try {
-            updatedRecord.getField(Scope.VERSIONABLE,fieldDescriptor2.getId());
-            fail();
-        } catch (FieldNotFoundException expected) {
-        }
-        try {
-            updatedRecord.getField(Scope.VERSIONABLE_MUTABLE,fieldDescriptor3.getId());
-            fail();
-        } catch (FieldNotFoundException expected) {
-        }
-        
-        assertEquals(record, repository.read(record.getId()));
-    }
-    
-    @Test
-    public void testIdempotentUpdate() throws Exception {
-        Record record = createDefaultRecord(idGenerator.newRecordId());
-        Record updateRecord = record.clone();
-        
-        Record updatedRecord = repository.update(updateRecord);
-        
-        assertEquals(Long.valueOf(1), updatedRecord.getVersion());
-        assertEquals("value1", updatedRecord.getField(Scope.NON_VERSIONABLE,fieldDescriptor1.getId()));
-        assertEquals(123, updatedRecord.getField(Scope.VERSIONABLE,fieldDescriptor2.getId()));
-        assertEquals(true, updatedRecord.getField(Scope.VERSIONABLE_MUTABLE,fieldDescriptor3.getId()));
+        assertEquals("value1", updatedRecord.getField(Scope.NON_VERSIONABLE,fieldDescriptor1.getName()));
+        assertEquals(123, updatedRecord.getField(Scope.VERSIONABLE,fieldDescriptor2.getName()));
+        assertEquals(true, updatedRecord.getField(Scope.VERSIONABLE_MUTABLE,fieldDescriptor3.getName()));
         
         assertEquals(record, repository.read(record.getId()));
@@ -357 +357 @@
         Record updateRecord = record.clone();
         updateRecord.setVersion(Long.valueOf(99));
-        updateRecord.setField(Scope.NON_VERSIONABLE,fieldDescriptor1.getId(), "value2");
+        updateRecord.setField(Scope.NON_VERSIONABLE,fieldDescriptor1.getName(), "value2");
         
         Record updatedRecord = repository.update(updateRecord);
@@ -371 +371 @@
         Record updateRecord = repository.newRecord(record.getId());
         updateRecord.setRecordType(record.getRecordTypeId(), null);
-        updateRecord.setField(Scope.NON_VERSIONABLE,fieldDescriptor1.getId(), "aNewValue");
+        updateRecord.setField(Scope.NON_VERSIONABLE,fieldDescriptor1.getName(), "aNewValue");
         repository.update(updateRecord);
         
         Record readRecord = repository.read(record.getId());
         assertEquals(Long.valueOf(1), readRecord.getVersion());
-        assertEquals("aNewValue", readRecord.getField(Scope.NON_VERSIONABLE,fieldDescriptor1.getId()));
+        assertEquals("aNewValue", readRecord.getField(Scope.NON_VERSIONABLE,fieldDescriptor1.getName()));
     }
     
@@ -384 +384 @@
         Record record = createDefaultRecord(idGenerator.newRecordId());
         Record updateRecord = record.clone();
-        updateRecord.setField(Scope.NON_VERSIONABLE,fieldDescriptor1.getId(), "value2");
-        updateRecord.setField(Scope.VERSIONABLE,fieldDescriptor2.getId(), 789);
-        updateRecord.setField(Scope.VERSIONABLE_MUTABLE,fieldDescriptor3.getId(), false);
+        updateRecord.setField(Scope.NON_VERSIONABLE,fieldDescriptor1.getName(), "value2");
+        updateRecord.setField(Scope.VERSIONABLE,fieldDescriptor2.getName(), 789);
+        updateRecord.setField(Scope.VERSIONABLE_MUTABLE,fieldDescriptor3.getName(), false);
         
         repository.update(updateRecord);
         
-        record.setField(Scope.NON_VERSIONABLE,fieldDescriptor1.getId(), "value2");
+        record.setField(Scope.NON_VERSIONABLE,fieldDescriptor1.getName(), "value2");
         assertEquals(record, repository.read(record.getId(), Long.valueOf(1)));
     }
@@ -426 +426 @@
         Record updateRecord = repository.newRecord(record.getId());
         updateRecord.setRecordType(recordType1B.getId(), recordType1B.getVersion());
-        updateRecord.setField(Scope.NON_VERSIONABLE,fieldDescriptor1.getId(), "value2");
-        updateRecord.setField(Scope.VERSIONABLE,fieldDescriptor2.getId(), 789);
-        updateRecord.setField(Scope.VERSIONABLE_MUTABLE,fieldDescriptor3.getId(), false);
+        updateRecord.setField(Scope.NON_VERSIONABLE,fieldDescriptor1.getName(), "value2");
+        updateRecord.setField(Scope.VERSIONABLE,fieldDescriptor2.getName(), 789);
+        updateRecord.setField(Scope.VERSIONABLE_MUTABLE,fieldDescriptor3.getName(), false);
         
         Record updatedRecord = repository.update(updateRecord);
@@ -456 +456 @@
         Record updateRecord = repository.newRecord(record.getId());
         updateRecord.setRecordType(recordType1B.getId(), recordType1B.getVersion());
-        updateRecord.setField(Scope.VERSIONABLE,fieldDescriptor2.getId(), 789);
+        updateRecord.setField(Scope.VERSIONABLE,fieldDescriptor2.getName(), 789);
         
         Record updatedRecord = repository.update(updateRecord);
@@ -480 +480 @@
         Record updateRecord = repository.newRecord(record.getId());
         updateRecord.setRecordType(recordType2.getId(), recordType2.getVersion());
-        updateRecord.setField(Scope.NON_VERSIONABLE,fieldDescriptor2.getId(), 789);
-        updateRecord.setField(Scope.VERSIONABLE,fieldDescriptor3.getId(), false);
-        updateRecord.setField(Scope.VERSIONABLE_MUTABLE,fieldDescriptor1.getId(), "value2");
+        updateRecord.setField(Scope.NON_VERSIONABLE,fieldDescriptor2.getName(), 789);
+        updateRecord.setField(Scope.VERSIONABLE,fieldDescriptor3.getName(), false);
+        updateRecord.setField(Scope.VERSIONABLE_MUTABLE,fieldDescriptor1.getName(), "value2");
         
         Record updatedRecord = repository.update(updateRecord);
@@ -503 +503 @@
         assertEquals(2, readRecord.getFields(Scope.VERSIONABLE).size());
         assertEquals(2, readRecord.getFields(Scope.VERSIONABLE_MUTABLE).size());
-        assertEquals("value1", readRecord.getField(Scope.NON_VERSIONABLE,fieldDescriptor1.getId()));
-        assertEquals(789, readRecord.getField(Scope.NON_VERSIONABLE,fieldDescriptor2.getId()));
-        assertEquals(123, readRecord.getField(Scope.VERSIONABLE,fieldDescriptor2.getId()));
-        assertFalse((Boolean)readRecord.getField(Scope.VERSIONABLE,fieldDescriptor3.getId()));
-        assertTrue((Boolean)readRecord.getField(Scope.VERSIONABLE_MUTABLE,fieldDescriptor3.getId()));
-        assertEquals("value2", readRecord.getField(Scope.VERSIONABLE_MUTABLE,fieldDescriptor1.getId()));
-
+        assertEquals("value1", readRecord.getField(Scope.NON_VERSIONABLE,fieldDescriptor1.getName()));
+        assertEquals(789, readRecord.getField(Scope.NON_VERSIONABLE,fieldDescriptor2.getName()));
+        assertEquals(123, readRecord.getField(Scope.VERSIONABLE,fieldDescriptor2.getName()));
+        assertFalse((Boolean)readRecord.getField(Scope.VERSIONABLE,fieldDescriptor3.getName()));
+        assertTrue((Boolean)readRecord.getField(Scope.VERSIONABLE_MUTABLE,fieldDescriptor3.getName()));
+        assertEquals("value2", readRecord.getField(Scope.VERSIONABLE_MUTABLE,fieldDescriptor1.getName()));
     }
     
@@ -517 +516 @@
         Record deleteRecord = repository.newRecord(record.getId());
         deleteRecord.setRecordType(record.getRecordTypeId(), null);
-        deleteRecord.addFieldsToDelete(Scope.NON_VERSIONABLE,Arrays.asList(new String[]{fieldDescriptor1.getId()}));
-        deleteRecord.addFieldsToDelete(Scope.VERSIONABLE,Arrays.asList(new String[]{fieldDescriptor2.getId()}));
-        deleteRecord.addFieldsToDelete(Scope.VERSIONABLE_MUTABLE,Arrays.asList(new String[]{fieldDescriptor3.getId()}));
+        deleteRecord.addFieldsToDelete(Scope.NON_VERSIONABLE,Arrays.asList(new String[]{fieldDescriptor1.getName()}));
+        deleteRecord.addFieldsToDelete(Scope.VERSIONABLE,Arrays.asList(new String[]{fieldDescriptor2.getName()}));
+        deleteRecord.addFieldsToDelete(Scope.VERSIONABLE_MUTABLE,Arrays.asList(new String[]{fieldDescriptor3.getName()}));
         
         repository.update(deleteRecord);
@@ -533 +532 @@
         Record updateRecord = repository.newRecord(record.getId());
         updateRecord.setRecordType(recordType2.getId(), recordType2.getVersion());
-        updateRecord.setField(Scope.NON_VERSIONABLE,fieldDescriptor2.getId(), 789);
-        updateRecord.setField(Scope.VERSIONABLE,fieldDescriptor3.getId(), false);
-        updateRecord.setField(Scope.VERSIONABLE_MUTABLE,fieldDescriptor1.getId(), "value2");
+        updateRecord.setField(Scope.NON_VERSIONABLE,fieldDescriptor2.getName(), 789);
+        updateRecord.setField(Scope.VERSIONABLE,fieldDescriptor3.getName(), false);
+        updateRecord.setField(Scope.VERSIONABLE_MUTABLE,fieldDescriptor1.getName(), "value2");
         
         repository.update(updateRecord);
         
         Record deleteRecord = repository.newRecord(record.getId());
-        deleteRecord.setRecordType(recordType2.getId(), recordType2.getVersion());
-        deleteRecord.addFieldsToDelete(Scope.NON_VERSIONABLE,Arrays.asList(new String[]{fieldDescriptor1.getId()}));
+        deleteRecord.setRecordType(recordType1.getId(), recordType1.getVersion());
+        deleteRecord.addFieldsToDelete(Scope.NON_VERSIONABLE,Arrays.asList(new String[]{fieldDescriptor1.getName()}));
         repository.update(deleteRecord);
         
@@ -548 +547 @@
         assertEquals(1, readRecord.getFields(Scope.NON_VERSIONABLE).size());
         try {
-            readRecord.getField(Scope.NON_VERSIONABLE,fieldDescriptor1.getId());
-            fail();
-        } catch (FieldNotFoundException expected) {
-        }
-        assertEquals("value2", readRecord.getField(Scope.VERSIONABLE_MUTABLE,fieldDescriptor1.getId()));
-        assertEquals(789, readRecord.getField(Scope.NON_VERSIONABLE,fieldDescriptor2.getId()));
-        
-        deleteRecord.addFieldsToDelete(Scope.VERSIONABLE,Arrays.asList(new String[]{fieldDescriptor2.getId()}));
-        deleteRecord.addFieldsToDelete(Scope.VERSIONABLE_MUTABLE, Arrays.asList(new String[]{fieldDescriptor3.getId()}));
+            readRecord.getField(Scope.NON_VERSIONABLE,fieldDescriptor1.getName());
+            fail();
+        } catch (FieldNotFoundException expected) {
+        }
+        assertEquals("value2", readRecord.getField(Scope.VERSIONABLE_MUTABLE,fieldDescriptor1.getName()));
+        assertEquals(789, readRecord.getField(Scope.NON_VERSIONABLE,fieldDescriptor2.getName()));
+        
+        deleteRecord.addFieldsToDelete(Scope.VERSIONABLE,Arrays.asList(new String[]{fieldDescriptor2.getName()}));
+        deleteRecord.addFieldsToDelete(Scope.VERSIONABLE_MUTABLE, Arrays.asList(new String[]{fieldDescriptor3.getName()}));
         repository.update(deleteRecord);
         
@@ -564 +563 @@
         assertEquals(1, readRecord.getFields(Scope.VERSIONABLE).size());
         assertEquals(1, readRecord.getFields(Scope.VERSIONABLE_MUTABLE).size());
-        assertEquals(789, readRecord.getField(Scope.NON_VERSIONABLE,fieldDescriptor2.getId()));
-        assertEquals(false, readRecord.getField(Scope.VERSIONABLE,fieldDescriptor3.getId()));
-        assertEquals("value2", readRecord.getField(Scope.VERSIONABLE_MUTABLE,fieldDescriptor1.getId()));
+        assertEquals(789, readRecord.getField(Scope.NON_VERSIONABLE,fieldDescriptor2.getName()));
+        assertEquals(false, readRecord.getField(Scope.VERSIONABLE,fieldDescriptor3.getName()));
+        assertEquals("value2", readRecord.getField(Scope.VERSIONABLE_MUTABLE,fieldDescriptor1.getName()));
     }
     
@@ -574 +573 @@
         Record deleteRecord = repository.newRecord(record.getId());
         deleteRecord.setRecordType(record.getRecordTypeId(), record.getRecordTypeVersion());
-        deleteRecord.addFieldsToDelete(Scope.VERSIONABLE,Arrays.asList(new String[]{fieldDescriptor2.getId()}));
+        deleteRecord.addFieldsToDelete(Scope.VERSIONABLE,Arrays.asList(new String[]{fieldDescriptor2.getName()}));
         repository.update(deleteRecord);
         
         Record updateRecord = repository.newRecord(record.getId());
         updateRecord.setRecordType(record.getRecordTypeId(), record.getRecordTypeVersion());
-        updateRecord.setField(Scope.VERSIONABLE,fieldDescriptor2.getId(), 789);
+        updateRecord.setField(Scope.VERSIONABLE,fieldDescriptor2.getName(), 789);
         repository.update(updateRecord);
         
         Record readRecord = repository.read(record.getId());
         assertEquals(Long.valueOf(3), readRecord.getVersion());
-        assertEquals(789, readRecord.getField(Scope.VERSIONABLE,fieldDescriptor2.getId()));
+        assertEquals(789, readRecord.getField(Scope.VERSIONABLE,fieldDescriptor2.getName()));
         
         readRecord = repository.read(record.getId(), Long.valueOf(2));
         try {
-            readRecord.getField(Scope.VERSIONABLE,fieldDescriptor2.getId());
+            readRecord.getField(Scope.VERSIONABLE,fieldDescriptor2.getName());
             fail();
         } catch (FieldNotFoundException expected) {
@@ -594 +593 @@
         
         readRecord = repository.read(record.getId(), Long.valueOf(1));
-        assertEquals(123, readRecord.getField(Scope.VERSIONABLE,fieldDescriptor2.getId()));
+        assertEquals(123, readRecord.getField(Scope.VERSIONABLE,fieldDescriptor2.getName()));
     }
     
@@ -602 +601 @@
         Record updateRecord = repository.newRecord(record.getId());
         updateRecord.setRecordType(record.getRecordTypeId(), record.getRecordTypeVersion());
-        updateRecord.setField(Scope.VERSIONABLE,fieldDescriptor2.getId(), 999);
-        updateRecord.addFieldsToDelete(Scope.NON_VERSIONABLE,Arrays.asList(new String[]{fieldDescriptor1.getId()}));
+        updateRecord.setField(Scope.VERSIONABLE,fieldDescriptor2.getName(), 999);
+        updateRecord.addFieldsToDelete(Scope.NON_VERSIONABLE,Arrays.asList(new String[]{fieldDescriptor1.getName()}));
         repository.update(updateRecord);
         
         Record readRecord = repository.read(record.getId());
-        assertEquals(999, readRecord.getField(Scope.VERSIONABLE,fieldDescriptor2.getId()));
-        try {
-            readRecord.getField(Scope.NON_VERSIONABLE,fieldDescriptor1.getId());
+        assertEquals(999, readRecord.getField(Scope.VERSIONABLE,fieldDescriptor2.getName()));
+        try {
+            readRecord.getField(Scope.NON_VERSIONABLE,fieldDescriptor1.getName());
             fail();
         } catch (FieldNotFoundException expected) {
@@ -616 +615 @@
         readRecord = repository.read(record.getId(), Long.valueOf(1));
         try {
-            readRecord.getField(Scope.NON_VERSIONABLE,fieldDescriptor1.getId());
+            readRecord.getField(Scope.NON_VERSIONABLE,fieldDescriptor1.getName());
             fail();
         } catch (FieldNotFoundException expected) {
@@ -628 +627 @@
         Record updateRecord = repository.newRecord(record.getId());
         updateRecord.setRecordType(record.getRecordTypeId(), record.getRecordTypeVersion());
-        updateRecord.setField(Scope.VERSIONABLE,fieldDescriptor2.getId(), 789);
-        updateRecord.addFieldsToDelete(Scope.VERSIONABLE,Arrays.asList(new String[]{fieldDescriptor2.getId()}));
+        updateRecord.setField(Scope.VERSIONABLE,fieldDescriptor2.getName(), 789);
+        updateRecord.addFieldsToDelete(Scope.VERSIONABLE,Arrays.asList(new String[]{fieldDescriptor2.getName()}));
         repository.update(updateRecord);
         
         try {
-            repository.read(record.getId()).getField(Scope.VERSIONABLE,fieldDescriptor2.getId());
+            repository.read(record.getId()).getField(Scope.VERSIONABLE,fieldDescriptor2.getName());
             fail();
         } catch (FieldNotFoundException expected) {
@@ -654 +653 @@
         Record record = createDefaultRecord(idGenerator.newRecordId());
         Record updateRecord = record.clone();
-        updateRecord.setField(Scope.NON_VERSIONABLE,fieldDescriptor1.getId(), "value2");
-        updateRecord.setField(Scope.VERSIONABLE,fieldDescriptor2.getId(), 789);
-        updateRecord.setField(Scope.VERSIONABLE_MUTABLE,fieldDescriptor3.getId(), false);
+        updateRecord.setField(Scope.NON_VERSIONABLE,fieldDescriptor1.getName(), "value2");
+        updateRecord.setField(Scope.VERSIONABLE,fieldDescriptor2.getName(), 789);
+        updateRecord.setField(Scope.VERSIONABLE_MUTABLE,fieldDescriptor3.getName(), false);
         repository.update(updateRecord);
         
@@ -663 +662 @@
         
         Record readRecord = repository.read(record.getId(), Long.valueOf(1));
-        assertEquals("value2", readRecord.getField(Scope.NON_VERSIONABLE, fieldDescriptor1.getId())); 
-        assertEquals(123, readRecord.getField(Scope.VERSIONABLE, fieldDescriptor2.getId())); 
-        assertEquals(false, readRecord.getField(Scope.VERSIONABLE_MUTABLE, fieldDescriptor3.getId())); 
+        assertEquals("value2", readRecord.getField(Scope.NON_VERSIONABLE, fieldDescriptor1.getName())); 
+        assertEquals(123, readRecord.getField(Scope.VERSIONABLE, fieldDescriptor2.getName())); 
+        assertEquals(false, readRecord.getField(Scope.VERSIONABLE_MUTABLE, fieldDescriptor3.getName())); 
     }
     
@@ -672 +671 @@
         Record record = createDefaultRecord(idGenerator.newRecordId());
         Record updateRecord = record.clone();
-        updateRecord.setField(Scope.NON_VERSIONABLE,fieldDescriptor1.getId(), "value2");
-        updateRecord.setField(Scope.VERSIONABLE,fieldDescriptor2.getId(), 789);
-        updateRecord.setField(Scope.VERSIONABLE_MUTABLE,fieldDescriptor3.getId(), false);
+        updateRecord.setField(Scope.NON_VERSIONABLE,fieldDescriptor1.getName(), "value2");
+        updateRecord.setField(Scope.VERSIONABLE,fieldDescriptor2.getName(), 789);
+        updateRecord.setField(Scope.VERSIONABLE_MUTABLE,fieldDescriptor3.getName(), false);
         repository.update(updateRecord);
         
@@ -680 +679 @@
         updateMutableRecord.setVersion(Long.valueOf(1));
         updateMutableRecord.setRecordType(recordType2.getId(), recordType2.getVersion());
-        updateMutableRecord.setField(Scope.NON_VERSIONABLE,fieldDescriptor2.getId(), 789);
-        updateMutableRecord.setField(Scope.VERSIONABLE,fieldDescriptor3.getId(), false);
-        updateMutableRecord.setField(Scope.VERSIONABLE_MUTABLE,fieldDescriptor1.getId(), "value3");
+        updateMutableRecord.setField(Scope.NON_VERSIONABLE,fieldDescriptor2.getName(), 789);
+        updateMutableRecord.setField(Scope.VERSIONABLE,fieldDescriptor3.getName(), false);
+        updateMutableRecord.setField(Scope.VERSIONABLE_MUTABLE,fieldDescriptor1.getName(), "value3");
         assertEquals(Long.valueOf(1), repository.updateMutableFields(updateMutableRecord).getVersion());
         
         Record readRecord = repository.read(record.getId(), Long.valueOf(1));
         assertEquals(Long.valueOf(1), readRecord.getVersion());
-        assertEquals("value2", readRecord.getField(Scope.NON_VERSIONABLE, fieldDescriptor1.getId())); 
-        assertEquals(123, readRecord.getField(Scope.VERSIONABLE, fieldDescriptor2.getId())); 
-        assertEquals(true, readRecord.getField(Scope.VERSIONABLE_MUTABLE, fieldDescriptor3.getId())); 
-        assertEquals("value3", readRecord.getField(Scope.VERSIONABLE_MUTABLE, fieldDescriptor1.getId()));
-        try {
-            readRecord.getField(Scope.NON_VERSIONABLE, fieldDescriptor2.getId());
-            fail();
-        } catch (FieldNotFoundException expected) {
-        }
-        try {
-            readRecord.getField(Scope.VERSIONABLE, fieldDescriptor3.getId());
+        assertEquals("value2", readRecord.getField(Scope.NON_VERSIONABLE, fieldDescriptor1.getName())); 
+        assertEquals(123, readRecord.getField(Scope.VERSIONABLE, fieldDescriptor2.getName())); 
+        assertEquals(true, readRecord.getField(Scope.VERSIONABLE_MUTABLE, fieldDescriptor3.getName())); 
+        assertEquals("value3", readRecord.getField(Scope.VERSIONABLE_MUTABLE, fieldDescriptor1.getName()));
+        try {
+            readRecord.getField(Scope.NON_VERSIONABLE, fieldDescriptor2.getName());
+            fail();
+        } catch (FieldNotFoundException expected) {
+        }
+        try {
+            readRecord.getField(Scope.VERSIONABLE, fieldDescriptor3.getName());
             fail();
         } catch (FieldNotFoundException expected) {
@@ -708 +707 @@
         readRecord = repository.read(record.getId());
         assertEquals(Long.valueOf(2), readRecord.getVersion());
-        assertEquals("value2", readRecord.getField(Scope.NON_VERSIONABLE, fieldDescriptor1.getId())); 
-        assertEquals(789, readRecord.getField(Scope.VERSIONABLE, fieldDescriptor2.getId())); 
-        assertEquals(false, readRecord.getField(Scope.VERSIONABLE_MUTABLE, fieldDescriptor3.getId())); 
-        assertEquals("value3", readRecord.getField(Scope.VERSIONABLE_MUTABLE, fieldDescriptor1.getId()));
+        assertEquals("value2", readRecord.getField(Scope.NON_VERSIONABLE, fieldDescriptor1.getName())); 
+        assertEquals(789, readRecord.getField(Scope.VERSIONABLE, fieldDescriptor2.getName())); 
+        assertEquals(false, readRecord.getField(Scope.VERSIONABLE_MUTABLE, fieldDescriptor3.getName())); 
+        assertEquals("value3", readRecord.getField(Scope.VERSIONABLE_MUTABLE, fieldDescriptor1.getName()));
         assertEquals(recordType1.getId(), readRecord.getRecordTypeId());
         assertEquals(recordType1.getId(), readRecord.getRecordTypeId(Scope.NON_VERSIONABLE));
@@ -722 +721 @@
         Record record = createDefaultRecord(idGenerator.newRecordId());
         Record updateRecord = record.clone();
-        updateRecord.setField(Scope.NON_VERSIONABLE,fieldDescriptor1.getId(), "value2");
-        updateRecord.setField(Scope.VERSIONABLE,fieldDescriptor2.getId(), 789);
-        updateRecord.setField(Scope.VERSIONABLE_MUTABLE,fieldDescriptor3.getId(), false);
+        updateRecord.setField(Scope.NON_VERSIONABLE,fieldDescriptor1.getName(), "value2");
+        updateRecord.setField(Scope.VERSIONABLE,fieldDescriptor2.getName(), 789);
+        updateRecord.setField(Scope.VERSIONABLE_MUTABLE,fieldDescriptor3.getName(), false);
         repository.update(updateRecord);
         
@@ -730 +729 @@
         deleteRecord.setVersion(Long.valueOf(1));
         deleteRecord.setRecordType(record.getRecordTypeId(), record.getRecordTypeVersion());
-        deleteRecord.addFieldsToDelete(Scope.NON_VERSIONABLE, Arrays.asList(new String[]{fieldDescriptor1.getId()}));
-        deleteRecord.addFieldsToDelete(Scope.VERSIONABLE, Arrays.asList(new String[]{fieldDescriptor2.getId()}));
-        deleteRecord.addFieldsToDelete(Scope.VERSIONABLE_MUTABLE, Arrays.asList(new String[]{fieldDescriptor3.getId()}));
+        deleteRecord.addFieldsToDelete(Scope.NON_VERSIONABLE, Arrays.asList(new String[]{fieldDescriptor1.getName()}));
+        deleteRecord.addFieldsToDelete(Scope.VERSIONABLE, Arrays.asList(new String[]{fieldDescriptor2.getName()}));
+        deleteRecord.addFieldsToDelete(Scope.VERSIONABLE_MUTABLE, Arrays.asList(new String[]{fieldDescriptor3.getName()}));
         
         repository.updateMutableFields(deleteRecord);
         
         Record readRecord = repository.read(record.getId(), Long.valueOf(1));
-        assertEquals("value2", readRecord.getField(Scope.NON_VERSIONABLE, fieldDescriptor1.getId())); 
-        assertEquals(123, readRecord.getField(Scope.VERSIONABLE, fieldDescriptor2.getId())); 
-        try {
-            readRecord.getField(Scope.VERSIONABLE_MUTABLE, fieldDescriptor3.getId());
+        assertEquals("value2", readRecord.getField(Scope.NON_VERSIONABLE, fieldDescriptor1.getName())); 
+        assertEquals(123, readRecord.getField(Scope.VERSIONABLE, fieldDescriptor2.getName())); 
+        try {
+            readRecord.getField(Scope.VERSIONABLE_MUTABLE, fieldDescriptor3.getName());
             fail();
         } catch (FieldNotFoundException expected) {
@@ -746 +745 @@
 
         readRecord = repository.read(record.getId());
-        assertEquals(false, readRecord.getField(Scope.VERSIONABLE_MUTABLE, fieldDescriptor3.getId()));
+        assertEquals(false, readRecord.getField(Scope.VERSIONABLE_MUTABLE, fieldDescriptor3.getName()));
     }
     
@@ -753 +752 @@
         Record record = createDefaultRecord(idGenerator.newRecordId());
         Record updateRecord = record.clone();
-        updateRecord.setField(Scope.NON_VERSIONABLE,fieldDescriptor1.getId(), "value2");
-        updateRecord.setField(Scope.VERSIONABLE,fieldDescriptor2.getId(), 789);
+        updateRecord.setField(Scope.NON_VERSIONABLE,fieldDescriptor1.getName(), "value2");
+        updateRecord.setField(Scope.VERSIONABLE,fieldDescriptor2.getName(), 789);
         updateRecord = repository.update(updateRecord); // Leave mutable field same on first update
 
-        updateRecord.setField(Scope.VERSIONABLE_MUTABLE,fieldDescriptor3.getId(), false);
+        updateRecord.setField(Scope.VERSIONABLE_MUTABLE,fieldDescriptor3.getName(), false);
         updateRecord = repository.update(updateRecord);
         
@@ -763 +762 @@
         deleteRecord.setVersion(Long.valueOf(1));
         deleteRecord.setRecordType(record.getRecordTypeId(), record.getRecordTypeVersion());
-        deleteRecord.addFieldsToDelete(Scope.VERSIONABLE_MUTABLE, Arrays.asList(new String[]{fieldDescriptor3.getId()}));
+        deleteRecord.addFieldsToDelete(Scope.VERSIONABLE_MUTABLE, Arrays.asList(new String[]{fieldDescriptor3.getName()}));
         
         repository.updateMutableFields(deleteRecord);
@@ -769 +768 @@
         Record readRecord = repository.read(record.getId(), Long.valueOf(1));
         try {
-            readRecord.getField(Scope.VERSIONABLE_MUTABLE, fieldDescriptor3.getId());
+            readRecord.getField(Scope.VERSIONABLE_MUTABLE, fieldDescriptor3.getName());
             fail();
         } catch (FieldNotFoundException expected) {
@@ -775 +774 @@
 
         readRecord = repository.read(record.getId(), Long.valueOf(2));
-        assertEquals(true, readRecord.getField(Scope.VERSIONABLE_MUTABLE, fieldDescriptor3.getId()));
+        assertEquals(true, readRecord.getField(Scope.VERSIONABLE_MUTABLE, fieldDescriptor3.getName()));
         
         readRecord = repository.read(record.getId());
-        assertEquals(false, readRecord.getField(Scope.VERSIONABLE_MUTABLE, fieldDescriptor3.getId()));
+        assertEquals(false, readRecord.getField(Scope.VERSIONABLE_MUTABLE, fieldDescriptor3.getName()));
+    }
+    
+    @Test
+    public void testMixin() throws Exception {
+        FieldDescriptor fieldDescriptor4 = typeManager.createFieldDescriptor(typeManager.newFieldDescriptor(typeManager.getValueType("STRING", false, false), "field4"));
+        FieldGroup fieldGroup4 = typeManager.newFieldGroup("FG4");
+        fieldGroup4.setFieldGroupEntry(typeManager.newFieldGroupEntry(fieldDescriptor4.getId(), fieldDescriptor4.getVersion(), false, "alias4"));
+        fieldGroup4 = typeManager.createFieldGroup(fieldGroup4);
+        RecordType recordType4 = typeManager.newRecordType("RT4");
+        recordType4.setFieldGroupId(Scope.VERSIONABLE,fieldGroup4.getId());
+        recordType4.setFieldGroupVersion(Scope.VERSIONABLE,fieldGroup4.getVersion());
+        recordType4.addMixin(recordType1.getId(), recordType1.getVersion());
+        recordType4 = typeManager.createRecordType(recordType4);
+        
+        Record record = repository.newRecord(idGenerator.newRecordId());
+        record.setRecordType(recordType4.getId(), recordType4.getVersion());
+        record.setField(Scope.NON_VERSIONABLE,fieldDescriptor1.getName(), "foo");
+        record.setField(Scope.VERSIONABLE,fieldDescriptor2.getName(), 555);
+        record.setField(Scope.VERSIONABLE, fieldDescriptor4.getName(), "bar");
+        record.setField(Scope.VERSIONABLE_MUTABLE,fieldDescriptor3.getName(), true);
+        record = repository.create(record);
+        
+        Record readRecord = repository.read(record.getId());
+        assertEquals(Long.valueOf(1), readRecord.getVersion());
+        assertEquals("foo", readRecord.getField(Scope.NON_VERSIONABLE, fieldDescriptor1.getName()));
+        assertEquals(555, readRecord.getField(Scope.VERSIONABLE, fieldDescriptor2.getName()));
+        assertEquals("bar", readRecord.getField(Scope.VERSIONABLE, fieldDescriptor4.getName()));
+        assertEquals(true, readRecord.getField(Scope.VERSIONABLE_MUTABLE, fieldDescriptor3.getName()));
+    }
+    
+    @Test
+    public void testUpdateNameFieldDescriptor() throws Exception {
+        // TODO : store fieldDescriptorVersion together with fieldValue
+        
+//        FieldDescriptor updatedFieldDescriptor = fieldDescriptor2.clone();
+//        updatedFieldDescriptor.setName("newName");
+//        updatedFieldDescriptor = typeManager.updateFieldDescriptor(updatedFieldDescriptor);
+//        
+//        FieldGroup fieldGroup5 = typeManager.newFieldGroup("FG5");
+//        fieldGroup5.setFieldGroupEntry(typeManager.newFieldGroupEntry(updatedFieldDescriptor.getId(), updatedFieldDescriptor.getVersion(), false, "alias5"));
+//        fieldGroup5 = typeManager.createFieldGroup(fieldGroup5);
+//        RecordType recordType5 = typeManager.newRecordType("RT5");
+//        recordType5.setFieldGroupId(Scope.VERSIONABLE,fieldGroup5.getId());
+//        recordType5.setFieldGroupVersion(Scope.VERSIONABLE,fieldGroup5.getVersion());
+//        recordType5 = typeManager.createRecordType(recordType5);
+//        
+//        Record record = createDefaultRecord(idGenerator.newRecordId());
+//        Record record2 = repository.newRecord(record.getId());
+//        record2.setRecordType(recordType5.getId(), recordType5.getVersion());
+//        record2.setField(Scope.VERSIONABLE, "newName", 54321);
+//        repository.update(record2);
+//        
+//        Record readRecord = repository.read(record.getId());
+//        assertEquals(1, readRecord.getFields(Scope.VERSIONABLE).size());
+//        assertEquals(54321, readRecord.getField(Scope.VERSIONABLE, "newName"));
+//        
+//        readRecord = repository.read(record.getId(), Long.valueOf(1));
+//        assertEquals(1, readRecord.getFields(Scope.VERSIONABLE).size());
+//        assertEquals(123, readRecord.getField(Scope.VERSIONABLE, fieldDescriptor2.getName()));
     }
 }

projects/lily/trunk/repository/impl/src/test/java/org/lilycms/repository/impl/test/TypeManagerFieldDescriptorTest.java

@@ -17 +17 @@
 
 
+import static org.junit.Assert.*;
+
 import org.apache.hadoop.hbase.HBaseTestingUtility;
 import org.junit.After;
 import org.junit.AfterClass;
-import static org.junit.Assert.*;
 import org.junit.Before;
 import org.junit.BeforeClass;
 import org.junit.Test;
 import org.lilycms.repository.api.FieldDescriptor;
-import org.lilycms.repository.api.FieldDescriptorExistsException;
 import org.lilycms.repository.api.FieldDescriptorNotFoundException;
 import org.lilycms.repository.api.FieldDescriptorUpdateException;
 import org.lilycms.repository.api.TypeManager;
 import org.lilycms.repository.api.ValueType;
-import org.lilycms.repository.impl.FieldDescriptorImpl;
 import org.lilycms.repository.impl.HBaseTypeManager;
 import org.lilycms.repository.impl.IdGeneratorImpl;
-import org.lilycms.repository.impl.RecordTypeImpl;
 import org.lilycms.testfw.TestHelper;
 
@@ -64 +62 @@
     @Test
     public void testCreate() throws Exception {
-        String id = "testCreate";
+        String name = "testCreate";
         ValueType valueType = typeManager.getValueType("STRING", false, false);
-        FieldDescriptor fieldDescriptor = typeManager.newFieldDescriptor(id, valueType , "aGlobalName");
-        typeManager.createFieldDescriptor(fieldDescriptor);
-        fieldDescriptor.setVersion(Long.valueOf(1));
+        FieldDescriptor fieldDescriptor = typeManager.newFieldDescriptor(valueType , name);
+        fieldDescriptor = typeManager.createFieldDescriptor(fieldDescriptor);
+        assertEquals(Long.valueOf(1), fieldDescriptor.getVersion());
         assertEquals(fieldDescriptor, typeManager.getFieldDescriptor(fieldDescriptor.getId(), null));
     }
@@ -74 +72 @@
     @Test
     public void testCreateIgnoresVersion() throws Exception {
-        String id = "testCreateIgnoresVersion";
+        String name = "testCreateIgnoresVersion";
         ValueType valueType = typeManager.getValueType("STRING", false, false);
-        FieldDescriptor fieldDescriptor = typeManager.newFieldDescriptor(id, valueType , "aGlobalName");
+        FieldDescriptor fieldDescriptor = typeManager.newFieldDescriptor(valueType , name);
         fieldDescriptor.setVersion(Long.valueOf(5));
-        typeManager.createFieldDescriptor(fieldDescriptor);
-        fieldDescriptor.setVersion(Long.valueOf(1));
+        fieldDescriptor = typeManager.createFieldDescriptor(fieldDescriptor);
+        assertEquals(Long.valueOf(1), fieldDescriptor.getVersion());
         assertEquals(fieldDescriptor, typeManager.getFieldDescriptor(fieldDescriptor.getId(), null));
     }
     
     @Test
-    public void testCreateExistingFails() throws Exception {
+    public void testCreateIgnoresGivenId() throws Exception {
         String id = "testCreateExistingFails";
         ValueType valueType = typeManager.getValueType("STRING", false, false);
         FieldDescriptor fieldDescriptor = typeManager.newFieldDescriptor(id, valueType , "aGlobalName");
-        typeManager.createFieldDescriptor(fieldDescriptor);
-        try {
-            typeManager.createFieldDescriptor(fieldDescriptor);
-            fail("Creating an existing fieldDescriptor is not allowed. Use update instead.");
-        } catch (FieldDescriptorExistsException expected) {
-        }
+        fieldDescriptor = typeManager.createFieldDescriptor(fieldDescriptor);
+        assertFalse(fieldDescriptor.getId().equals(typeManager.createFieldDescriptor(fieldDescriptor.clone())));
     }
 
     @Test
     public void testUpdate() throws Exception {
-        String id = "testUpdate";
+        String name = "testUpdate";
         ValueType valueType = typeManager.getValueType("STRING", false, false);
-        FieldDescriptor fieldDescriptorCreate = typeManager.newFieldDescriptor(id, valueType , "aGlobalName");
-        typeManager.createFieldDescriptor(fieldDescriptorCreate);
+        FieldDescriptor fieldDescriptorCreate = typeManager.newFieldDescriptor(valueType , name);
+        fieldDescriptorCreate = typeManager.createFieldDescriptor(fieldDescriptorCreate);
         
-        FieldDescriptor fieldDescriptorGlobalName = typeManager.newFieldDescriptor(id, valueType , "newGlobalName");
-        typeManager.updateFieldDescriptor(fieldDescriptorGlobalName);
-        fieldDescriptorGlobalName.setVersion(Long.valueOf(2));
-        assertEquals(fieldDescriptorGlobalName, typeManager.getFieldDescriptor(id, null));
+        FieldDescriptor fieldDescriptorNewName = typeManager.newFieldDescriptor(fieldDescriptorCreate.getId(), valueType , "newName");
+        fieldDescriptorNewName = typeManager.updateFieldDescriptor(fieldDescriptorNewName);
+        assertEquals(fieldDescriptorCreate.getId(), fieldDescriptorNewName.getId());
+        assertEquals(Long.valueOf(2), fieldDescriptorNewName.getVersion());
+        assertEquals(fieldDescriptorNewName, typeManager.getFieldDescriptor(fieldDescriptorCreate.getId(), null));
         
     }
@@ -112 +107 @@
     @Test
     public void testUpdateVersions() throws Exception {
-        String id = "testUpdateVersions";
+        String name = "testUpdateVersions";
         ValueType valueType = typeManager.getValueType("STRING", false, false);
-        FieldDescriptor fieldDescriptorCreate = typeManager.newFieldDescriptor(id, valueType , "aGlobalName");
-        typeManager.createFieldDescriptor(fieldDescriptorCreate);
+        FieldDescriptor fieldDescriptorCreate = typeManager.newFieldDescriptor(valueType , name);
+        fieldDescriptorCreate = typeManager.createFieldDescriptor(fieldDescriptorCreate);
         
-        FieldDescriptor fieldDescriptorGlobalName = typeManager.newFieldDescriptor(id, valueType , "newGlobalName");
+        FieldDescriptor fieldDescriptorNewName = typeManager.newFieldDescriptor(fieldDescriptorCreate.getId(), valueType , "newName");
         // Update should ignore version
-        fieldDescriptorGlobalName.setVersion(Long.valueOf(99));
-        FieldDescriptor updatedFieldDescriptor = typeManager.updateFieldDescriptor(fieldDescriptorGlobalName);
+        fieldDescriptorNewName.setVersion(Long.valueOf(99));
+        FieldDescriptor updatedFieldDescriptor = typeManager.updateFieldDescriptor(fieldDescriptorNewName);
         assertEquals(Long.valueOf(2), updatedFieldDescriptor.getVersion());
-        fieldDescriptorGlobalName.setVersion(Long.valueOf(2));
-        assertEquals(fieldDescriptorGlobalName, typeManager.getFieldDescriptor(id, null));
+        assertEquals(updatedFieldDescriptor, typeManager.getFieldDescriptor(fieldDescriptorCreate.getId(), null));
 
     }
@@ -129 +123 @@
     @Test
     public void testRetrieveOlderVersions() throws Exception {
-        String id = "testRetrieveOlderVersions";
+        String name = "testRetrieveOlderVersions";
         ValueType valueType = typeManager.getValueType("STRING", false, false);
-        FieldDescriptor fieldDescriptorCreate = typeManager.newFieldDescriptor(id, valueType , "aGlobalName");
-        typeManager.createFieldDescriptor(fieldDescriptorCreate);
-        FieldDescriptor fieldDescriptorGlobalName = typeManager.newFieldDescriptor(id, valueType , "newGlobalName");
-        typeManager.updateFieldDescriptor(fieldDescriptorGlobalName);
+        FieldDescriptor fieldDescriptorCreate = typeManager.newFieldDescriptor(valueType , name);
+        fieldDescriptorCreate = typeManager.createFieldDescriptor(fieldDescriptorCreate);
+        FieldDescriptor fieldDescriptorNewName = typeManager.newFieldDescriptor(fieldDescriptorCreate.getId(), valueType , "newName");
+        fieldDescriptorNewName = typeManager.updateFieldDescriptor(fieldDescriptorNewName);
         
-        fieldDescriptorGlobalName.setVersion(Long.valueOf(2));
-        assertEquals(fieldDescriptorGlobalName, typeManager.getFieldDescriptor(id, Long.valueOf(2)));
+        assertEquals(Long.valueOf(2), fieldDescriptorNewName.getVersion());
+        assertEquals(fieldDescriptorNewName, typeManager.getFieldDescriptor(fieldDescriptorCreate.getId(), Long.valueOf(2)));
 
-        fieldDescriptorCreate.setVersion(Long.valueOf(1));
-        assertEquals(fieldDescriptorCreate, typeManager.getFieldDescriptor(id, Long.valueOf(1)));
+        assertEquals(fieldDescriptorCreate, typeManager.getFieldDescriptor(fieldDescriptorCreate.getId(), Long.valueOf(1)));
     }
     
     @Test
     public void testRetrieveTooRecentVersionFails() throws Exception {
-        String id = "testRetrieveTooRecentVersionFails";
+        String name = "testRetrieveTooRecentVersionFails";
         ValueType valueType = typeManager.getValueType("STRING", false, false);
-        FieldDescriptor fieldDescriptorCreate = typeManager.newFieldDescriptor(id, valueType , "aGlobalName");
-        typeManager.createFieldDescriptor(fieldDescriptorCreate);
-        FieldDescriptor fieldDescriptorGlobalName = typeManager.newFieldDescriptor(id, valueType , "newGlobalName");
-        typeManager.updateFieldDescriptor(fieldDescriptorGlobalName);
+        FieldDescriptor fieldDescriptorCreate = typeManager.newFieldDescriptor(valueType , name);
+        fieldDescriptorCreate = typeManager.createFieldDescriptor(fieldDescriptorCreate);
+        FieldDescriptor fieldDescriptorNewName = typeManager.newFieldDescriptor(fieldDescriptorCreate.getId(), valueType , "newName");
+        typeManager.updateFieldDescriptor(fieldDescriptorNewName);
         
         try {
-            typeManager.getFieldDescriptor(id, Long.valueOf(3));
+            typeManager.getFieldDescriptor(fieldDescriptorCreate.getId(), Long.valueOf(3));
             fail("Retrieving a too recent/non-existing version should fail.");
         } catch (FieldDescriptorNotFoundException expected) {
@@ -162 +155 @@
     @Test
     public void testIdempotentUpdateReturnsLatestVersionNumber() throws Exception {
-        String id = "testIdempotentUpdateReturnsLatestVersionNumber";
+        String name = "testIdempotentUpdateReturnsLatestVersionNumber";
         ValueType valueType = typeManager.getValueType("STRING", false, false);
-        FieldDescriptor fieldDescriptorCreate = typeManager.newFieldDescriptor(id, valueType , "aGlobalName");
-        typeManager.createFieldDescriptor(fieldDescriptorCreate);
+        FieldDescriptor fieldDescriptorCreate = typeManager.newFieldDescriptor(valueType , name);
+        fieldDescriptorCreate = typeManager.createFieldDescriptor(fieldDescriptorCreate);
         
-        FieldDescriptor fieldDescriptorGlobalName = typeManager.newFieldDescriptor(id, valueType , "newGlobalName");
-        typeManager.updateFieldDescriptor(fieldDescriptorGlobalName);
+        FieldDescriptor fieldDescriptorNewName = typeManager.newFieldDescriptor(fieldDescriptorCreate.getId(), valueType , "newName");
+        typeManager.updateFieldDescriptor(fieldDescriptorNewName);
         
-        FieldDescriptor idempotentUpdate = typeManager.updateFieldDescriptor(fieldDescriptorGlobalName);
+        FieldDescriptor idempotentUpdate = typeManager.updateFieldDescriptor(fieldDescriptorNewName);
         assertEquals(Long.valueOf(2), idempotentUpdate.getVersion());
-        fieldDescriptorGlobalName.setVersion(Long.valueOf(2));
-        assertEquals(fieldDescriptorGlobalName, typeManager.getFieldDescriptor(id, null));
+        assertEquals(idempotentUpdate, typeManager.getFieldDescriptor(fieldDescriptorCreate.getId(), null));
     }
     
     @Test
     public void testUpdateValueTypeFails() throws Exception {
-        String id = "testUpdateValueTypeFails";
+        String name = "testUpdateValueTypeFails";
         ValueType valueType = typeManager.getValueType("STRING", false, false);
-        FieldDescriptor fieldDescriptor = typeManager.newFieldDescriptor(id, valueType , "aGlobalName");
-        typeManager.createFieldDescriptor(fieldDescriptor);
+        FieldDescriptor fieldDescriptor = typeManager.newFieldDescriptor(valueType , name);
+        fieldDescriptor = typeManager.createFieldDescriptor(fieldDescriptor);
         
         fieldDescriptor.setValueType(typeManager.getValueType("INTEGER", false, false));

projects/lily/trunk/repository/impl/src/test/java/org/lilycms/repository/impl/test/TypeManagerFieldGroupTest.java

@@ -20 +20 @@
 
 import java.util.Arrays;
+import java.util.UUID;
 
 import org.apache.hadoop.hbase.HBaseTestingUtility;
@@ -56 +57 @@
     
     private static void setupFieldDescriptors() throws Exception {
-        fieldDescriptor1 = typeManager.createFieldDescriptor(typeManager.newFieldDescriptor("FD1", typeManager.getValueType("STRING", false, false), "GN1"));
-        fieldDescriptor2 = typeManager.createFieldDescriptor(typeManager.newFieldDescriptor("FD2", typeManager.getValueType("STRING", false, false), "GN2"));
-        fieldDescriptor3 = typeManager.createFieldDescriptor(typeManager.newFieldDescriptor("FD3", typeManager.getValueType("STRING", false, false), "GN3"));
-        fieldDescriptor3B = typeManager.updateFieldDescriptor(typeManager.newFieldDescriptor("FD3", typeManager.getValueType("STRING", false, false), "GN3B"));
+        fieldDescriptor1 = typeManager.createFieldDescriptor(typeManager.newFieldDescriptor(typeManager.getValueType("STRING", false, false), "name1"));
+        fieldDescriptor2 = typeManager.createFieldDescriptor(typeManager.newFieldDescriptor(typeManager.getValueType("STRING", false, false), "name2"));
+        fieldDescriptor3 = typeManager.createFieldDescriptor(typeManager.newFieldDescriptor(typeManager.getValueType("STRING", false, false), "name3"));
+        fieldDescriptor3B = typeManager.updateFieldDescriptor(typeManager.newFieldDescriptor(fieldDescriptor3.getId(), typeManager.getValueType("STRING", false, false), "name3B"));
     }
 
@@ -122 +123 @@
         FieldGroup actualFieldGroup = typeManager.getFieldGroup(id, null);
         assertEquals(fieldGroup, actualFieldGroup);
-        assertEquals(Long.valueOf(1), actualFieldGroup.getFieldGroupEntry("FD3").getFieldDescriptorVersion());
+        assertEquals(Long.valueOf(1), actualFieldGroup.getFieldGroupEntry(fieldDescriptor3.getId()).getFieldDescriptorVersion());
     }
     
@@ -197 +198 @@
         String id = "testFieldDescriptorExistsOnCreate";
         FieldGroup fieldGroup = typeManager.newFieldGroup(id);
-        FieldGroupEntry fieldGroupEntry = typeManager.newFieldGroupEntry("nonExistingFD", null, false, "alias1");
+        FieldGroupEntry fieldGroupEntry = typeManager.newFieldGroupEntry(UUID.randomUUID().toString(), null, false, "alias1");
         fieldGroup.setFieldGroupEntry(fieldGroupEntry);
         try {
@@ -224 +225 @@
         FieldGroup fieldGroup = typeManager.newFieldGroup(id);
         typeManager.createFieldGroup(fieldGroup);
-        FieldGroupEntry fieldGroupEntry = typeManager.newFieldGroupEntry("nonExistingFD", null, false, "alias1");
+        FieldGroupEntry fieldGroupEntry = typeManager.newFieldGroupEntry(UUID.randomUUID().toString(), null, false, "alias1");
         fieldGroup.setFieldGroupEntry(fieldGroupEntry);
         try {
@@ -254 +255 @@
         fieldGroup.setFieldGroupEntry(fieldGroupEntry);
         FieldGroup createdFieldgroup = typeManager.createFieldGroup(fieldGroup);
-        assertEquals(fieldDescriptor1.getVersion(), createdFieldgroup.getFieldGroupEntry("FD1").getFieldDescriptorVersion());
+        assertEquals(fieldDescriptor1.getVersion(), createdFieldgroup.getFieldGroupEntry(fieldDescriptor1.getId()).getFieldDescriptorVersion());
         
         fieldGroupEntry = typeManager.newFieldGroupEntry(fieldDescriptor2.getId(), null, false, "alias2");
         fieldGroup.setFieldGroupEntry(fieldGroupEntry);
         FieldGroup updatedFieldgroup = typeManager.updateFieldGroup(fieldGroup);
-        assertEquals(fieldDescriptor2.getVersion(), updatedFieldgroup.getFieldGroupEntry("FD2").getFieldDescriptorVersion());
+        assertEquals(fieldDescriptor2.getVersion(), updatedFieldgroup.getFieldGroupEntry(fieldDescriptor2.getId()).getFieldDescriptorVersion());
         
         fieldGroupEntry = typeManager.newFieldGroupEntry(fieldDescriptor3.getId(), null, false, "alias3");
         fieldGroup.setFieldGroupEntry(fieldGroupEntry);
         updatedFieldgroup = typeManager.updateFieldGroup(fieldGroup);
-        assertEquals(fieldDescriptor3B.getVersion(), updatedFieldgroup.getFieldGroupEntry("FD3").getFieldDescriptorVersion());
+        assertEquals(fieldDescriptor3B.getVersion(), updatedFieldgroup.getFieldGroupEntry(fieldDescriptor3.getId()).getFieldDescriptorVersion());
     }
     

projects/lily/trunk/repository/impl/src/test/java/org/lilycms/repository/impl/test/TypeManagerRecordTypeTest.java

@@ -19 +19 @@
 import static junit.framework.Assert.*;
 
-import org.apache.commons.lang.NotImplementedException;
+import java.util.Map;
+
 import org.apache.hadoop.hbase.HBaseTestingUtility;
 import org.junit.After;
@@ -425 +426 @@
     }
     
+    @Test
+    public void testMixin() throws Exception {
+        String id = "testMixin";
+        RecordType mixinType = typeManager.newRecordType(id+"MIX");
+        mixinType.setFieldGroupId(Scope.NON_VERSIONABLE,fieldGroup1.getId());
+        mixinType.setFieldGroupVersion(Scope.NON_VERSIONABLE,fieldGroup1.getVersion());
+        mixinType.setFieldGroupId(Scope.VERSIONABLE,fieldGroup2.getId());
+        mixinType.setFieldGroupVersion(Scope.VERSIONABLE,fieldGroup2.getVersion());
+        mixinType.setFieldGroupId(Scope.VERSIONABLE_MUTABLE,fieldGroup3.getId());
+        mixinType.setFieldGroupVersion(Scope.VERSIONABLE_MUTABLE,fieldGroup3.getVersion());
+        mixinType = typeManager.createRecordType(mixinType);
+        
+        RecordType recordType = typeManager.newRecordType(id+"RT");
+        recordType.addMixin(mixinType.getId(), mixinType.getVersion());
+        assertEquals(Long.valueOf(1), typeManager.createRecordType(recordType).getVersion());
+        recordType.setVersion(Long.valueOf(1));
+        assertEquals(recordType, typeManager.getRecordType(recordType.getId(), null));
+    }
+    
+    @Test
+    public void testMixinUpdate() throws Exception {
+        String id = "testMixinUpdate";
+        RecordType mixinType1 = typeManager.newRecordType(id+"MIX");
+        mixinType1.setFieldGroupId(Scope.NON_VERSIONABLE,fieldGroup1.getId());
+        mixinType1.setFieldGroupVersion(Scope.NON_VERSIONABLE,fieldGroup1.getVersion());
+        mixinType1.setFieldGroupId(Scope.VERSIONABLE,fieldGroup2.getId());
+        mixinType1.setFieldGroupVersion(Scope.VERSIONABLE,fieldGroup2.getVersion());
+        mixinType1.setFieldGroupId(Scope.VERSIONABLE_MUTABLE,fieldGroup3.getId());
+        mixinType1.setFieldGroupVersion(Scope.VERSIONABLE_MUTABLE,fieldGroup3.getVersion());
+        mixinType1 = typeManager.createRecordType(mixinType1);
+        RecordType mixinType2 = typeManager.newRecordType(id+"MIX2");
+        mixinType2.setFieldGroupId(Scope.NON_VERSIONABLE,fieldGroup1.getId());
+        mixinType2.setFieldGroupVersion(Scope.NON_VERSIONABLE,fieldGroup1.getVersion());
+        mixinType2.setFieldGroupId(Scope.VERSIONABLE,fieldGroup2.getId());
+        mixinType2.setFieldGroupVersion(Scope.VERSIONABLE,fieldGroup2.getVersion());
+        mixinType2.setFieldGroupId(Scope.VERSIONABLE_MUTABLE,fieldGroup3.getId());
+        mixinType2.setFieldGroupVersion(Scope.VERSIONABLE_MUTABLE,fieldGroup3.getVersion());
+        mixinType2 = typeManager.createRecordType(mixinType2);
+        
+        RecordType recordType = typeManager.newRecordType(id+"RT");
+        recordType.addMixin(mixinType1.getId(), mixinType1.getVersion());
+        typeManager.createRecordType(recordType);
+        
+        recordType.addMixin(mixinType2.getId(), mixinType2.getVersion());
+        assertEquals(Long.valueOf(2), typeManager.updateRecordType(recordType).getVersion());
+        recordType.setVersion(Long.valueOf(2));
+        assertEquals(recordType, typeManager.getRecordType(recordType.getId(), null));
+    }
+    
+    @Test
+    public void testMixinRemove() throws Exception {
+        String id = "testMixinRemove";
+        RecordType mixinType1 = typeManager.newRecordType(id+"MIX");
+        mixinType1.setFieldGroupId(Scope.NON_VERSIONABLE,fieldGroup1.getId());
+        mixinType1.setFieldGroupVersion(Scope.NON_VERSIONABLE,fieldGroup1.getVersion());
+        mixinType1.setFieldGroupId(Scope.VERSIONABLE,fieldGroup2.getId());
+        mixinType1.setFieldGroupVersion(Scope.VERSIONABLE,fieldGroup2.getVersion());
+        mixinType1.setFieldGroupId(Scope.VERSIONABLE_MUTABLE,fieldGroup3.getId());
+        mixinType1.setFieldGroupVersion(Scope.VERSIONABLE_MUTABLE,fieldGroup3.getVersion());
+        mixinType1 = typeManager.createRecordType(mixinType1);
+        RecordType mixinType2 = typeManager.newRecordType(id+"MIX2");
+        mixinType2.setFieldGroupId(Scope.NON_VERSIONABLE,fieldGroup1.getId());
+        mixinType2.setFieldGroupVersion(Scope.NON_VERSIONABLE,fieldGroup1.getVersion());
+        mixinType2.setFieldGroupId(Scope.VERSIONABLE,fieldGroup2.getId());
+        mixinType2.setFieldGroupVersion(Scope.VERSIONABLE,fieldGroup2.getVersion());
+        mixinType2.setFieldGroupId(Scope.VERSIONABLE_MUTABLE,fieldGroup3.getId());
+        mixinType2.setFieldGroupVersion(Scope.VERSIONABLE_MUTABLE,fieldGroup3.getVersion());
+        mixinType2 = typeManager.createRecordType(mixinType2);
+        
+        RecordType recordType = typeManager.newRecordType(id+"RT");
+        recordType.addMixin(mixinType1.getId(), mixinType1.getVersion());
+        typeManager.createRecordType(recordType);
+        
+        recordType.addMixin(mixinType2.getId(), mixinType2.getVersion());
+        recordType.removeMixin(mixinType1.getId());
+        assertEquals(Long.valueOf(2), typeManager.updateRecordType(recordType).getVersion());
+        RecordType readRecordType = typeManager.getRecordType(recordType.getId(), null);
+        Map<String, Long> mixins = readRecordType.getMixins();
+        assertEquals(1, mixins.size());
+        assertEquals(Long.valueOf(1), mixins.get(mixinType2.getId()));
+    }
+    
 //    @Test
 //    public void testCreateWithDuplicateFieldGroupFails() throws Exception {

projects/lily/trunk/repository/impl/src/test/java/org/lilycms/repository/impl/test/ValueTypeTest.java

@@ -120 +120 @@
     private void testType(String recordTypeId, String valueTypeString, boolean multivalue, boolean hierarchical,
                     Object fieldValue) throws Exception {
-        String fieldDescriptorId = valueTypeString+"FieldId"+multivalue+hierarchical;
-        FieldDescriptor fieldDescriptor = typeManager.createFieldDescriptor(typeManager.newFieldDescriptor(fieldDescriptorId, typeManager.getValueType(
-                        valueTypeString, multivalue, hierarchical), "aGlobalName"));
+        String name = valueTypeString+"FieldId"+multivalue+hierarchical;
+        FieldDescriptor fieldDescriptor = typeManager.createFieldDescriptor(typeManager.newFieldDescriptor(typeManager.getValueType(
+                        valueTypeString, multivalue, hierarchical), name));
         String fieldGroupId = valueTypeString+"FieldGroupId"+multivalue+hierarchical;
         FieldGroup fieldGroup = typeManager.newFieldGroup(fieldGroupId);
@@ -134 +134 @@
         Record record = repository.newRecord(idGenerator.newRecordId());
         record.setRecordType(recordType.getId(), recordType.getVersion());
-        record.setField(Scope.NON_VERSIONABLE, fieldDescriptorId, fieldValue);
+        record.setField(Scope.NON_VERSIONABLE, fieldDescriptor.getName(), fieldValue);
         repository.create(record);
 
         Record actualRecord = repository.read(record.getId());
-        assertEquals(fieldValue, actualRecord.getField(Scope.NON_VERSIONABLE, fieldDescriptorId));
+        assertEquals(fieldValue, actualRecord.getField(Scope.NON_VERSIONABLE, fieldDescriptor.getName()));
     }