用户定义聚合函数

用户定义聚合函数是聚合数据并返回单个结果的函数。有关用户定义过程、函数和聚合函数之间比较的信息，请参阅Neo4j 定制代码。

调用聚合函数

用户定义聚合函数的调用方式与任何其他 Cypher 聚合函数相同。函数名称必须完全限定，因此在包 org.neo4j.examples 中定义的名为 longestString 的函数可以使用以下方式调用：

MATCH (p: Person) WHERE p.age = 36
RETURN org.neo4j.examples.longestString(p.name)

编写用户定义聚合函数

用户定义聚合函数使用 @UserAggregationFunction 进行注释。注释的函数必须返回聚合器类的实例。聚合器类包含一个使用 @UserAggregationUpdate 注释的方法和一个使用 @UserAggregationResult 注释的方法。使用 @UserAggregationUpdate 注释的方法将被多次调用，并使类能够聚合数据。聚合完成后，将调用一次使用 @UserAggregationResult 注释的方法，并返回聚合的结果。

有关值和类型的详细信息，请参阅值和类型。

有关更多详细信息，请参阅 Neo4j Javadocs 中的org.neo4j.procedure.UserAggregationFunction。

从聚合函数内部发出错误信号的正确方法是抛出 RuntimeException。

 
package example;

import org.neo4j.procedure.Description;
import org.neo4j.procedure.Name;
import org.neo4j.procedure.UserAggregationFunction;
import org.neo4j.procedure.UserAggregationResult;
import org.neo4j.procedure.UserAggregationUpdate;

public class LongestString
{
    @UserAggregationFunction
    @Description( "org.neo4j.function.example.longestString(string) - aggregates the longest string found" )
    public LongStringAggregator longestString()
    {
        return new LongStringAggregator();
    }

    public static class LongStringAggregator
    {
        private int longest;
        private String longestString;

        @UserAggregationUpdate
        public void findLongest(
                @Name( "string" ) String string )
        {
            if ( string != null && string.length() > longest)
            {
                longest = string.length();
                longestString = string;
            }
        }

        @UserAggregationResult
        public String result()
        {
            return longestString;
        }
    }
}

集成测试

用户定义聚合函数的测试创建方式与普通用户定义函数的测试相同。

用于测试查找最长字符串的用户定义聚合函数的模板。
package example;

import org.junit.Rule;
import org.junit.Test;
import org.neo4j.driver.v1.*;
import org.neo4j.harness.junit.Neo4jRule;

import static org.hamcrest.core.IsEqual.equalTo;
import static org.junit.Assert.assertThat;

public class LongestStringTest
{
    // This rule starts a Neo4j instance
    @Rule
    public Neo4jRule neo4j = new Neo4jRule()

            // This is the function to test
            .withAggregationFunction( LongestString.class );

    @Test
    public void shouldAllowIndexingAndFindingANode() throws Throwable
    {
        // This is in a try-block, to make sure you close the driver after the test
        try( Driver driver = GraphDatabase.driver( neo4j.boltURI() , Config.build().withEncryptionLevel( Config.EncryptionLevel.NONE ).toConfig() ) )
        {
            // Given
            Session session = driver.session();

            // When
            String result = session.run( "UNWIND ["abc", "abcd", "ab"] AS string RETURN example.longestString(string) AS result").single().get("result").asString();

            // Then
            assertThat( result, equalTo( "abcd" ) );
        }
    }
}