neo4j php client

 use Laudis  Neo4j  Authentication  Authenticate ;
use Laudis  Neo4j  ClientBuilder ;

$ client = ClientBuilder:: create ()
    -> withDriver ( ' bolt ' , ' bolt+s://user:password@localhost ' ) // creates a bolt driver
    -> withDriver ( ' https ' , ' https://t**e*st.com ' , Authenticate:: basic ( ' user ' , ' password ' )) // creates an http driver
    -> withDriver ( ' neo4j ' , ' neo4j://neo4j.test.com?database=my-database ' , Authenticate:: oidc ( ' token ' )) // creates an auto routed driver with an OpenID Connect token
    -> withDefaultDriver ( ' bolt ' )
    -> build ();

 use Laudis  Neo4j  Contracts  TransactionInterface ;

$ result = $ client -> writeTransaction ( static function ( TransactionInterface $ tsx ) {
    $ result = $ tsx -> run ( ' MERGE (x {y: "z"}:X) return x ' );
    return $ result -> first ()-> get ( ' x ' )[ ' y ' ];
});

echo $ result ; // echos 'z' 

 $ client -> run (
    ' MERGE (user {email: $email}) ' , //The query is a required parameter
    [ ' email ' => ' abc@hotmail.com ' ],  //Requests can be optionally added
    ' backup ' //The default connection can be overridden
);

 use Laudis  Neo4j  Databags  Statement ;

$ statement = new Statement ( ' MERGE (user {email: $email}) ' , [ ' email ' => ' abc@hotmail.com ' ]);
$ client -> runStatement ( $ statement , ' default ' );

 use Laudis  Neo4j  Databags  Statement ;

$ results = $ client -> runStatements ([
    Statement:: create ( ' MATCH (x) RETURN x LIMIT 100 ' ),
    Statement:: create ( ' MERGE (x:Person {email: $email}) ' , [ ' email ' => ' abc@hotmail.com ' ])
]);

 use Laudis  Neo4j  Contracts  TransactionInterface ;

// Do a simple merge and return the result
$ result = $ client -> writeTransaction ( static function ( TransactionInterface $ tsx ) {
    $ result = $ tsx -> run ( ' MERGE (x {y: "z"}:X) return x ' );
    return $ result -> first ()-> get ( ' x ' )[ ' y ' ];
});

// Will result in an error
$ client -> readTransaction ( static function ( TransactionInterface $ tsx ) {
    $ tsx -> run ( ' MERGE (x {y: "z"}:X) return x ' );
});

// This is a poorly designed transaction function
$ client -> writeTransaction ( static function ( TransactionInterface $ tsx ) use ( $ externalCounter ) {
    $ externalCounter -> incrementNodesCreated ();
    $ tsx -> run ( ' MERGE (x {y: $id}:X) return x ' , [ ' id ' => Uuid:: v4 ()]);
});

// This achieves the same effect but is safe in case it should be retried. The function is now idempotent.
$ id = Uuid:: v4 ();
$ client -> writeTransaction ( static function ( TransactionInterface $ tsx ) use ( $ id ) {
    $ tsx -> run ( ' MERGE (x {y: $id}:X) return x ' , [ ' id ' => $ id ]);
});
$ externalCounter -> incrementNodesCreated ();

 use Laudis  Neo4j  Databags  Statement ;

$ tsx = $ client -> beginTransaction (
    // This is an optional set of statements to execute while opening the transaction
    [Statement:: create ( ' MERGE (x:Person({email: $email}) ' , [ ' email ' => ' abc@hotmail.com ' ])],
    ' backup ' // This is the optional connection alias
);

 $ result = $ tsx -> run ( ' MATCH (x) RETURN x LIMIT 100 ' );
$ result = $ tsx -> runStatement (Statement:: create ( ' MATCH (x) RETURN x LIMIT 100 ' ));
$ results = $ tsx -> runStatements ([Statement:: create ( ' MATCH (x) RETURN x LIMIT 100 ' )]);

 $ tsx -> rollback ();

 $ tsx -> commit ([Statement:: create ( ' MATCH (x) RETURN x LIMIT 100 ' )]);

 // Results are a CypherList
