Merge pull request #40 from transistive/call-clause

Add support of the CALL clause to the package.
Great work!

Author: wgevaert

src/Clauses/CallClause.php

@@ -0,0 +1,63 @@
+<?php
+
+namespace WikibaseSolutions\CypherDSL\Clauses;
+
+use WikibaseSolutions\CypherDSL\Query;
+
+/**
+ * This class represents a CALL clause.
+ *
+ * @see https://neo4j.com/docs/cypher-manual/current/clauses/call-subquery/
+ */
+class CallClause extends Clause
+{
+    /**
+     * @var Query The query to call.
+     */
+    private Query $subQuery;
+
+    /**
+     * @param Query $subQuery The query to call.
+     */
+    public function __construct(Query $subQuery)
+    {
+        $this->subQuery = $subQuery;
+    }
+
+    /**
+     * Returns the query that is being called.
+     *
+     * @return Query
+     */
+    public function getSubQuery(): Query
+    {
+        return $this->subQuery;
+    }
+
+    public function toQuery(): string
+    {
+        $subQuery = trim($this->subQuery->toQuery());
+
+        if ($subQuery === '') {
+            return '';
+        }
+
+        return sprintf('CALL { %s }', $subQuery);
+    }
+
+    /**
+     * @inheritDoc
+     */
+    protected function getSubject(): string
+    {
+        return '{ ' . $this->subQuery->toQuery() . ' }';
+    }
+
+    /**
+     * @inheritDoc
+     */
+    protected function getClause(): string
+    {
+        return 'CALL';
+    }
+}

src/Query.php

@@ -21,6 +21,9 @@
 
 namespace WikibaseSolutions\CypherDSL;
 
+use Closure;
+use Prophecy\Call\Call;
+use WikibaseSolutions\CypherDSL\Clauses\CallClause;
 use WikibaseSolutions\CypherDSL\Clauses\CallProcedureClause;
 use WikibaseSolutions\CypherDSL\Clauses\Clause;
 use WikibaseSolutions\CypherDSL\Clauses\CreateClause;
@@ -666,6 +669,29 @@ public function union($queryOrCallable, bool $all = false): self
         return $this;
     }
 
+    /**
+     * Creates a CALL sub query clause.
+     *
+     * @param callable(Query)|Query $decoratorOrClause The callable decorating the pattern, or the actual CALL clause.
+     *
+     * @return Query
+     *
+     * @see https://neo4j.com/docs/cypher-manual/current/clauses/call-subquery/
+     */
+    public function call($decoratorOrClause): self
+    {
+        if (is_callable($decoratorOrClause)) {
+            $subQuery = self::new();
+            $decoratorOrClause($subQuery);
+        } else {
+            $subQuery = $decoratorOrClause;
+        }
+
+        $this->clauses[] = new CallClause($subQuery);
+
+        return $this;
+    }
+
     /**
      * Add a clause to the query.
      *

tests/Unit/Clauses/CallClauseTest.php

@@ -0,0 +1,30 @@
+<?php
+
+namespace WikibaseSolutions\CypherDSL\Tests\Unit\Clauses;
+
+use PHPUnit\Framework\TestCase;
+use WikibaseSolutions\CypherDSL\Clauses\CallClause;
+use WikibaseSolutions\CypherDSL\Query;
+
+class CallClauseTest extends TestCase
+{
+    public function testCallClauseEmpty(): void
+    {
+        $query = Query::new();
+
+        $clause = new CallClause($query);
+
+        $this->assertEquals('', $clause->toQuery());
+        $this->assertEquals(Query::new(), $clause->getSubQuery());
+    }
+
+    public function testCallClauseFilled(): void
+    {
+        $query = Query::new()->match(Query::node('X')->named('x'))->returning(Query::rawExpression('*'));
+
+        $clause = new CallClause($query);
+
+        $this->assertEquals('CALL { MATCH (x:X) RETURN * }', $clause->toQuery());
+        $this->assertEquals($query, $clause->getSubQuery());
+    }
+}

tests/Unit/QueryTest.php

@@ -1108,6 +1108,36 @@ public function testAutomaticIdentifierGeneration(): void
         $this->assertInstanceOf(Variable::class, $node->getName());
     }
 
+    public function testCallCallable(): void
+    {
+        $node = Query::node('X')->named('y');
+        $query = Query::new()->match($node)
+            ->call(function (Query $subQuery) use ($node) {
+                $subQuery->with($node->getVariable())
+                    ->where($node->property('z')->equals(Query::literal('foo'), false))
+                    ->returning($node->property('z')->alias('foo'));
+            })
+            ->returning(Query::variable('foo'));
+
+        $this->assertEquals("MATCH (y:X) CALL { WITH y WHERE y.z = 'foo' RETURN y.z AS foo } RETURN foo", $query->toQuery());
+    }
+
+    public function testCallClause(): void {
+
+        $node = Query::node('X')->named('y');
+
+        $sub = Query::new()->with($node->getVariable())
+            ->where($node->property('z')->equals(Query::literal('foo'), false))
+            ->returning($node->property('z')->alias('foo'));
+
+        $query = Query::new()
+            ->match($node)
+            ->call($sub)
+            ->returning(Query::variable('foo'));
+
+        $this->assertEquals("MATCH (y:X) CALL { WITH y WHERE y.z = 'foo' RETURN y.z AS foo } RETURN foo", $query->toQuery());
+    }
+
     public function provideLiteralData(): array
     {
         return [