添加、弃用、移除与兼容性

SHOW CONSTRAINTS YIELD name, enforcedLabel, classification

SHOW [NODE] EXIST[ENCE] CONSTRAINTS

SHOW CONSTRAINTS

ALTER CURRENT GRAPH TYPE SET {
    (:Person => :Resident {name :: STRING NOT NULL}),
    (:Pet => :Resident&Animal {healthCertificate :: STRING, name :: STRING}),
    (:City => {name :: STRING NOT NULL, population :: INTEGER}),
    (:Resident)-[:LIVES_IN => {since :: DATE NOT NULL}]->(:City)
}

ALTER CURRENT GRAPH TYPE ADD {
  (p:Person => :Resident {name :: STRING, ssn :: INTEGER, nationality :: STRING})
    REQUIRE (p.name, p.ssn) IS KEY,
  CONSTRAINT pet_address FOR (pet:Pet) REQUIRE pet.address IS NOT NULL,
  (:Animal => {type :: STRING NOT NULL})
}

ALTER CURRENT GRAPH TYPE ALTER {
    (:Robot => :Resident&Machine {application :: STRING NOT NULL, id :: INTEGER NOT NULL}),
    (:Resident)-[:LIVES_IN => {since :: ANY NOT NULL}]->(:City)
}

SHOW CURRENT GRAPH TYPE

ALTER CURRENT GRAPH DROP {
  (:Pet =>),
  CONSTRAINT pet_address
}

CREATE CONSTRAINT node_vector_constraint
FOR (n:Movie) REQUIRE n.embedding IS :: VECTOR<INT32>(42)

CREATE CONSTRAINT rel_vector_constraint
FOR ()-[r:CONTAINS]->() REQUIRE r.embedding IS :: VECTOR<FLOAT32>(1536)

WITH datetime('1986-11-18T6:04:45.123456789+01:00[Europe/Berlin]') AS dt
RETURN format(dt, "MM/dd/yyyy") AS US, format(dt, "dd/MM/yyyy") AS EU

MATCH (()-->(n))+
WHERE allReduce(acc = 0, node IN n | acc + node.x, 6 < acc < 30)
RETURN [i IN n | i.x] AS sequence
ORDER BY head(n).x, size(n)

MATCH (n)-[r]->()
WHERE n:$(<expr1>)
WITH n, r:$(<expr2>) AS hasType
RETURN n:$(<expr3>)

CREATE DATABASE db OPTIONS { seedCredentials: ... }

CREATE DATABASE db OPTIONS { existingDataSeedInstance: ... }

CREATE ALIAS composite.`1` FOR DATABASE neo4j

USE composite.`1`

RETURN 1 as my\u0085identifier

RETURN 1 as my$Identifier

MATCH (n)-[r:REL]->(m) SET n = r;
MATCH (n)-[r:REL]->(m) SET n += r;
MATCH (n)-[r:REL]->(m) SET r = n;
MATCH (n)-[r:REL]->(m) SET r += n;

MATCH (n)-[r:REL]->(m) SET n = properties(r)

REVOKE READ {*} ON GRAPH * NODES A FROM missingUser
REVOKE ROLE missingRole FROM bob

MERGE (a {foo:1})-[:T]->(b {foo:a.foo})

CREATE ... INDEX ... OPTIONS { indexProvider: ... }
CREATE ... CONSTRAINTS ... OPTIONS { indexProvider: ... }

db.create.setVectorProperty()
db.index.vector.createNodeIndex()
dbms.cluster.readReplicaToggle()
dbms.cluster.uncordonServer()
dbms.quarantineDatabase()
dbms.upgrade()
dbms.upgradeStatus()

CREATE DATABASE db OPTIONS { existingData: ... }

WITH 1 AS g
RETURN COLLECT {
        UNWIND [1,2,3] AS x
        WITH * WHERE x < 0
        WITH count(*) AS agg
        RETURN agg + g
} AS x

RETURN $0hello

