DOPE-281: refactor Bucket and related classes to introduce Definable interface for improved bucket definition handling

jansigi · jansigi · commit 70e8dd2e07b5 · 2026-02-20T15:39:01.000+01:00
diff --git a/core/src/main/kotlin/ch/ergon/dope/resolvable/bucket/Bucket.kt b/core/src/main/kotlin/ch/ergon/dope/resolvable/bucket/Bucket.kt
@@ -9,14 +9,20 @@ import ch.ergon.dope.resolvable.Updatable
 import ch.ergon.dope.resolvable.expression.SingleExpression
 import ch.ergon.dope.validtype.ObjectType
 
-sealed interface Bucket : Fromable, Joinable, Nestable, Deletable, Updatable, SingleExpression<ObjectType> {
+interface Bucket : Fromable, Joinable, Nestable, Deletable, Updatable, SingleExpression<ObjectType> {
     val name: String
     val scope: BucketScope?
 }
 
+interface Definable : Bucket {
+    val alias: String
+
+    fun asBucketDefinition(): AliasedBucketDefinition = AliasedBucketDefinition(name, alias, scope)
+}
+
 data class BucketScope(val name: String, val collection: ScopeCollection? = null) {
-    fun withCollection(collectionName: String) = copy(collection = ScopeCollection(collectionName))
 
+    fun withCollection(collectionName: String) = copy(collection = ScopeCollection(collectionName))
     fun withCollection(collection: ScopeCollection) = copy(collection = collection)
 }
 
@@ -38,21 +44,12 @@ data class UnaliasedBucket(
 
 data class AliasedBucket(
     override val name: String,
-    val alias: String,
+    override val alias: String,
     override val scope: BucketScope? = null,
-) : Bucket {
-    fun asBucketDefinition(): AliasedBucketDefinition =
-        AliasedBucketDefinition(
-            bucketName = name,
-            scopeName = scope?.name,
-            collectionName = scope?.collection?.name,
-            alias = alias,
-        )
-}
+) : Definable
 
 data class AliasedBucketDefinition(
     val bucketName: String,
-    val scopeName: String? = null,
-    val collectionName: String? = null,
     val alias: String,
+    val scope: BucketScope? = null,
 ) : Resolvable
diff --git a/core/src/main/kotlin/ch/ergon/dope/resolvable/keyspace/Keyspace.kt b/core/src/main/kotlin/ch/ergon/dope/resolvable/keyspace/Keyspace.kt
diff --git a/couchbase/src/main/kotlin/ch/ergon/dope/couchbase/resolvable/keyspace/SystemKeyspaces.kt b/couchbase/src/main/kotlin/ch/ergon/dope/couchbase/resolvable/keyspace/SystemKeyspaces.kt
diff --git a/couchbase/src/main/kotlin/ch/ergon/dope/couchbase/resolver/KeySpaceResolver.kt b/couchbase/src/main/kotlin/ch/ergon/dope/couchbase/resolver/KeySpaceResolver.kt
@@ -5,25 +5,22 @@ import ch.ergon.dope.couchbase.resolver.expression.queryString
 import ch.ergon.dope.couchbase.util.formatBucket
 import ch.ergon.dope.couchbase.util.formatListToQueryStringWithBrackets
 import ch.ergon.dope.couchbase.util.formatToQueryStringWithSymbol
-import ch.ergon.dope.resolvable.bucket.AliasedBucket
 import ch.ergon.dope.resolvable.bucket.AliasedBucketDefinition
+import ch.ergon.dope.resolvable.bucket.Definable
 import ch.ergon.dope.resolvable.bucket.IndexReference
+import ch.ergon.dope.resolvable.bucket.UnaliasedBucket
 import ch.ergon.dope.resolvable.bucket.UseIndex
 import ch.ergon.dope.resolvable.bucket.UseKeysClass
 
 interface KeySpaceResolver : AbstractCouchbaseResolver {
     fun resolve(aliasedBucket: AliasedBucketDefinition): CouchbaseDopeQuery =
         CouchbaseDopeQuery(
-            formatBucket(
-                aliasedBucket.bucketName,
-                aliasedBucket.scopeName,
-                aliasedBucket.collectionName,
-            ) + " AS `${aliasedBucket.alias}`",
+            formatBucket(UnaliasedBucket(aliasedBucket.bucketName, aliasedBucket.scope)) + " AS `${aliasedBucket.alias}`",
         )
 
     fun resolve(useKeysClass: UseKeysClass): CouchbaseDopeQuery {
         val bucket = when (val bucket = useKeysClass.bucket) {
-            is AliasedBucket -> bucket.asBucketDefinition().toDopeQuery(this)
+            is Definable -> bucket.asBucketDefinition().toDopeQuery(this)
             else -> useKeysClass.bucket.toDopeQuery(this)
         }
         val keys = useKeysClass.useKeys.toDopeQuery(this)
@@ -42,7 +39,7 @@ interface KeySpaceResolver : AbstractCouchbaseResolver {
     fun resolve(useIndex: UseIndex): CouchbaseDopeQuery {
         val bucket = useIndex.bucket
         val bucketDopeQuery = when (bucket) {
-            is AliasedBucket -> bucket.asBucketDefinition().toDopeQuery(this)
+            is Definable -> bucket.asBucketDefinition().toDopeQuery(this)
             else -> bucket.toDopeQuery(this)
         }
         val refs = useIndex.indexReferences.map { it.toDopeQuery(this) }
diff --git a/couchbase/src/main/kotlin/ch/ergon/dope/couchbase/resolver/clause/ClauseResolver.kt b/couchbase/src/main/kotlin/ch/ergon/dope/couchbase/resolver/clause/ClauseResolver.kt
@@ -7,7 +7,7 @@ import ch.ergon.dope.couchbase.util.formatToQueryString
 import ch.ergon.dope.couchbase.util.formatToQueryStringWithSymbol
 import ch.ergon.dope.merge
 import ch.ergon.dope.resolvable.AliasedSelectClause
-import ch.ergon.dope.resolvable.bucket.AliasedBucket
+import ch.ergon.dope.resolvable.bucket.Definable
 import ch.ergon.dope.resolvable.clause.Clause
 import ch.ergon.dope.resolvable.clause.ISelectOffsetClause
 import ch.ergon.dope.resolvable.clause.joinHint.HashOrNestedLoopHint
@@ -76,7 +76,7 @@ interface ClauseResolver : SelectClauseResolver {
 
             is UpdateClause -> {
                 val updatable = when (val updatable = clause.updatable) {
-                    is AliasedBucket -> updatable.asBucketDefinition().toDopeQuery(this)
+                    is Definable -> updatable.asBucketDefinition().toDopeQuery(this)
                     else -> clause.updatable.toDopeQuery(this)
                 }
                 CouchbaseDopeQuery(
@@ -87,7 +87,7 @@ interface ClauseResolver : SelectClauseResolver {
 
             is DeleteClause -> {
                 val bucket = when (val deletable = clause.deletable) {
-                    is AliasedBucket -> deletable.asBucketDefinition().toDopeQuery(this)
+                    is Definable -> deletable.asBucketDefinition().toDopeQuery(this)
                     else -> clause.deletable.toDopeQuery(this)
                 }
                 CouchbaseDopeQuery(
diff --git a/couchbase/src/main/kotlin/ch/ergon/dope/couchbase/resolver/clause/MergeableClauseResolver.kt b/couchbase/src/main/kotlin/ch/ergon/dope/couchbase/resolver/clause/MergeableClauseResolver.kt
@@ -5,7 +5,7 @@ import ch.ergon.dope.couchbase.resolver.AbstractCouchbaseResolver
 import ch.ergon.dope.couchbase.util.formatPartsToQueryStringWithSpace
 import ch.ergon.dope.orEmpty
 import ch.ergon.dope.resolvable.AliasedSelectClause
-import ch.ergon.dope.resolvable.bucket.AliasedBucket
+import ch.ergon.dope.resolvable.bucket.Definable
 import ch.ergon.dope.resolvable.clause.model.mergeable.JoinType
 import ch.ergon.dope.resolvable.clause.model.mergeable.MergeableClause
 import ch.ergon.dope.resolvable.clause.model.mergeable.NestType
@@ -21,7 +21,7 @@ interface MergeableClauseResolver : AbstractCouchbaseResolver {
         }
         val parent = selectClause.parentClause.toDopeQuery(this)
         val mergeable = when (val mergeable = selectClause.mergeable) {
-            is AliasedBucket -> mergeable.asBucketDefinition().toDopeQuery(this)
+            is Definable -> mergeable.asBucketDefinition().toDopeQuery(this)
             is AliasedSelectClause<*> -> mergeable.asAliasedSelectClauseDefinition().toDopeQuery(this)
             else -> selectClause.mergeable.toDopeQuery(this)
         }
diff --git a/couchbase/src/main/kotlin/ch/ergon/dope/couchbase/resolver/clause/SelectClauseResolver.kt b/couchbase/src/main/kotlin/ch/ergon/dope/couchbase/resolver/clause/SelectClauseResolver.kt
@@ -5,7 +5,7 @@ import ch.ergon.dope.couchbase.util.formatQueryStringWithNullableFirst
 import ch.ergon.dope.couchbase.util.formatToQueryStringWithSymbol
 import ch.ergon.dope.orEmpty
 import ch.ergon.dope.resolvable.AliasedSelectClause
-import ch.ergon.dope.resolvable.bucket.AliasedBucket
+import ch.ergon.dope.resolvable.bucket.Definable
 import ch.ergon.dope.resolvable.clause.ISelectOffsetClause
 import ch.ergon.dope.resolvable.clause.SetOperator
 import ch.ergon.dope.resolvable.clause.model.AliasedUnnestClause
@@ -95,7 +95,7 @@ interface SelectClauseResolver : MergeableClauseResolver {
         is FromClause<*> -> {
             val parentDopeQuery = selectClause.parentClause.toDopeQuery(this)
             val fromableDopeQuery = when (val fromable = selectClause.fromable) {
-                is AliasedBucket -> fromable.asBucketDefinition().toDopeQuery(this)
+                is Definable -> fromable.asBucketDefinition().toDopeQuery(this)
                 is AliasedSelectClause<*> -> fromable.asAliasedSelectClauseDefinition().toDopeQuery(this)
                 else -> selectClause.fromable.toDopeQuery(this)
             }
diff --git a/couchbase/src/main/kotlin/ch/ergon/dope/couchbase/resolver/expression/ExpressionResolver.kt b/couchbase/src/main/kotlin/ch/ergon/dope/couchbase/resolver/expression/ExpressionResolver.kt
@@ -8,8 +8,8 @@ import ch.ergon.dope.merge
 import ch.ergon.dope.resolvable.AliasedSelectClause
 import ch.ergon.dope.resolvable.AliasedSelectClauseDefinition
 import ch.ergon.dope.resolvable.Asterisk
-import ch.ergon.dope.resolvable.bucket.AliasedBucket
 import ch.ergon.dope.resolvable.bucket.Bucket
+import ch.ergon.dope.resolvable.bucket.Definable
 import ch.ergon.dope.resolvable.expression.Expression
 import ch.ergon.dope.resolvable.expression.rowscope.AliasedRowScopeExpression
 import ch.ergon.dope.resolvable.expression.rowscope.RowScopeExpression
@@ -20,7 +20,7 @@ interface ExpressionResolver : TypeExpressionResolver {
     fun resolve(expression: Expression<*>): CouchbaseDopeQuery = when (expression) {
         is TypeExpression<*> -> resolve(expression)
 
-        is AliasedBucket -> CouchbaseDopeQuery("`${expression.alias}`")
+        is Definable -> CouchbaseDopeQuery("`${expression.alias}`")
 
         is Bucket -> CouchbaseDopeQuery(formatBucket(expression))
 
diff --git a/couchbase/src/main/kotlin/ch/ergon/dope/couchbase/resolver/expression/TypeExpressionResolver.kt b/couchbase/src/main/kotlin/ch/ergon/dope/couchbase/resolver/expression/TypeExpressionResolver.kt
@@ -8,7 +8,7 @@ import ch.ergon.dope.couchbase.util.formatToQueryString
 import ch.ergon.dope.couchbase.util.formatToQueryStringWithSeparator
 import ch.ergon.dope.merge
 import ch.ergon.dope.orEmpty
-import ch.ergon.dope.resolvable.bucket.AliasedBucket
+import ch.ergon.dope.resolvable.bucket.Definable
 import ch.ergon.dope.resolvable.bucket.UnaliasedBucket
 import ch.ergon.dope.resolvable.expression.operator.FunctionOperator
 import ch.ergon.dope.resolvable.expression.operator.InfixOperator
@@ -241,7 +241,7 @@ interface TypeExpressionResolver : InfixOperatorResolver, FunctionOperatorResolv
             is IField<*> -> {
                 val bucket = typeExpression.bucket
                 val fieldQuery = when (bucket) {
-                    is AliasedBucket -> "`${bucket.alias}`.`${typeExpression.name}`"
+                    is Definable -> "`${bucket.alias}`.`${typeExpression.name}`"
 
                     is UnaliasedBucket -> {
                         val path = when {
diff --git a/couchbase/src/main/kotlin/ch/ergon/dope/couchbase/util/QueryStringBuilder.kt b/couchbase/src/main/kotlin/ch/ergon/dope/couchbase/util/QueryStringBuilder.kt
@@ -25,7 +25,7 @@ internal fun formatPathToQueryString(name: String, path: String) =
     }
 
 internal fun formatBucket(bucket: Bucket): String =
-    bucket.name.split('.').plus(listOfNotNull(bucket.scope?.name, bucket.scope?.collection?.name))
+    bucket.name.split(".").plus(listOfNotNull(bucket.scope?.name, bucket.scope?.collection?.name))
         .filter { it.isNotBlank() }
         .joinToString(".") { dotPart ->
             dotPart
@@ -34,11 +34,6 @@ internal fun formatBucket(bucket: Bucket): String =
                 .joinToString(":") { "`$it`" }
         }
 
-internal fun formatBucket(bucket: String, scope: String? = null, collection: String? = null): String =
-    listOfNotNull(bucket, scope, collection)
-        .filter { it.isNotBlank() }
-        .joinToString(".") { "`$it`" }
-
 internal fun formatPartsToQueryStringWithSpace(vararg string: String?) =
     listOfNotNull(*string).joinToString(separator = " ")
 
diff --git a/couchbase/src/test/kotlin/ch/ergon/dope/buildTest/SystemTest.kt b/couchbase/src/test/kotlin/ch/ergon/dope/buildTest/SystemTest.kt
@@ -1,8 +1,8 @@
 package ch.ergon.dope.buildTest
 
 import ch.ergon.dope.QueryBuilder
-import ch.ergon.dope.couchbase.CouchbaseResolver
 import ch.ergon.dope.couchbase.resolvable.keyspace.system
+import ch.ergon.dope.couchbase.resolver.CouchbaseResolver
 import kotlin.test.Test
 import kotlin.test.assertEquals
 
@@ -29,7 +29,7 @@ class SystemTest {
 
         val actual = QueryBuilder
             .select(
-                allSequences.name,
+                allSequences.nameField,
             ).from(
                 allSequences,
             ).build(CouchbaseResolver()).queryString
diff --git a/couchbase/src/test/kotlin/ch/ergon/dope/resolvable/bucket/SystemKeyspacesTest.kt b/couchbase/src/test/kotlin/ch/ergon/dope/resolvable/bucket/SystemKeyspacesTest.kt
@@ -0,0 +1,33 @@
+package ch.ergon.dope.resolvable.bucket
+
+import ch.ergon.dope.QueryBuilder
+import ch.ergon.dope.couchbase.resolvable.keyspace.system
+import ch.ergon.dope.couchbase.resolver.CouchbaseResolver
+import kotlin.test.Test
+import kotlin.test.assertEquals
+import kotlin.test.assertNull
+
+class SystemKeyspacesTest {
+    @Test
+    fun `should keep keyspace identity separate from colliding field names`() {
+        val allSequences = system().allSequences
+
+        assertEquals("system:all_sequences", allSequences.name)
+        assertNull(allSequences.scope)
+        assertEquals("all_sequences", allSequences.alias)
+    }
+
+    @Test
+    fun `should select renamed field from system keyspace`() {
+        val allSequences = system().allSequences
+        val expected = "SELECT `all_sequences`.`name` FROM `system`:`all_sequences` AS `all_sequences`"
+
+        val actual = QueryBuilder
+            .select(allSequences.nameField)
+            .from(allSequences)
+            .build(CouchbaseResolver())
+            .queryString
+
+        assertEquals(expected, actual)
+    }
+}
diff --git a/couchbase/src/test/kotlin/ch/ergon/dope/resolvable/bucket/SystemNamespaceTest.kt b/couchbase/src/test/kotlin/ch/ergon/dope/resolvable/bucket/SystemNamespaceTest.kt
@@ -0,0 +1,17 @@
+package ch.ergon.dope.resolvable.bucket
+
+import ch.ergon.dope.couchbase.resolvable.keyspace.system
+import kotlin.test.Test
+import kotlin.test.assertSame
+
+class SystemNamespaceTest {
+    @Test
+    fun `should expose grouped and top-level references to same keyspace instances`() {
+        val namespace = system()
+
+        assertSame(namespace.dataContainers.keyspaces, namespace.keyspaces)
+        assertSame(namespace.monitoring.prepareds, namespace.prepareds)
+        assertSame(namespace.security.nodes, namespace.nodes)
+        assertSame(namespace.other.allSequences, namespace.allSequences)
+    }
+}
diff --git a/couchbase/src/test/kotlin/ch/ergon/dope/resolvable/expression/type/function/date/WeekDayStrExpressionTest.kt b/couchbase/src/test/kotlin/ch/ergon/dope/resolvable/expression/type/function/date/WeekDayStrExpressionTest.kt
@@ -1,4 +1,3 @@
-
 package ch.ergon.dope.resolvable.expression.type.function.date
 
 import ch.ergon.dope.DopeParameters
diff --git a/crystal-map-connector/src/main/kotlin/ch/ergon/dope/CrystalMapAdapter.kt b/crystal-map-connector/src/main/kotlin/ch/ergon/dope/CrystalMapAdapter.kt
@@ -81,9 +81,9 @@ fun CMJsonList<Boolean>.toDopeType(reference: String = path): Field<ArrayType<Bo
 
 fun CMJsonList<out Any>.toDopeType(reference: String = path): Field<ArrayType<ValidType>> = Field(name, bucketFrom(reference))
 
-fun <S : Schema> CMObjectField<S>.toDopeType() = ObjectField(element, name, path)
+fun <S : Schema> CMObjectField<S>.toDopeType() = ObjectField(element, name, bucketFrom(path))
 
-fun <T : Schema> CMObjectList<T>.toDopeType() = ObjectList(element, name, path)
+fun <T : Schema> CMObjectList<T>.toDopeType() = ObjectList(element, name, bucketFrom(path))
 
 fun <Convertable : Any, JsonNumberType : Number> Convertable.asParameter(
     converter: ITypeConverter<Convertable, JsonNumberType>,
diff --git a/crystal-map-connector/src/main/kotlin/ch/ergon/dope/extension/QueryBuilder.kt b/crystal-map-connector/src/main/kotlin/ch/ergon/dope/extension/QueryBuilder.kt
@@ -7,16 +7,13 @@ import com.schwarz.crystalapi.schema.CMJsonField
 import com.schwarz.crystalapi.schema.CMJsonList
 import com.schwarz.crystalapi.schema.CMType
 
-fun QueryBuilder
-.select(expression: CMType, vararg expressions: CMType) =
+fun QueryBuilder.select(expression: CMType, vararg expressions: CMType) =
     select(expression.toDopeType(), *expressions.map { it.toDopeType() }.toTypedArray())
 
-fun QueryBuilder
-.select(firstExpression: Selectable, secondExpression: CMType, vararg expressions: CMType) =
+fun QueryBuilder.select(firstExpression: Selectable, secondExpression: CMType, vararg expressions: CMType) =
     select(firstExpression, *listOf(secondExpression, *expressions).map { it.toDopeType() }.toTypedArray())
 
-fun QueryBuilder
-.select(firstExpression: CMType, secondExpression: Selectable, vararg expressions: Selectable) =
+fun QueryBuilder.select(firstExpression: CMType, secondExpression: Selectable, vararg expressions: Selectable) =
     select(firstExpression.toDopeType(), secondExpression, *expressions)
 
 fun QueryBuilder.selectDistinct(expression: CMType, vararg expressions: CMType) =
diff --git a/crystal-map-connector/src/main/kotlin/ch/ergon/dope/extension/expression/type/ObjectField.kt b/crystal-map-connector/src/main/kotlin/ch/ergon/dope/extension/expression/type/ObjectField.kt
@@ -18,7 +18,6 @@ import kotlin.reflect.KProperty1
 data class ObjectField<S : Schema>(
     val schema: S,
     override val name: String,
-    val path: String,
     override val bucket: Bucket? = null,
 ) : IField<ObjectType>
 
@@ -49,7 +48,12 @@ data class ObjectField<S : Schema>(
 @Suppress("UNCHECKED_CAST")
 inline fun <reified T : CMType, S : Schema> ObjectField<S>.getField(field: KProperty1<S, T>): T {
     val schemaField = field.get(schema)
-    val nestedFieldPath = if (path.isBlank()) name else "$path.$name"
+    val bucketValue = bucket
+    val nestedFieldPath = if (bucketValue == null) {
+        name
+    } else {
+        "${bucketValue.name}${bucketValue.scope?.let { ".$it" }}${bucketValue.scope?.collection?.let { ".$it" }}.$name"
+    }
     return when (schemaField) {
         is CMConverterField<*, *> ->
             CMConverterField(
diff --git a/crystal-map-connector/src/main/kotlin/ch/ergon/dope/extension/expression/type/ObjectList.kt b/crystal-map-connector/src/main/kotlin/ch/ergon/dope/extension/expression/type/ObjectList.kt
@@ -9,6 +9,5 @@ import com.schwarz.crystalapi.schema.Schema
 data class ObjectList<T : Schema>(
     val schema: T,
     override val name: String,
-    val path: String,
     override val bucket: Bucket? = null,
 ) : IField<ArrayType<ObjectType>>
diff --git a/crystal-map-connector/src/main/kotlin/ch/ergon/dope/extension/expression/type/range/RangeIndexedSchemaExpression.kt b/crystal-map-connector/src/main/kotlin/ch/ergon/dope/extension/expression/type/range/RangeIndexedSchemaExpression.kt
@@ -33,13 +33,13 @@ abstract class RangeIndexedSchemaExpression<S : Schema, T : ValidType, V : Valid
     override val range: TypeExpression<ArrayType<ObjectType>> get() = this.cmRange
     override val withAttributeKeys: ((Iterator<NumberType>, Iterator<ObjectType>) -> TypeExpression<StringType>)? =
         this.cmWithAttributeKeys?.let { fn ->
-            { index, iterator -> fn(index, ObjectField(cmRange.schema, iterator.variable, "")) }
+            { index, iterator -> fn(index, ObjectField(cmRange.schema, iterator.variable)) }
         }
     override val transformation: (Iterator<NumberType>, Iterator<ObjectType>) -> TypeExpression<T> =
-        { index, iterator -> this.cmTransformation(index, ObjectField(cmRange.schema, iterator.variable, "")) }
+        { index, iterator -> this.cmTransformation(index, ObjectField(cmRange.schema, iterator.variable)) }
     override val condition: ((Iterator<NumberType>, Iterator<ObjectType>) -> TypeExpression<BooleanType>)? =
         this.cmCondition?.let { fn ->
-            { index, iterator -> fn(index, ObjectField(cmRange.schema, iterator.variable, "")) }
+            { index, iterator -> fn(index, ObjectField(cmRange.schema, iterator.variable)) }
         }
 }
 
diff --git a/crystal-map-connector/src/main/kotlin/ch/ergon/dope/extension/expression/type/range/RangeSchemaExpression.kt b/crystal-map-connector/src/main/kotlin/ch/ergon/dope/extension/expression/type/range/RangeSchemaExpression.kt
@@ -30,11 +30,11 @@ abstract class RangeSchemaExpression<S : Schema, T : ValidType, V : ValidType>(
     override val membershipType = IN
     override val range: TypeExpression<ArrayType<ObjectType>> get() = this.cmRange
     override val withAttributeKeys: ((Iterator<ObjectType>) -> TypeExpression<StringType>)?
-        get() = this.cmWithAttributeKeys?.let { fn -> { iterator -> fn(ObjectField(cmRange.schema, iterator.variable, "")) } }
+        get() = this.cmWithAttributeKeys?.let { fn -> { iterator -> fn(ObjectField(cmRange.schema, iterator.variable)) } }
     override val transformation: (Iterator<ObjectType>) -> TypeExpression<T>
-        get() = { iterator -> this.cmTransformation(ObjectField(cmRange.schema, iterator.variable, "")) }
+        get() = { iterator -> this.cmTransformation(ObjectField(cmRange.schema, iterator.variable)) }
     override val condition: ((Iterator<ObjectType>) -> TypeExpression<BooleanType>)?
-        get() = this.cmCondition?.let { fn -> { iterator -> fn(ObjectField(cmRange.schema, iterator.variable, "")) } }
+        get() = this.cmCondition?.let { fn -> { iterator -> fn(ObjectField(cmRange.schema, iterator.variable)) } }
 }
 
 data class FilterRangeSchemaExpression<S : Schema>(
diff --git a/crystal-map-connector/src/main/kotlin/ch/ergon/dope/extension/expression/type/relational/SatisfiesSchemaExpression.kt b/crystal-map-connector/src/main/kotlin/ch/ergon/dope/extension/expression/type/relational/SatisfiesSchemaExpression.kt
diff --git a/crystal-map-connector/src/test/kotlin/ch/ergon/dope/CrystalMapAdapterTest.kt b/crystal-map-connector/src/test/kotlin/ch/ergon/dope/CrystalMapAdapterTest.kt
diff --git a/crystal-map-connector/src/test/kotlin/ch/ergon/dope/helper/Builder.kt b/crystal-map-connector/src/test/kotlin/ch/ergon/dope/helper/Builder.kt
