Set data type (#7442)

Author: edualonso

CHANGELOG.md

@@ -12,6 +12,7 @@
 * Added support for `java.util.UUID` as a primary key.
 * Added support for `RealmAny` as supported field in model classes. A `RealmAny` is used to represent a polymorphic Realm value or Realm Object, is indexable but cannot be used as a primary key. See [Javadoc for RealmAny](https://docs.mongodb.com/realm-sdks/java/latest/io/realm/RealmAny.html).
 * Added support for `RealmDictionary` as supported field in model classes. A `RealmDictionary` is a `Map` of strings to values - all types under the `RealmAny` umbrella can be used as values. See [Javadoc for RealmDictionary](https://docs.mongodb.com/realm-sdks/java/latest/io/realm/RealmDictionary.html) and [Javadoc for RealmMap](https://docs.mongodb.com/realm-sdks/java/latest/io/realm/RealmMap.html). `RealmDictionary` is not yet supported by any of the `Realm.insert` and `Realm.createFromJson` methods - This support will be added in a future release.
+* Added support for `RealmSet` as supported field in model classes. A `RealmSet` is a collection that implements the Java `Set` interface and contains no duplicate values - all types under the `RealmAny` umbrella can be used as values. See [Javadoc for RealmSet](https://docs.mongodb.com/realm-sdks/java/latest/io/realm/RealmSet.html). `RealmSet` is not yet supported by any of the `Realm.insert` and `Realm.createFromJson` methods - This support will be added in a future release.
 * Allow UTF8 encoded characters in property names in string-based queries ([#4467](https://github.com/realm/realm-core/issues/4467))
 * The error message when the initial steps of opening a Realm file fails is now more descriptive.
 * Make conversion of Decimal128 to/from string work for numbers with more than 19 significant digits. ([#4548](https://github.com/realm/realm-core/issues/4548))

dependencies.list

@@ -4,7 +4,7 @@ REALM_CORE=10.3.3
 
 # Version of MongoDB Realm used by integration tests
 # See https://github.com/realm/ci/packages/147854 for available versions
-MONGODB_REALM_SERVER=2021-04-19
+MONGODB_REALM_SERVER=2021-04-22
 
 # Common Android settings across projects
 GRADLE_BUILD_TOOLS=4.0.0

realm/realm-annotations-processor/src/main/java/io/realm/processor/ClassMetaData.kt

@@ -41,6 +41,8 @@ class ClassMetaData(env: ProcessingEnvironment, typeMirrors: TypeMirrors, privat
     private val nullableFields = LinkedHashSet<RealmFieldElement>() // Set of fields which can be nullable
     private val nullableValueListFields = LinkedHashSet<RealmFieldElement>() // Set of fields whose elements can be nullable
     private val nullableValueMapFields = LinkedHashSet<RealmFieldElement>() // Set of fields whose elements can be nullable
+    private val nullableValueSetFields = LinkedHashSet<RealmFieldElement>() // Set of fields whose elements can be nullable
+    private val realmModelSets = LinkedHashSet<RealmFieldElement>()
 
     // package name for model class.
     private lateinit var packageName: String
@@ -85,10 +87,25 @@ class ClassMetaData(env: ProcessingEnvironment, typeMirrors: TypeMirrors, privat
             typeMirrors.UUID_MIRROR,
             typeMirrors.MIXED_MIRROR
     )
-    private val validDictionaryTypes: List<TypeMirror>  = listOf(
+    private val validDictionaryTypes: List<TypeMirror> = listOf(
+            typeMirrors.STRING_MIRROR,
+            typeMirrors.BINARY_MIRROR,
+            typeMirrors.BOOLEAN_MIRROR,
+            typeMirrors.LONG_MIRROR,
+            typeMirrors.INTEGER_MIRROR,
+            typeMirrors.SHORT_MIRROR,
+            typeMirrors.BYTE_MIRROR,
+            typeMirrors.DOUBLE_MIRROR,
+            typeMirrors.FLOAT_MIRROR,
+            typeMirrors.DATE_MIRROR,
+            typeMirrors.DECIMAL128_MIRROR,
+            typeMirrors.OBJECT_ID_MIRROR,
+            typeMirrors.UUID_MIRROR,
+            typeMirrors.MIXED_MIRROR
+    )
+    private val validSetTypes: List<TypeMirror>  = listOf(
             typeMirrors.STRING_MIRROR,
             typeMirrors.BINARY_MIRROR,
-            typeMirrors.BINARY_NON_PRIMITIVE_MIRROR,
             typeMirrors.BOOLEAN_MIRROR,
             typeMirrors.LONG_MIRROR,
             typeMirrors.INTEGER_MIRROR,
@@ -119,6 +136,9 @@ class ClassMetaData(env: ProcessingEnvironment, typeMirrors: TypeMirrors, privat
     val primaryKeyGetter: String
         get() = getInternalGetter(primaryKey!!.simpleName.toString())
 
+    val realmModelSetFields: Set<RealmFieldElement>
+        get() = realmModelSets.toSet()
+
     /**
      * Returns `true if the class is considered to be a valid RealmObject class.
      * RealmObject and Proxy classes also have the @RealmClass annotation but are not considered valid
@@ -232,6 +252,15 @@ class ClassMetaData(env: ProcessingEnvironment, typeMirrors: TypeMirrors, privat
         return nullableValueMapFields.contains(realmDictionaryVariableElement)
     }
 
+    /**
+     * Checks if the value of a `RealmDictionary` entry designated by `realmDictionaryVariableElement` is nullable.
+     *
+     * @return `true` if the element is nullable type, `false` otherwise.
+     */
+    fun isSetValueNullable(realmSetVariableElement: VariableElement): Boolean {
+        return nullableValueSetFields.contains(realmSetVariableElement)
+    }
+
     /**
      * Checks if a VariableElement is indexed.
      *
@@ -333,6 +362,9 @@ class ClassMetaData(env: ProcessingEnvironment, typeMirrors: TypeMirrors, privat
         if (!checkDictionaryTypes()) {
             return false
         }
+        if (!checkSetTypes()) {
+            return false
+        }
         if (!checkReferenceTypes()) {
             return false
         }
@@ -403,6 +435,34 @@ class ClassMetaData(env: ProcessingEnvironment, typeMirrors: TypeMirrors, privat
         return true
     }
 
+    private fun checkSetTypes(): Boolean {
+        for (field in fields) {
+            if (Utils.isRealmSet(field)) {
+                if (!checkSetValuesType(field)) {
+                    return false
+                }
+            }
+        }
+
+        return true
+    }
+
+    private fun checkSetValuesType(field: VariableElement): Boolean {
+        // Check for missing generic (default back to Object)
+        if (Utils.getGenericTypeQualifiedName(field) == null) {
+            Utils.error(getFieldErrorSuffix(field) + "No generic type supplied for field", field)
+            return false
+        }
+
+        val elementTypeMirror = checkReferenceIsNotInterface(field) ?: return false
+        return checkAcceptableClass(
+                field,
+                elementTypeMirror,
+                validSetTypes,
+                "Element type RealmSet must be of type 'RealmAny' or any type that can be boxed inside 'RealmAny': "
+        )
+    }
+
     private fun checkDictionaryValuesType(field: VariableElement): Boolean {
         // Check for missing generic (default back to Object)
         if (Utils.getGenericTypeQualifiedName(field) == null) {
@@ -415,7 +475,7 @@ class ClassMetaData(env: ProcessingEnvironment, typeMirrors: TypeMirrors, privat
                 field,
                 elementTypeMirror,
                 validDictionaryTypes,
-                "Element type of RealmDictionary must be of type 'RealmAny' or any type that can be boxed inside 'RealmAny': "
+                "Element type RealmDictionary must be of type 'RealmAny' or any type that can be boxed inside 'RealmAny': "
         )
     }
 
@@ -541,8 +601,10 @@ class ClassMetaData(env: ProcessingEnvironment, typeMirrors: TypeMirrors, privat
             if (!field.modifiers.contains(Modifier.FINAL)) {
                 continue
             }
-            if (Utils.isRealmList(field) || Utils.isMutableRealmInteger(field) ||
-                    Utils.isRealmDictionary(field)) {
+            if (Utils.isRealmList(field) ||
+                    Utils.isMutableRealmInteger(field) ||
+                    Utils.isRealmDictionary(field) ||
+                    Utils.isRealmSet(field)) {
                 continue
             }
 
@@ -617,7 +679,7 @@ class ClassMetaData(env: ProcessingEnvironment, typeMirrors: TypeMirrors, privat
             val containsRealmModelClasses = (listGenericType.isNotEmpty() && Utils.isRealmModel(listGenericType[0]))
             val containsRealmAny = (listGenericType.isNotEmpty() && Utils.isRealmAny(listGenericType[0]))
 
-            // @Required not allowed if the dictionary contains Realm model classes
+            // @Required not allowed if the dictionary contains Realm model classes or RealmAny
             if (hasRequiredAnnotation && (containsRealmModelClasses || containsRealmAny)) {
                 Utils.error("@Required not allowed on RealmDictionaries that contain other Realm model classes and RealmAny.")
                 return false
@@ -630,6 +692,30 @@ class ClassMetaData(env: ProcessingEnvironment, typeMirrors: TypeMirrors, privat
                     nullableValueMapFields.add(field)
                 }
             }
+        } else if (Utils.isRealmSet(field)) {
+            // Same as RealmList
+            val hasRequiredAnnotation = hasRequiredAnnotation(field)
+            val setGenericType = (field.asType() as DeclaredType).typeArguments
+            val containsRealmModelClasses = (setGenericType.isNotEmpty() && Utils.isRealmModel(setGenericType[0]))
+            val containsRealmAny = (setGenericType.isNotEmpty() && Utils.isRealmAny(setGenericType[0]))
+
+            // @Required not allowed if the set contains Realm model classes or RealmAny
+            if (hasRequiredAnnotation && (containsRealmModelClasses || containsRealmAny)) {
+                Utils.error("@Required not allowed on RealmSets that contain other Realm model classes and RealmAny.")
+                return false
+            }
+
+            // @Required thus only makes sense for RealmSets with primitive types
+            // We only check @Required annotation. @org.jetbrains.annotations.NotNull annotation should not affect nullability of the list values.
+            if (!hasRequiredAnnotation) {
+                if (!containsRealmModelClasses) {
+                    nullableValueSetFields.add(field)
+                }
+            }
+
+            if (containsRealmModelClasses) {
+                realmModelSets.add(field)
+            }
         } else if (isRequiredField(field)) {
             if (!checkBasicRequiredAnnotationUsage(field)) {
                 return false
@@ -670,7 +756,9 @@ class ClassMetaData(env: ProcessingEnvironment, typeMirrors: TypeMirrors, privat
                 Utils.isRealmAnyList(field) ||
                 Utils.isRealmAny(field) ||
                 Utils.isRealmModelDictionary(field) ||
-                Utils.isRealmAnyDictionary(field)) {
+                Utils.isRealmModelSet(field) ||
+                Utils.isRealmAnyDictionary(field)||
+                Utils.isRealmAnySet(field)) {
             _objectReferenceFields.add(field)
         } else {
             basicTypeFields.add(field)

realm/realm-annotations-processor/src/main/java/io/realm/processor/Constants.kt

@@ -87,6 +87,23 @@ object Constants {
             "io.realm.RealmAny" to RealmFieldType.STRING_TO_MIXED_MAP
     )
 
+    val SET_ELEMENT_TYPE_TO_REALM_TYPES = mapOf(
+            "java.lang.Byte" to RealmFieldType.INTEGER_SET,
+            "java.lang.Short" to RealmFieldType.INTEGER_SET,
+            "java.lang.Integer" to RealmFieldType.INTEGER_SET,
+            "java.lang.Long" to RealmFieldType.INTEGER_SET,
+            "java.lang.Float" to RealmFieldType.FLOAT_SET,
+            "java.lang.Double" to RealmFieldType.DOUBLE_SET,
+            "java.lang.Boolean" to RealmFieldType.BOOLEAN_SET,
+            "java.lang.String" to RealmFieldType.STRING_SET,
+            "java.util.Date" to RealmFieldType.DATE_SET,
+            "byte[]" to RealmFieldType.BINARY_SET,
+            "org.bson.types.Decimal128" to RealmFieldType.DECIMAL128_SET,
+            "org.bson.types.ObjectId" to RealmFieldType.OBJECT_ID_SET,
+            "java.util.UUID" to RealmFieldType.UUID_SET,
+            "io.realm.RealmAny" to RealmFieldType.MIXED_SET
+    )
+
     /**
      * Realm types and their corresponding Java types.
      *
@@ -135,8 +152,20 @@ object Constants {
         STRING_TO_DECIMAL128_MAP("STRING_TO_DECIMAL128_MAP", "Map"),
         STRING_TO_OBJECT_ID_MAP("STRING_TO_OBJECT_ID_MAP", "Map"),
         STRING_TO_UUID_MAP("STRING_TO_UUID_MAP", "Map"),
-        STRING_TO_MIXED_MAP("STRING_TO_MIXED_MAP", "Map");
+        STRING_TO_MIXED_MAP("STRING_TO_MIXED_MAP", "Map"),
 
+        INTEGER_SET("INTEGER_SET", "Set"),
+        BOOLEAN_SET("BOOLEAN_SET", "Set"),
+        STRING_SET("STRING_SET", "Set"),
+        BINARY_SET("BINARY_SET", "Set"),
+        DATE_SET("DATE_SET", "Set"),
+        FLOAT_SET("FLOAT_SET", "Set"),
+        DOUBLE_SET("DOUBLE_SET", "Set"),
+        DECIMAL128_SET("DECIMAL128_SET", "Set"),
+        OBJECT_ID_SET("OBJECT_ID_SET", "Set"),
+        UUID_SET("UUID_SET", "Set"),
+        LINK_SET("LINK_SET", "Set"),
+        MIXED_SET("MIXED_SET", "Set");
 
         /**
          * The name of the enum, used in the Java bindings, used to represent the corresponding type.

realm/realm-annotations-processor/src/main/java/io/realm/processor/OsObjectBuilderTypeHelper.kt

@@ -42,6 +42,23 @@ object OsObjectBuilderTypeHelper {
             QualifiedClassName("java.util.UUID") to "UUIDValueDictionary"
     )
 
+    private val QUALIFIED_SET_VALUES: Map<QualifiedClassName, String> = mapOf(
+            QualifiedClassName("io.realm.RealmAny") to "RealmAnySet",
+            QualifiedClassName("java.lang.Boolean") to "BooleanSet",
+            QualifiedClassName("java.lang.String") to "StringSet",
+            QualifiedClassName("java.lang.Integer") to "IntegerSet",
+            QualifiedClassName("java.lang.Float") to "FloatSet",
+            QualifiedClassName("java.lang.Long") to "LongSet",
+            QualifiedClassName("java.lang.Short") to "ShortSet",
+            QualifiedClassName("java.lang.Byte") to "ByteSet",
+            QualifiedClassName("java.lang.Double") to "DoubleSet",
+            QualifiedClassName("java.util.Date") to "DateSet",
+            QualifiedClassName("byte[]") to "BinarySet",
+            QualifiedClassName("org.bson.types.ObjectId") to "ObjectIdSet",
+            QualifiedClassName("org.bson.types.Decimal128") to "Decimal128Set",
+            QualifiedClassName("java.util.UUID") to "UUIDSet"
+    )
+
     init {
         // Map of qualified types to their OsObjectBuilder Type
         val fieldTypes = HashMap<QualifiedClassName, String>()
@@ -107,6 +124,8 @@ object OsObjectBuilderTypeHelper {
             "add" + getListTypeName(Utils.getRealmListType(field))
         } else if (Utils.isRealmDictionary(field)) {
             "add" + getDictionaryValueTypeName(Utils.getDictionaryType(field))
+        } else if (Utils.isRealmSet(field)) {
+            "add" + getSetValueTypeName(Utils.getSetType(field))
         } else if (Utils.isRealmResults(field)) {
             throw IllegalStateException("RealmResults are not supported by OsObjectBuilder: $field")
         } else {
@@ -135,4 +154,10 @@ object OsObjectBuilderTypeHelper {
             "Unsupported dictionary value type: '$typeName'"
         }
     }
+
+    private fun getSetValueTypeName(typeName: QualifiedClassName?): String {
+        return requireNotNull(QUALIFIED_SET_VALUES[typeName]) {
+            "Unsupported set value type: '$typeName'"
+        }
+    }
 }

realm/realm-annotations-processor/src/main/java/io/realm/processor/RealmProcessor.kt

@@ -16,20 +16,19 @@
 
 package io.realm.processor
 
+import io.realm.annotations.RealmClass
+import io.realm.annotations.RealmModule
 import java.io.IOException
-import java.util.HashSet
-
+import java.util.*
 import javax.annotation.processing.AbstractProcessor
 import javax.annotation.processing.RoundEnvironment
 import javax.annotation.processing.SupportedAnnotationTypes
 import javax.annotation.processing.SupportedOptions
 import javax.lang.model.SourceVersion
 import javax.lang.model.element.ElementKind
-import javax.lang.model.element.TypeElement
-
-import io.realm.annotations.RealmClass
-import io.realm.annotations.RealmModule
 import javax.lang.model.element.Name
+import javax.lang.model.element.TypeElement
+import javax.lang.model.type.DeclaredType
 import javax.lang.model.type.TypeMirror
 
 
@@ -152,6 +151,9 @@ class RealmProcessor : AbstractProcessor() {
     // List of backlinks
     private val backlinksToValidate = HashSet<Backlink>()
 
+    // List of realm model sets
+    private val realmModelSetsToValidate = HashSet<RealmFieldElement>()
+
     private var hasProcessedModules = false
     private var round = -1
 
@@ -187,6 +189,9 @@ class RealmProcessor : AbstractProcessor() {
             if (!validateBacklinks()) {
                 return ABORT
             }
+            if (!validateRealmModelSets()) {
+                return ABORT
+            }
             hasProcessedModules = true
 
             // Create all files
@@ -230,6 +235,7 @@ class RealmProcessor : AbstractProcessor() {
 
             classCollection.addClass(metadata)
             backlinksToValidate.addAll(metadata.backlinkFields)
+            realmModelSetsToValidate.addAll(metadata.realmModelSetFields)
         }
 
         return true
@@ -338,4 +344,26 @@ class RealmProcessor : AbstractProcessor() {
 
         return allValid
     }
+
+    // Because library classes are processed separately, there is no guarantee that this method can
+    // see all of the classes necessary to completely validate all of the realm model sets.  If it can find
+    // the fully-qualified class, though, and prove that the generic type is an embedded object,
+    // it can catch the error at compile time. Otherwise it is caught at runtime, when validating the
+    // schema.
+    private fun validateRealmModelSets(): Boolean {
+        var allValid = true
+
+        for (field in realmModelSetsToValidate) {
+            val genericClassName = (field.asType() as DeclaredType).typeArguments.toString()
+            val genericType = processingEnv.elementUtils.getTypeElement(genericClassName).asType()
+
+            val embedded = Utils.isFieldTypeEmbedded(genericType, classCollection)
+            if(embedded && allValid){
+                Utils.error("RealmSets field ${field.javaName} at ${field.fieldReference} do not support embedded objects.")
+                allValid = false
+            }
+        }
+
+        return allValid
+    }
 }