Merge pull request #8879 from fickludd/3.2-push-more-boundary

Constraint boundary push

community/cypher/cypher-compiler-3.2/src/main/scala/org/neo4j/cypher/internal/compiler/v3_2/spi/DelegatingQueryContext.scala

@@ -110,19 +110,19 @@ class DelegatingQueryContext(val inner: QueryContext) extends QueryContext {
   override def getOrCreateFromSchemaState[K, V](key: K, creator: => V): V =
     singleDbHit(inner.getOrCreateFromSchemaState(key, creator))
 
-  override def createUniqueConstraint(descriptor: IndexDescriptor) =
+  override def createUniqueConstraint(descriptor: IndexDescriptor): Boolean =
     singleDbHit(inner.createUniqueConstraint(descriptor))
 
   override def dropUniqueConstraint(descriptor: IndexDescriptor) =
     singleDbHit(inner.dropUniqueConstraint(descriptor))
 
-  override def createNodePropertyExistenceConstraint(labelId: Int, propertyKeyId: Int) =
+  override def createNodePropertyExistenceConstraint(labelId: Int, propertyKeyId: Int): Boolean =
     singleDbHit(inner.createNodePropertyExistenceConstraint(labelId, propertyKeyId))
 
   override def dropNodePropertyExistenceConstraint(labelId: Int, propertyKeyId: Int) =
     singleDbHit(inner.dropNodePropertyExistenceConstraint(labelId, propertyKeyId))
 
-  override def createRelationshipPropertyExistenceConstraint(relTypeId: Int, propertyKeyId: Int) =
+  override def createRelationshipPropertyExistenceConstraint(relTypeId: Int, propertyKeyId: Int): Boolean =
     singleDbHit(inner.createRelationshipPropertyExistenceConstraint(relTypeId, propertyKeyId))
 
   override def dropRelationshipPropertyExistenceConstraint(relTypeId: Int, propertyKeyId: Int) =

community/cypher/cypher-compiler-3.2/src/main/scala/org/neo4j/cypher/internal/compiler/v3_2/spi/QueryContext.scala

@@ -26,7 +26,6 @@ import org.neo4j.cypher.internal.compiler.v3_2.commands.expressions.{Expander, K
 import org.neo4j.cypher.internal.compiler.v3_2.pipes.matching.PatternNode
 import org.neo4j.cypher.internal.frontend.v3_2.SemanticDirection
 import org.neo4j.graphdb.{Node, Path, PropertyContainer, Relationship}
-import org.neo4j.kernel.api.constraints.{NodePropertyExistenceConstraint, RelationshipPropertyExistenceConstraint, UniquenessConstraint}
 import org.neo4j.cypher.internal.compiler.v3_2.IndexDescriptor
 
 import scala.collection.Iterator
@@ -103,15 +102,18 @@ trait QueryContext extends TokenContext {
 
   def getOrCreateFromSchemaState[K, V](key: K, creator: => V): V
 
-  def createUniqueConstraint(descriptor: IndexDescriptor): IdempotentResult[UniquenessConstraint]
+  /* return true if the constraint was created, false if preexisting, throws if failed */
+  def createUniqueConstraint(descriptor: IndexDescriptor): Boolean
 
   def dropUniqueConstraint(descriptor: IndexDescriptor)
 
-  def createNodePropertyExistenceConstraint(labelId: Int, propertyKeyId: Int): IdempotentResult[NodePropertyExistenceConstraint]
+  /* return true if the constraint was created, false if preexisting, throws if failed */
+  def createNodePropertyExistenceConstraint(labelId: Int, propertyKeyId: Int): Boolean
 
   def dropNodePropertyExistenceConstraint(labelId: Int, propertyKeyId: Int)
 
-  def createRelationshipPropertyExistenceConstraint(relTypeId: Int, propertyKeyId: Int): IdempotentResult[RelationshipPropertyExistenceConstraint]
+  /* return true if the constraint was created, false if preexisting, throws if failed */
+  def createRelationshipPropertyExistenceConstraint(relTypeId: Int, propertyKeyId: Int): Boolean
 
   def dropRelationshipPropertyExistenceConstraint(relTypeId: Int, propertyKeyId: Int)
 

community/cypher/cypher-compiler-3.2/src/main/scala/org/neo4j/cypher/internal/compiler/v3_2/spi/UpdateCountingQueryContext.scala

@@ -102,9 +102,9 @@ class UpdateCountingQueryContext(inner: QueryContext) extends DelegatingQueryCon
     indexesRemoved.increase()
   }
 
-  override def createUniqueConstraint(descriptor: IndexDescriptor) = {
+  override def createUniqueConstraint(descriptor: IndexDescriptor): Boolean = {
     val result = inner.createUniqueConstraint(descriptor)
-    result.ifCreated { uniqueConstraintsAdded.increase() }
+    if ( result ) uniqueConstraintsAdded.increase();
     result
   }
 
@@ -113,9 +113,9 @@ class UpdateCountingQueryContext(inner: QueryContext) extends DelegatingQueryCon
     uniqueConstraintsRemoved.increase()
   }
 
-  override def createNodePropertyExistenceConstraint(labelId: Int, propertyKeyId: Int) = {
+  override def createNodePropertyExistenceConstraint(labelId: Int, propertyKeyId: Int): Boolean = {
     val result = inner.createNodePropertyExistenceConstraint(labelId, propertyKeyId)
-    result.ifCreated { propertyExistenceConstraintsAdded.increase() }
+    if ( result ) propertyExistenceConstraintsAdded.increase()
     result
   }
 
@@ -124,9 +124,9 @@ class UpdateCountingQueryContext(inner: QueryContext) extends DelegatingQueryCon
     propertyExistenceConstraintsRemoved.increase()
   }
 
-  override def createRelationshipPropertyExistenceConstraint(relTypeId: Int, propertyKeyId: Int) = {
+  override def createRelationshipPropertyExistenceConstraint(relTypeId: Int, propertyKeyId: Int): Boolean = {
     val result = inner.createRelationshipPropertyExistenceConstraint(relTypeId, propertyKeyId)
-    result.ifCreated { propertyExistenceConstraintsAdded.increase() }
+    if ( result ) propertyExistenceConstraintsAdded.increase()
     result
   }
 

community/cypher/cypher-compiler-3.2/src/test/scala/org/neo4j/cypher/internal/compiler/v3_2/spi/QueryContextAdaptation.scala

@@ -25,7 +25,6 @@ import org.neo4j.cypher.internal.compiler.v3_2.commands.expressions.{Expander, K
 import org.neo4j.cypher.internal.compiler.v3_2.pipes.matching.PatternNode
 import org.neo4j.cypher.internal.frontend.v3_2.SemanticDirection
 import org.neo4j.graphdb.{Node, Path, PropertyContainer, Relationship}
-import org.neo4j.kernel.api.constraints.{NodePropertyExistenceConstraint, RelationshipPropertyExistenceConstraint, UniquenessConstraint}
 import org.neo4j.cypher.internal.compiler.v3_2.IndexDescriptor
 
 trait QueryContextAdaptation {
@@ -37,14 +36,13 @@ trait QueryContextAdaptation {
 
   override def indexScanByEndsWith(index: IndexDescriptor, value: String): Iterator[Node] = ???
 
-  override def createNodePropertyExistenceConstraint(labelId: Int, propertyKeyId: Int): IdempotentResult[NodePropertyExistenceConstraint] = ???
+  override def createNodePropertyExistenceConstraint(labelId: Int, propertyKeyId: Int): Boolean = ???
 
   override def createNode(): Node = ???
 
   override def dropRelationshipPropertyExistenceConstraint(relTypeId: Int, propertyKeyId: Int): Unit = ???
 
-  override def createUniqueConstraint(descriptor: IndexDescriptor):
-  IdempotentResult[UniquenessConstraint] = ???
+  override def createUniqueConstraint(descriptor: IndexDescriptor): Boolean = ???
 
   override def getOrCreateRelTypeId(relTypeName: String): Int = ???
 
@@ -109,7 +107,7 @@ trait QueryContextAdaptation {
 
   override def setLabelsOnNode(node: Long, labelIds: scala.Iterator[Int]): Int = ???
 
-  override def createRelationshipPropertyExistenceConstraint(relTypeId: Int, propertyKeyId: Int): IdempotentResult[RelationshipPropertyExistenceConstraint] = ???
+  override def createRelationshipPropertyExistenceConstraint(relTypeId: Int, propertyKeyId: Int): Boolean = ???
 
   override def relationshipEndNode(rel: Relationship): Node = ???
 

community/cypher/cypher-compiler-3.2/src/test/scala/org/neo4j/cypher/internal/compiler/v3_2/spi/UpdateCountingQueryContextTest.scala

@@ -27,7 +27,6 @@ import org.neo4j.cypher.internal.compiler.v3_2.InternalQueryStatistics
 import org.neo4j.cypher.internal.compiler.v3_2.IndexDescriptor
 import org.neo4j.cypher.internal.frontend.v3_2.test_helpers.CypherFunSuite
 import org.neo4j.graphdb.{Node, Relationship}
-import org.neo4j.kernel.api.constraints.{NodePropertyExistenceConstraint, RelationshipPropertyExistenceConstraint, UniquenessConstraint}
 
 class UpdateCountingQueryContextTest extends CypherFunSuite {
 
@@ -57,14 +56,11 @@ class UpdateCountingQueryContextTest extends CypherFunSuite {
     }
   } )
 
-  when(inner.createUniqueConstraint(anyObject()))
-    .thenReturn(IdempotentResult(mock[UniquenessConstraint]))
+  when(inner.createUniqueConstraint(anyObject())).thenReturn(true)
 
-  when( inner.createNodePropertyExistenceConstraint(anyInt(), anyInt()) )
-    .thenReturn(IdempotentResult(mock[NodePropertyExistenceConstraint]))
+  when( inner.createNodePropertyExistenceConstraint(anyInt(), anyInt()) ).thenReturn(true)
 
-  when( inner.createRelationshipPropertyExistenceConstraint(anyInt(), anyInt()) )
-    .thenReturn(IdempotentResult(mock[RelationshipPropertyExistenceConstraint]))
+  when( inner.createRelationshipPropertyExistenceConstraint(anyInt(), anyInt()) ).thenReturn(true)
 
   when(inner.addIndexRule(anyObject()))
     .thenReturn(IdempotentResult(mock[IndexDescriptor]))

community/cypher/cypher/src/main/scala/org/neo4j/cypher/internal/compatibility/v3_2/ExceptionTranslatingQueryContext.scala

@@ -112,19 +112,19 @@ class ExceptionTranslatingQueryContext(val inner: QueryContext) extends QueryCon
   override def getOrCreateFromSchemaState[K, V](key: K, creator: => V): V =
     translateException(inner.getOrCreateFromSchemaState(key, creator))
 
-  override def createUniqueConstraint(descriptor: IndexDescriptor) =
+  override def createUniqueConstraint(descriptor: IndexDescriptor): Boolean =
     translateException(inner.createUniqueConstraint(descriptor))
 
   override def dropUniqueConstraint(descriptor: IndexDescriptor) =
     translateException(inner.dropUniqueConstraint(descriptor))
 
-  override def createNodePropertyExistenceConstraint(labelId: Int, propertyKeyId: Int) =
+  override def createNodePropertyExistenceConstraint(labelId: Int, propertyKeyId: Int): Boolean =
     translateException(inner.createNodePropertyExistenceConstraint(labelId, propertyKeyId))
 
   override def dropNodePropertyExistenceConstraint(labelId: Int, propertyKeyId: Int) =
     translateException(inner.dropNodePropertyExistenceConstraint(labelId, propertyKeyId))
 
-  override def createRelationshipPropertyExistenceConstraint(relTypeId: Int, propertyKeyId: Int) =
+  override def createRelationshipPropertyExistenceConstraint(relTypeId: Int, propertyKeyId: Int): Boolean =
     translateException(inner.createRelationshipPropertyExistenceConstraint(relTypeId, propertyKeyId))
 
   override def dropRelationshipPropertyExistenceConstraint(relTypeId: Int, propertyKeyId: Int) =

community/cypher/cypher/src/main/scala/org/neo4j/cypher/internal/spi/v2_3/TransactionBoundPlanContext.scala

@@ -30,7 +30,9 @@ import org.neo4j.kernel.api.constraints.UniquenessConstraint
 import org.neo4j.kernel.api.exceptions.KernelException
 import org.neo4j.kernel.api.exceptions.schema.SchemaKernelException
 import org.neo4j.kernel.api.index.InternalIndexState
-import org.neo4j.kernel.api.schema.{NodePropertyDescriptor}
+import org.neo4j.kernel.api.schema.NodePropertyDescriptor
+import org.neo4j.kernel.api.schema_new.SchemaDescriptorFactory
+import org.neo4j.kernel.api.schema_new.constaints.{ConstraintBoundary, ConstraintDescriptor}
 import org.neo4j.kernel.api.schema_new.index.{NewIndexDescriptor => KernelIndexDescriptor}
 import org.neo4j.kernel.impl.transaction.log.TransactionIdStore
 
@@ -78,8 +80,11 @@ class TransactionBoundPlanContext(tc: TransactionalContextWrapper)
     val propertyKeyId = tc.statement.readOperations().propertyKeyGetForName(propertyKey)
 
     import scala.collection.JavaConverters._
-    tc.statement.readOperations().constraintsGetForLabelAndPropertyKey(new NodePropertyDescriptor(labelId, propertyKeyId)).asScala.collectFirst {
-      case unique: UniquenessConstraint => unique
+    tc.statement.readOperations().constraintsGetForSchema(
+      SchemaDescriptorFactory.forLabel(labelId, propertyKeyId)
+    ).asScala.collectFirst {
+      case constraint: ConstraintDescriptor if constraint.`type`() == ConstraintDescriptor.Type.UNIQUE =>
+        ConstraintBoundary.map( constraint ).asInstanceOf[UniquenessConstraint]
     }
   } catch {
     case _: KernelException => None

community/cypher/cypher/src/main/scala/org/neo4j/cypher/internal/spi/v2_3/TransactionBoundQueryContext.scala

@@ -48,8 +48,10 @@ import org.neo4j.kernel.GraphDatabaseQueryService
 import org.neo4j.kernel.api.constraints.{NodePropertyExistenceConstraint, RelationshipPropertyExistenceConstraint, UniquenessConstraint}
 import org.neo4j.kernel.api.exceptions.schema.{AlreadyConstrainedException, AlreadyIndexedException}
 import org.neo4j.kernel.api.index.InternalIndexState
-import org.neo4j.kernel.api.schema.{NodePropertyDescriptor, RelationshipPropertyDescriptor}
 import org.neo4j.kernel.api.schema_new.IndexQuery
+import org.neo4j.kernel.api.schema.NodePropertyDescriptor
+import org.neo4j.kernel.api.schema_new.SchemaDescriptorFactory
+import org.neo4j.kernel.api.schema_new.constaints.{ConstraintBoundary, ConstraintDescriptorFactory}
 import org.neo4j.kernel.api.schema_new.index.NewIndexDescriptorFactory
 import org.neo4j.kernel.api.{exceptions, _}
 import org.neo4j.kernel.impl.core.NodeManager
@@ -467,41 +469,45 @@ final class TransactionBoundQueryContext(tc: TransactionalContextWrapper)
     tc.statement.schemaWriteOperations().indexDrop(NewIndexDescriptorFactory.forLabel( labelId, propertyKeyId ))
 
   def createUniqueConstraint(labelId: Int, propertyKeyId: Int): IdempotentResult[UniquenessConstraint] = try {
-    IdempotentResult(tc.statement.schemaWriteOperations().uniquePropertyConstraintCreate(new NodePropertyDescriptor(labelId,
-      propertyKeyId)))
+    IdempotentResult(ConstraintBoundary.mapUnique(
+        tc.statement.schemaWriteOperations().uniquePropertyConstraintCreate(
+          SchemaDescriptorFactory.forLabel(labelId, propertyKeyId)
+        )))
   } catch {
     case existing: AlreadyConstrainedException =>
       IdempotentResult(existing.constraint().asInstanceOf[UniquenessConstraint], wasCreated = false)
   }
 
   def dropUniqueConstraint(labelId: Int, propertyKeyId: Int) =
-    tc.statement.schemaWriteOperations().constraintDrop(new UniquenessConstraint(new NodePropertyDescriptor(labelId,
-      propertyKeyId)))
+    tc.statement.schemaWriteOperations().constraintDrop(ConstraintDescriptorFactory.uniqueForLabel(labelId, propertyKeyId))
 
   def createNodePropertyExistenceConstraint(labelId: Int, propertyKeyId: Int): IdempotentResult[NodePropertyExistenceConstraint] =
     try {
-      IdempotentResult(tc.statement.schemaWriteOperations().nodePropertyExistenceConstraintCreate(new NodePropertyDescriptor(labelId,
-        propertyKeyId)))
+      IdempotentResult(ConstraintBoundary.mapNode(
+        tc.statement.schemaWriteOperations().nodePropertyExistenceConstraintCreate(
+          SchemaDescriptorFactory.forLabel(labelId, propertyKeyId)
+        )).asInstanceOf[NodePropertyExistenceConstraint]) // this cast can be resolved with 2.3.10
     } catch {
       case existing: AlreadyConstrainedException =>
         IdempotentResult(existing.constraint().asInstanceOf[NodePropertyExistenceConstraint], wasCreated = false)
     }
 
   def dropNodePropertyExistenceConstraint(labelId: Int, propertyKeyId: Int) =
-    tc.statement.schemaWriteOperations().constraintDrop(new NodePropertyExistenceConstraint(new NodePropertyDescriptor(labelId,
-      propertyKeyId)))
+    tc.statement.schemaWriteOperations().constraintDrop(ConstraintDescriptorFactory.existsForLabel(labelId, propertyKeyId))
 
   def createRelationshipPropertyExistenceConstraint(relTypeId: Int, propertyKeyId: Int): IdempotentResult[RelationshipPropertyExistenceConstraint] =
     try {
-      IdempotentResult(tc.statement.schemaWriteOperations().relationshipPropertyExistenceConstraintCreate(new RelationshipPropertyDescriptor(relTypeId, propertyKeyId)))
+      IdempotentResult(ConstraintBoundary.mapRelationship(
+        tc.statement.schemaWriteOperations().relationshipPropertyExistenceConstraintCreate(
+          SchemaDescriptorFactory.forRelType(relTypeId, propertyKeyId)
+        )).asInstanceOf[RelationshipPropertyExistenceConstraint])
     } catch {
       case existing: AlreadyConstrainedException =>
         IdempotentResult(existing.constraint().asInstanceOf[RelationshipPropertyExistenceConstraint], wasCreated = false)
     }
 
   def dropRelationshipPropertyExistenceConstraint(relTypeId: Int, propertyKeyId: Int) =
-    tc.statement.schemaWriteOperations().constraintDrop(new RelationshipPropertyExistenceConstraint(new
-        RelationshipPropertyDescriptor(relTypeId,propertyKeyId)))
+    tc.statement.schemaWriteOperations().constraintDrop(ConstraintDescriptorFactory.existsForRelType(relTypeId,propertyKeyId))
 
   override def getImportURL(url: URL): Either[String,URL] = tc.graph match {
     case db: GraphDatabaseQueryService =>

community/cypher/cypher/src/main/scala/org/neo4j/cypher/internal/spi/v3_1/TransactionBoundPlanContext.scala

@@ -37,6 +37,8 @@ import org.neo4j.kernel.api.index.InternalIndexState
 import org.neo4j.kernel.api.proc.Neo4jTypes.AnyType
 import org.neo4j.kernel.api.proc.{Neo4jTypes, QualifiedName => KernelQualifiedName}
 import org.neo4j.kernel.api.schema.NodePropertyDescriptor
+import org.neo4j.kernel.api.schema_new.SchemaDescriptorFactory
+import org.neo4j.kernel.api.schema_new.constaints.{ConstraintBoundary, ConstraintDescriptor}
 import org.neo4j.kernel.api.schema_new.index.{NewIndexDescriptor => KernelIndexDescriptor}
 import org.neo4j.kernel.impl.proc.Neo4jValue
 import org.neo4j.procedure.Mode
@@ -85,8 +87,11 @@ class TransactionBoundPlanContext(tc: TransactionalContextWrapper, logger: Inter
     val propertyKeyId = tc.statement.readOperations().propertyKeyGetForName(propertyKey)
 
     import scala.collection.JavaConverters._
-    tc.statement.readOperations().constraintsGetForLabelAndPropertyKey(new NodePropertyDescriptor(labelId, propertyKeyId)).asScala.collectFirst {
-      case unique: UniquenessConstraint => unique
+    tc.statement.readOperations().constraintsGetForSchema(
+      SchemaDescriptorFactory.forLabel(labelId, propertyKeyId)
+    ).asScala.collectFirst {
+        case constraint: ConstraintDescriptor if constraint.`type`() == ConstraintDescriptor.Type.UNIQUE =>
+          ConstraintBoundary.map( constraint ).asInstanceOf[UniquenessConstraint]
     }
   } catch {
     case _: KernelException => None
@@ -96,7 +101,7 @@ class TransactionBoundPlanContext(tc: TransactionalContextWrapper, logger: Inter
     val labelId = tc.statement.readOperations().labelGetForName(labelName)
     val propertyKeyId = tc.statement.readOperations().propertyKeyGetForName(propertyKey)
 
-    tc.statement.readOperations().constraintsGetForLabelAndPropertyKey(new NodePropertyDescriptor(labelId, propertyKeyId)).hasNext
+    tc.statement.readOperations().constraintsGetForSchema(SchemaDescriptorFactory.forLabel(labelId, propertyKeyId)).hasNext
   }
 
   def checkNodeIndex(idxName: String) {