MATCH SHORTEST $param (:A)-[:R]->{0,10}(:B)

MATCH p = ANY $param (:A)-[:R]->{0,10}(:B)

MATCH SHORTEST $param GROUPS (:A)-[:R]->{0,10}(:B)

CALL db.schema.nodeTypeProperties() YIELD propertyTypes RETURN propertyTypes;
CALL db.schema.relTypeProperties() YIELD propertyTypes RETURN propertyTypes;

SHOW NODE PROPERTY UNIQUENESS CONSTRAINTS
SHOW RELATIONSHIP PROPERTY UNIQUENESS CONSTRAINTS
SHOW PROPERTY UNIQUENESS CONSTRAINTS

SHOW TRANSACTIONS YIELD startTime, clientAddress, outerTransactionId, currentQuery, currentQueryId, parameters, planner, runtime, indexes, currentQueryStartTime, currentQueryElapsedTime, currentQueryCpuTime, currentQueryIdleTime, currentQueryStatus

USE graph.byName('composite.with.dot.constituent')
USE graph.propertiesByName('composite.with.dot.constituent')

CREATE (:Person)
MATCH (p:Person)
RETURN count(p) AS count

RETURN replace("hello world", "l", "", 1)

CREATE [COMPOSITE] DATABASE actors SET DEFAULT LANGUAGE CYPHER 25

CREATE ALIAS `remote-with-default-language`
FOR DATABASE `northwind-graph-2020`
    AT "neo4j+s://location:7687"
    USER alice
    PASSWORD 'example_secret'
    DEFAULT LANGUAGE CYPHER 25

ALTER DATABASE movies SET DEFAULT LANGUAGE CYPHER 25

ALTER ALIAS `remote-with-default-language` SET DATABASE DEFAULT LANGUAGE CYPHER 25

SHOW DATABASES YIELD name, defaultLanguage

SHOW ALIAS `remote-with-default-language` FOR DATABASE YIELD name, defaultLanguage

CYPHER 25
MATCH (n:Person)
FILTER n.age < 35
RETURN n.name AS name

RETURN 1 AS a

NEXT

RETURN 1 AS b

MATCH (s:Supplier)-[:SUPPLIES]->(p:Product)
LET supplier =  s.name
RETURN supplier, p.name AS product

UNWIND [1, 2, 3, 4, 5, 6] AS x
FILTER x > 2
RETURN x

LOAD CSV WITH HEADERS FROM 'file:///companies.csv' AS row
FILTER row.Id IS NOT NULL
MERGE (c:Company {id: row.Id})

WHEN false THEN RETURN 1 AS x
WHEN true THEN RETURN 2 AS x
ELSE RETURN 3 AS x

 MATCH (n:Person)
 OPTIONAL MATCH (n)-[:KNOWS]->(m)
 CALL (*) {
   WHEN m IS NULL THEN {
      CREATE (f: Person {name: 'Peter', age: n.age}),
      (n)-[:KNOWS]->(f)
         RETURN f, n.name AS newConnection
   }
 }
RETURN f.name AS newNode,
       collect(newConnection) AS newConnections

{
   MATCH (n:Actor)
   RETURN n.name AS name
   UNION
   MATCH (n:Director)
   RETURN n.name AS name
}
UNION ALL
MATCH (n:Movie)
RETURN n.title AS name

CREATE DATABASE db OPTIONS { seedRestoreUntil: ... }

CREATE DATABASE db OPTIONS { seedSourceDatabase: ... }

RETURN cosh(0.5), coth(0.5), sinh(0.5), tanh(0.5)

MATCH (n)
RETURN ALL n.prop AS prop

MATCH (n)
WITH ALL n.prop AS prop
RETURN prop

MATCH REPEATABLE ELEMENTS p = (:B)-->{,5}()
RETURN [n IN nodes(p) | n.q] AS nodes

MATCH DIFFERENT RELATIONSHIPS p = (:B)-->{,5}()
RETURN [n IN nodes(p) | n.q] AS nodes