$ results = $ client -> run ( ' MATCH (node:Node) RETURN node, node.id AS id ' );

// A row is a CypherMap
foreach ( $ results as $ result ) {
    // Returns a Node
    $ node = $ result -> get ( ' node ' );

    echo $ node -> getProperty ( ' id ' );
    echo $ result -> get ( ' id ' );
}

 use Laudis  Neo4j  ParameterHelper ;

$ client -> run ( ' MATCH (x) WHERE x.slug in $listOrMap RETURN x ' , [ ' listOrMap ' => ParameterHelper:: asList ([])]); // will return an empty CypherList
$ client -> run ( ' MATCH (x) WHERE x.slug in $listOrMap RETURN x ' , [ ' listOrMap ' => ParameterHelper:: asMap ([])]); // will error
$ client -> run ( ' MATCH (x) WHERE x.slug in $listOrMap RETURN x ' , [ ' listOrMap ' => []]); // will return an empty CypherList

 $ client =  Laudis  Neo4j ClientBuilder:: create ()-> build ();

/**
 * The client will now return a result, decorated with a summary.
 *
 * @var LaudisNeo4jDatabagsSummarizedResult $results
 */
$ summarisedResult = $ client -> run ( ' MATCH (x) RETURN x ' );

// The summary contains extensive information such as counters for changed values in the database,
// information on the database, potential notifications, timing, a (profiled) plan, the type of query
// and information on the server itself.
$ summary = $ summarisedResult -> getSummary ();
// The result is exactly the same as the default.
$ result = $ summarisedResult -> getResult ();

 use Laudis  Neo4j  ClientBuilder ;

// A builder is responsible for configuring the client on a high level.
$ builder = ClientBuilder:: create ();
// A client manages the drivers as configured by the builder.
$ client = $ builder -> build ();
// A driver manages connections and sessions.
$ driver = $ client -> getDriver ( ' default ' );
// A session manages transactions.
$ session = $ driver -> createSession ();
// A transaction is the atomic unit of the driver where are the cypher queries are chained.
$ transaction = $ session -> beginTransaction ();
// A transaction runs the actual queries
$ transaction -> run ( ' MATCH (x) RETURN count(x) ' );

 use Laudis  Neo4j  Basic  Driver ;
use Laudis  Neo4j  Databags  DriverConfiguration ;

$ driver = Driver:: create (
    uri: ' neo4j://user:mypassword@Localhost:7687 ' ,
    configuration: DriverConfiguration:: create ()-> withUserAgent ( ' MyApp/1.0.0 ' )
);

 use Laudis  Neo4j  Databags  SessionConfiguration ;
use Laudis  Neo4j  Enum  AccessMode ;

$ session = $ driver -> createSession (SessionConfiguration:: create ()
    -> withDatabase ( ' my-database ' )
    -> withAccessMode (AccessMode:: READ ())
);

 use  Laudis  Neo4j  Databags  DriverConfiguration ;
use Laudis  Neo4j  Databags  SessionConfiguration ;
use Laudis  Neo4j  Databags  TransactionConfiguration ;

$ client =  Laudis  Neo4j ClientBuilder:: create ()
    -> withDefaultDriverConfiguration (DriverConfiguration:: default ()-> withUserAgent ( ' MyApp/1.0.0 ' ))
    -> withDefaultSessionConfiguration (SessionConfiguration:: default ()-> withDatabase ( ' app-database ' ))
    -> withDefaultTransactionConfiguration (TransactionConfiguration:: default ()-> withTimeout ( 5.0 ))
    -> build ();

// The client will run the query on a driver with the provided config,
// which spawns a session with the provided session config
// and runs the query in a transaction with the provided transaction config
$ client -> run ( ' MATCH (x) RETURN count(x) AS count ' );

// More granular control can be achieved by requesting the concepts yourself:
$ tsx = $ client -> getDriver ( ' default ' )
    -> createSession (SessionConfiguration:: default ()-> withDatabase ( ' management-database ' ))
    -> beginTransaction ( null , TransactionConfiguration:: default ()-> withTimeout ( 200 ));

$ tsx -> run ( ' SOME REALLY LONG MANAGEMENT QUERY ' );

$ tsx -> commit ();