查询数据库

let { records, summary } = await driver.executeQuery(`  (1)
  CREATE (a:Person {name: $name})
  CREATE (b:Person {name: $friendName})
  CREATE (a)-[:KNOWS]->(b)
  `,
  { name: 'Alice', friendName: 'David' },  (2)
  { database: '<database-name>' }  (3)
)
console.log(
  `Created ${summary.counters.updates().nodesCreated} nodes ` +
  `in ${summary.resultAvailableAfter} ms.`
)

let { _, summary } = await driver.executeQuery(`
  MATCH (p:Person {name: $name})
  SET p.age = $age
  `,
  { name: 'Alice', age: 42 },
  { database: '<database-name>' }
)
console.log('Query counters:')
console.log(summary.counters.updates())

let { records, summary } = await driver.executeQuery(`
  MATCH (alice:Person {name: $name})  (1)
  MATCH (bob:Person {name: $friendName})  (2)
  CREATE (alice)-[:KNOWS]->(bob)  (3)
  `, { name: 'Alice', friendName: 'Bob' },
  { database: '<database-name>' }
)
console.log('Query counters:')
console.log(summary.counters.updates())

// This does not delete _only_ p, but also all its relationships!
let { _, summary } = await driver.executeQuery(`
  MATCH (p:Person WHERE p.name = $name)
  DETACH DELETE p
  `, { name: 'Alice' },
  { database: '<database-name>' }
)
console.log('Query counters:')
console.log(summary.counters.updates())

try {
  let err = await driver.executeQuery(
    'MATCH (p:Person) RETURN ',
    {},
    { database: '<database-name>' }
  )
} catch (err) {
  console.log('Neo4j error code:', err.code)
  console.log('Error message:', err.message)
}
/*
Neo4j error code: Neo.ClientError.Statement.SyntaxError
Error message: Neo4jError: Invalid input '': expected an expression, '*', 'ALL' or 'DISTINCT' (line 1, column 25 (offset: 24))
"MATCH (p:Person) RETURN"
                         ^
*/

try {
  let err = await driver.executeQuery(
    'MATCH (p:Person) RETURN ',
    {},
    { database: '<database-name>' }
  )
} catch (err) {
  console.log('Error GQL status:', err.gqlStatus)
  console.log('Error GQL status description:', err.gqlStatusDescription)
  console.log('Error GQL classification:', err.classification)
  console.log('Error GQL cause:', err.cause.message)
  console.log('Error GQL diagnostic record:', err.diagnosticRecord)
}
/*
Error GQL status: 42001
Error GQL status description: error: syntax error or access rule violation - invalid syntax
Error GQL classification: CLIENT_ERROR
Error GQL cause: GQLError: 42I06: Invalid input '', expected: an expression, '*', 'ALL' or 'DISTINCT'.
Error GQL diagnostic record: {
  OPERATION: '',
  OPERATION_CODE: '0',
  CURRENT_SCHEMA: '/',
  _classification: 'CLIENT_ERROR',
  _position: {
    line: Integer { low: 1, high: 0 },
    column: Integer { low: 25, high: 0 },
    offset: Integer { low: 24, high: 0 }
  }
}
*/

try {
  let err = await driver.executeQuery(
    'MATCH (p:Person) RETURN ',
    {},
    { database: '<database-name>' }
  )
} catch (err) {
    if (err.findByGqlStatus('42001')) {
        // Neo.ClientError.Statement.SyntaxError
        // special handling of syntax error in query
        console.log(err.message)
    } else if (err.findByGqlStatus('42NFF')) {
        // Neo.ClientError.Security.Forbidden
        // special handling of user not having CREATE permissions
        console.log(err.message)
    } else {
        // handling of all other errors
        console.log(err.message)
    }
}

const neo4j = require('neo4j-driver');

(async () => {
  const URI = '<database-uri>'
  const USER = '<username>'
  const PASSWORD = '<password>'
  let driver, result

  let people = [{name: 'Alice', age: 42, friends: ['Bob', 'Peter', 'Anna']},
                {name: 'Bob', age: 19},
                {name: 'Peter', age: 50},
                {name: 'Anna', age: 30}]

  // Connect to database
  try {
    driver = neo4j.driver(URI,  neo4j.auth.basic(USER, PASSWORD))
    await driver.verifyConnectivity()
  } catch(err) {
    console.log(`Connection error\n${err}\nCause: ${err.cause}`)
    await driver.close()
    return
  }

  // Create some nodes
  for(let person of people) {
    await driver.executeQuery(
      'MERGE (p:Person {name: $person.name, age: $person.age})',
      { person: person },
      { database: '<database-name>' }
    )
  }

  // Create some relationships
  for(let person of people) {
    if(person.friends != undefined) {
      await driver.executeQuery(`
        MATCH (p:Person {name: $person.name})
        UNWIND $person.friends AS friendName
        MATCH (friend:Person {name: friendName})
        MERGE (p)-[:KNOWS]->(friend)
        `, { person: person },
        { database: '<database-name>' }
      )
    }
  }

  // Retrieve Alice's friends who are under 40
  result = await driver.executeQuery(`
    MATCH (p:Person {name: $name})-[:KNOWS]-(friend:Person)
    WHERE friend.age < $age
    RETURN friend
    `, { name: 'Alice', age: 40 },
    { database: '<database-name>' }
  )

  // Loop through results and do something with them
  for(let person of result.records) {
    // `person.friend` is an object of type `Node`
    console.log(person.get('friend'))
  }

  // Summary information
  console.log(
    `The query \`${result.summary.query.text}\` ` +
    `returned ${result.records.length} records ` +
    `in ${result.summary.resultAvailableAfter} ms.`
  )

  await driver.close()
})();