Added missing system updates

Changed updates to a dictionary.

Author: Zhen Li

src/result-summary.js

@@ -206,11 +206,13 @@ class StatementStatistics {
       constraintsAdded: 0,
       constraintsRemoved: 0
     }
+    this._systemUpdates = 0
     Object.keys(statistics).forEach(index => {
       // To camelCase
-      this._stats[index.replace(/(-\w)/g, m => m[1].toUpperCase())] = intValue(
-        statistics[index]
-      )
+      const camelCaseIndex = index.replace(/(-\w)/g, m => m[1].toUpperCase())
+      if (camelCaseIndex in this._stats) { this._stats[camelCaseIndex] = intValue(statistics[index]) } else if (camelCaseIndex === 'systemUpdates') {
+        this._systemUpdates = intValue(statistics[index])
+      }
     })
   }
 
@@ -227,80 +229,26 @@ class StatementStatistics {
   }
 
   /**
-   * @return {Number} - Number of nodes created.
+   * Returns the statement statistics updates in a dictionary.
+   * @returns {*}
    */
-  nodesCreated () {
-    return this._stats.nodesCreated
+  updates () {
+    return this._stats
   }
 
   /**
-   * @return {Number} - Number of nodes deleted.
+   * Return true if the system database get updated, otherwise false
+   * @returns {boolean} - If the system database get updated or not.
    */
-  nodesDeleted () {
-    return this._stats.nodesDeleted
+  containsSystemUpdates () {
+    return this._systemUpdates > 0
   }
 
   /**
-   * @return {Number} - Number of relationships created.
+   * @returns {number} - Number of system updates
    */
-  relationshipsCreated () {
-    return this._stats.relationshipsCreated
-  }
-
-  /**
-   * @return {Number} - Number of nodes deleted.
-   */
-  relationshipsDeleted () {
-    return this._stats.relationshipsDeleted
-  }
-
-  /**
-   * @return {Number} - Number of properties set.
-   */
-  propertiesSet () {
-    return this._stats.propertiesSet
-  }
-
-  /**
-   * @return {Number} - Number of labels added.
-   */
-  labelsAdded () {
-    return this._stats.labelsAdded
-  }
-
-  /**
-   * @return {Number} - Number of labels removed.
-   */
-  labelsRemoved () {
-    return this._stats.labelsRemoved
-  }
-
-  /**
-   * @return {Number} - Number of indexes added.
-   */
-  indexesAdded () {
-    return this._stats.indexesAdded
-  }
-
-  /**
-   * @return {Number} - Number of indexes removed.
-   */
-  indexesRemoved () {
-    return this._stats.indexesRemoved
-  }
-
-  /**
-   * @return {Number} - Number of constraints added.
-   */
-  constraintsAdded () {
-    return this._stats.constraintsAdded
-  }
-
-  /**
-   * @return {Number} - Number of constraints removed.
-   */
-  constraintsRemoved () {
-    return this._stats.constraintsRemoved
+  systemUpdates () {
+    return this._systemUpdates
   }
 }
 

test/rx/summary.test.js

@@ -201,6 +201,43 @@ describe('#integration-rx summary', () => {
       shouldReturnNotification(serverVersion, txc))
   })
 
+  describe('system', () => {
+    let driver
+    /** @type {RxSession} */
+    let session
+    /** @type {ServerVersion} */
+    let serverVersion
+
+    beforeEach(async () => {
+      driver = neo4j.driver('bolt://localhost', sharedNeo4j.authToken)
+      session = driver.rxSession({ database: 'system' })
+      //
+
+      const normalSession = driver.session()
+      try {
+        const result = await normalSession.run('MATCH (n) DETACH DELETE n')
+        serverVersion = ServerVersion.fromString(result.summary.server.version)
+      } finally {
+        await normalSession.close()
+      }
+
+      await dropConstraintsAndIndices(driver)
+    })
+
+    afterEach(async () => {
+      if (session) {
+        await session.close().toPromise()
+      }
+      await driver.close()
+    })
+
+    it('session should return summary with correct system updates for create', () =>
+      shouldReturnSummaryWithSystemUpdates(serverVersion, session))
+
+    it('transaction should return summary with correct system updates for create', () =>
+      shouldReturnSummaryWithSystemUpdates(serverVersion, session, true))
+  })
+
   /**
    * @param {ServerVersion} version
    * @param {RxSession|RxTransaction} runnable
@@ -269,6 +306,37 @@ describe('#integration-rx summary', () => {
     await verifyStatementType(runnable, 'CREATE (n) RETURN n', 'rw')
   }
 
+  /**
+   * @param {ServerVersion} version
+   * @param {RxSession} session
+   * @param {boolean} useTransaction
+   */
+  async function shouldReturnSummaryWithSystemUpdates (
+    version,
+    session,
+    useTransaction = false
+  ) {
+    if (version.compareTo(VERSION_4_0_0) < 0) {
+      return
+    }
+
+    let runnable = session
+    if (useTransaction) {
+      runnable = await session.beginTransaction().toPromise()
+    }
+
+    try {
+      await verifySystemUpdates(
+        runnable,
+        "CREATE USER foo SET PASSWORD 'bar'",
+        {},
+        1
+      )
+    } finally {
+      await verifySystemUpdates(runnable, 'DROP USER foo', {}, 1)
+    }
+  }
+
   /**
    * @param {ServerVersion} version
    * @param {RxSession|RxTransaction} runnable
@@ -281,7 +349,7 @@ describe('#integration-rx summary', () => {
       return
     }
 
-    await verifyCounters(
+    await verifyUpdates(
       runnable,
       'CREATE (n:Label1 {id: $id1})-[:KNOWS]->(m:Label2 {id: $id2}) RETURN n, m',
       { id1: 10, id2: 20 },
@@ -316,7 +384,7 @@ describe('#integration-rx summary', () => {
     // first create the to-be-deleted nodes
     await shouldReturnSummaryWithUpdateStatisticsForCreate(version, runnable)
 
-    await verifyCounters(
+    await verifyUpdates(
       runnable,
       'MATCH (n:Label1)-[r:KNOWS]->(m:Label2) DELETE n, r',
       null,
@@ -348,7 +416,7 @@ describe('#integration-rx summary', () => {
       return
     }
 
-    await verifyCounters(runnable, 'CREATE INDEX on :Label(prop)', null, {
+    await verifyUpdates(runnable, 'CREATE INDEX on :Label(prop)', null, {
       nodesCreated: 0,
       nodesDeleted: 0,
       relationshipsCreated: 0,
@@ -384,7 +452,7 @@ describe('#integration-rx summary', () => {
       await session.close()
     }
 
-    await verifyCounters(runnable, 'DROP INDEX on :Label(prop)', null, {
+    await verifyUpdates(runnable, 'DROP INDEX on :Label(prop)', null, {
       nodesCreated: 0,
       nodesDeleted: 0,
       relationshipsCreated: 0,
@@ -411,7 +479,7 @@ describe('#integration-rx summary', () => {
       return
     }
 
-    await verifyCounters(
+    await verifyUpdates(
       runnable,
       'CREATE CONSTRAINT ON (book:Book) ASSERT book.isbn IS UNIQUE',
       null,
@@ -454,7 +522,7 @@ describe('#integration-rx summary', () => {
       await session.close()
     }
 
-    await verifyCounters(
+    await verifyUpdates(
       runnable,
       'DROP CONSTRAINT ON (book:Book) ASSERT book.isbn IS UNIQUE',
       null,
@@ -628,27 +696,42 @@ describe('#integration-rx summary', () => {
    * @param {RxSession|RxTransaction} runnable
    * @param {string} statement
    * @param {*} parameters
-   * @param {*} counters
+   * @param {*} stats
+   */
+  async function verifyUpdates (runnable, statement, parameters, stats) {
+    const summary = await runnable
+      .run(statement, parameters)
+      .summary()
+      .toPromise()
+    expect(summary).toBeDefined()
+    expect(summary.counters.containsUpdates()).toBeTruthy()
+    expect(summary.counters.updates()).toEqual(stats)
+    expect(summary.counters.containsSystemUpdates()).toBeFalsy()
+  }
+
+  /**
+   *
+   * @param {RxSession|RxTransaction} runnable
+   * @param {string} statement
+   * @param {*} parameters
+   * @param {number} systemUpdates
+   * @returns {Promise<void>}
    */
-  async function verifyCounters (runnable, statement, parameters, counters) {
+  async function verifySystemUpdates (
+    runnable,
+    statement,
+    parameters,
+    systemUpdates
+  ) {
     const summary = await runnable
       .run(statement, parameters)
       .summary()
       .toPromise()
     expect(summary).toBeDefined()
-    expect({
-      nodesCreated: summary.counters.nodesCreated(),
-      nodesDeleted: summary.counters.nodesDeleted(),
-      relationshipsCreated: summary.counters.relationshipsCreated(),
-      relationshipsDeleted: summary.counters.relationshipsDeleted(),
-      propertiesSet: summary.counters.propertiesSet(),
-      labelsAdded: summary.counters.labelsAdded(),
-      labelsRemoved: summary.counters.labelsRemoved(),
-      indexesAdded: summary.counters.indexesAdded(),
-      indexesRemoved: summary.counters.indexesRemoved(),
-      constraintsAdded: summary.counters.constraintsAdded(),
-      constraintsRemoved: summary.counters.constraintsRemoved()
-    }).toEqual(counters)
+
+    expect(summary.counters.containsSystemUpdates()).toBeTruthy()
+    expect(summary.counters.systemUpdates()).toBe(systemUpdates)
+    expect(summary.counters.containsUpdates()).toBeFalsy()
   }
 
   async function dropConstraintsAndIndices (driver) {

test/summary.test.js

@@ -107,18 +107,20 @@ describe('#integration result summary', () => {
       expect(summary.resultConsumedAfter).toBeDefined()
       expect(summary.resultAvailableAfter).toBeDefined()
 
-      const counters = summary.counters
-      expect(counters.nodesCreated()).toBe(1)
-      expect(counters.nodesDeleted()).toBe(0)
-      expect(counters.relationshipsCreated()).toBe(0)
-      expect(counters.relationshipsDeleted()).toBe(0)
-      expect(counters.propertiesSet()).toBe(1)
-      expect(counters.labelsAdded()).toBe(1)
-      expect(counters.labelsRemoved()).toBe(0)
-      expect(counters.indexesAdded()).toBe(0)
-      expect(counters.indexesRemoved()).toBe(0)
-      expect(counters.constraintsAdded()).toBe(0)
-      expect(counters.constraintsRemoved()).toBe(0)
+      expect(summary.counters.containsUpdates()).toBe(true)
+      const stats = summary.counters.updates()
+      expect(stats.nodesCreated).toBe(1)
+      expect(stats.nodesDeleted).toBe(0)
+      expect(stats.relationshipsCreated).toBe(0)
+      expect(stats.relationshipsDeleted).toBe(0)
+      expect(stats.propertiesSet).toBe(1)
+      expect(stats.labelsAdded).toBe(1)
+      expect(stats.labelsRemoved).toBe(0)
+      expect(stats.indexesAdded).toBe(0)
+      expect(stats.indexesRemoved).toBe(0)
+      expect(stats.constraintsAdded).toBe(0)
+      expect(stats.constraintsRemoved).toBe(0)
+      expect(summary.counters.containsSystemUpdates()).toBe(false)
       done()
     })
   }

test/types/result-summary.test.ts

@@ -40,17 +40,9 @@ const str: string = sum1.statementType
 const counters: StatementStatistic = sum1.counters
 
 const containsUpdates: boolean = counters.containsUpdates()
-const nodesCreated: number = counters.nodesCreated()
-const nodesDeleted: number = counters.nodesDeleted()
-const relationshipsCreated: number = counters.relationshipsCreated()
-const relationshipsDeleted: number = counters.relationshipsDeleted()
-const propertiesSet: number = counters.propertiesSet()
-const labelsAdded: number = counters.labelsAdded()
-const labelsRemoved: number = counters.labelsRemoved()
-const indexesAdded: number = counters.indexesAdded()
-const indexesRemoved: number = counters.indexesRemoved()
-const constraintsAdded: number = counters.constraintsAdded()
-const constraintsRemoved: number = counters.constraintsRemoved()
+const containsSystemUpdates: boolean = counters.containsSystemUpdates()
+const systemUpdates: number = counters.systemUpdates()
+const updates: { [key: string]: number } = counters.updates()
 
 const plan: Plan = sum1.plan
 const planOperatorType: string = plan.operatorType

types/result-summary.d.ts

@@ -55,27 +55,11 @@ declare interface ProfiledPlan {
 declare interface StatementStatistic {
   containsUpdates(): boolean
 
-  nodesCreated(): number
+  containsSystemUpdates(): boolean
 
-  nodesDeleted(): number
+  updates(): { [key: string]: number }
 
-  relationshipsCreated(): number
-
-  relationshipsDeleted(): number
-
-  propertiesSet(): number
-
-  labelsAdded(): number
-
-  labelsRemoved(): number
-
-  indexesAdded(): number
-
-  indexesRemoved(): number
-
-  constraintsAdded(): number
-
-  constraintsRemoved(): number
+  systemUpdates(): number
 }
 
 declare type NotificationPosition = {