haveyaseen · Jun 6, 2018 · Jan 23, 2018 · Jan 23, 2018 · Feb 1, 2018 · Feb 1, 2018
diff --git a/src/Model.js b/src/Model.js
@@ -124,8 +124,12 @@ const Model = class Model {
         return this.session.getDataForModel(this.modelName);
     }
 
-    static markAccessed() {
-        this.session.markAccessed(this);
+    static markAccessed(ids) {
+        this.session.markAccessed(this.modelName, ids);
+    }
+
+    static markFullTableScanned() {
+        this.session.markFullTableScanned(this.modelName);
     }
 
     /**

diff --git a/src/Session.js b/src/Session.js
@@ -1,7 +1,7 @@
 import { getBatchToken } from 'immutable-ops';
 
-import { SUCCESS } from './constants';
-import { warnDeprecated } from './utils';
+import { SUCCESS, UPDATE, DELETE } from './constants';
+import { warnDeprecated, clauseFiltersByAttribute } from './utils';
 
 const Session = class Session {
     /**
@@ -22,7 +22,6 @@ const Session = class Session {
         this.withMutations = !!withMutations;
         this.batchToken = batchToken || getBatchToken();
 
-        this._accessedModels = {};
         this.modelData = {};
 
         this.models = schema.getModelClasses();
@@ -38,23 +37,46 @@ const Session = class Session {
         });
     }
 
-    markAccessed(modelName) {
-        this.getDataForModel(modelName).accessed = true;
-    }
-
-    get accessedModels() {
-        return this.sessionBoundModels
-            .filter(model => !!this.getDataForModel(model.modelName).accessed)
-            .map(model => model.modelName);
-    }
-
     getDataForModel(modelName) {
         if (!this.modelData[modelName]) {
             this.modelData[modelName] = {};
         }
         return this.modelData[modelName];
     }
 
+    markAccessed(modelName, modelIds = []) {
+        const data = this.getDataForModel(modelName);
+        if (!data.accessedInstances) {
+            data.accessedInstances = {};
+        }
+        modelIds.forEach((id) => {
+            data.accessedInstances[id] = true;
+        });
+    }
+
+    get accessedModelInstances() {
+        return this.sessionBoundModels
+            .filter(({ modelName }) => !!this.getDataForModel(modelName).accessedInstances)
+            .reduce(
+                (result, { modelName }) => ({
+                    ...result,
+                    [modelName]: this.getDataForModel(modelName).accessedInstances,
+                }),
+                {}
+            );
+    }
+
+    markFullTableScanned(modelName) {
+        const data = this.getDataForModel(modelName);
+        data.fullTableScanned = true;
+    }
+
+    get fullTableScannedModels() {
+        return this.sessionBoundModels
+            .filter(({ modelName }) => !!this.getDataForModel(modelName).fullTableScanned)
+            .map(({ modelName }) => modelName);
+    }
+
     /**
      * Applies update to a model state.
      *
@@ -63,24 +85,73 @@ const Session = class Session {
      *                          `type`, `payload`.
      */
     applyUpdate(updateSpec) {
-        const { batchToken, withMutations } = this;
-        const tx = { batchToken, withMutations };
+        const tx = this._getTransaction(updateSpec);
         const result = this.db.update(updateSpec, tx, this.state);
-        const { status, state } = result;
+        const { status, state, payload } = result;
 
-        if (status === SUCCESS) {
-            this.state = state;
-        } else {
+        if (status !== SUCCESS) {
             throw new Error(`Applying update failed: ${result.toString()}`);
         }
 
-        return result.payload;
+        this.state = state;
+
+        return payload;
     }
 
     query(querySpec) {
-        const { table } = querySpec;
-        this.markAccessed(table);
-        return this.db.query(querySpec, this.state);
+        const result = this.db.query(querySpec, this.state);
+
+        this._markAccessedByQuery(querySpec, result);
+
+        return result;
+    }
+
+    _getTransaction(updateSpec) {
+        const { withMutations } = this;
+        const { action } = updateSpec;
+        let batchToken = this.batchToken;
+        if ([UPDATE, DELETE].includes(action)) {
+            batchToken = getBatchToken();
+        }
+        return { batchToken, withMutations };
+    }
+
+    _markAccessedByQuery(querySpec, result) {
+        const { table, clauses } = querySpec;
+        const { rows } = result;
+
+        const idAttribute = this[table].idAttribute;
+        const accessedIds = new Set(rows.map(
+            row => row[idAttribute]
+        ));
+
+        const anyClauseFilteredById = clauses.some((clause) => {
+            if (!clauseFiltersByAttribute(clause, idAttribute)) {
+                return false;
+            }
+            /**
+             * we previously knew which row we wanted to access,
+             * so there was no need to scan the entire table
+             */
+            const id = clause.payload[idAttribute];
+            accessedIds.add(id);
+            return true;
+        });
+
+        if (anyClauseFilteredById) {
+            /**
+             * clauses have been ordered so that an indexed one was
+             * the first to be evaluated, and thus only the row
+             * with the specified id has actually been accessed
+             */
+            this.markAccessed(table, accessedIds);
+        } else {
+            /**
+             * any other clause would have caused a full table scan,
+             * even if we specified an empty clauses array
+             */
+            this.markFullTableScanned(table);
+        }
     }
 
     // DEPRECATED AND REMOVED METHODS

diff --git a/src/db/Database.js b/src/db/Database.js
@@ -50,8 +50,12 @@ function update(tables, updateSpec, tx, state) {
 
         if (action === UPDATE) {
             nextTableState = table.update(tx, currTableState, rows, payload);
+            // return updated rows
+            resultPayload = query(tables, querySpec, state).rows;
         } else if (action === DELETE) {
             nextTableState = table.delete(tx, currTableState, rows);
+            // return original rows that we just deleted
+            resultPayload = rows;
         } else {
             throw new Error(`Database received unknown update type: ${action}`);
         }

diff --git a/src/db/Table.js b/src/db/Table.js
@@ -5,7 +5,7 @@ import sortBy from 'lodash/sortBy';
 import ops from 'immutable-ops';
 
 import { FILTER, EXCLUDE, ORDER_BY } from '../constants';
-import { includes } from '../utils';
+import { includes, clauseFiltersByAttribute, clauseReducesResultSetSize } from '../utils';
 
 
 const DEFAULT_OPTS = {
@@ -105,31 +105,30 @@ const Table = class Table {
             return this.accessList(branch);
         }
 
+        const { idAttribute } = this;
+
         const optimallyOrderedClauses = sortBy(clauses, (clause) => {
-            if (this._willClauseUseIndexedAttribute(clause)) {
+            if (clauseFiltersByAttribute(clause, idAttribute)) {
                 return 1;
             }
 
-            if (this._willClauseReduceResultSetSize(clause)) {
+            if (clauseReducesResultSetSize(clause)) {
                 return 2;
             }
 
             return 3;
         });
 
-        const { idAttribute } = this;
         const reducer = (rows, clause) => {
             const { type, payload } = clause;
             if (!rows) {
-                if (type === FILTER && payload.hasOwnProperty(idAttribute)) {
+                if (clauseFiltersByAttribute(clause, idAttribute)) {
                     const id = payload[idAttribute];
-                    if (id !== null && id !== undefined) {
-                        // Payload specified a primary key; Since that is
-                        // unique, we can directly return that.
-                        return this.idExists(branch, id)
-                            ? [this.accessId(branch, id)]
-                            : [];
-                    }
+                    // Payload specified a primary key; Since that is
+                    // unique, we can directly return that.
+                    return this.idExists(branch, id)
+                        ? [this.accessId(branch, id)]
+                        : [];
                 }
 
                 return reducer(this.accessList(branch), clause);
@@ -154,15 +153,6 @@ const Table = class Table {
         return optimallyOrderedClauses.reduce(reducer, undefined);
     }
 
-    _willClauseUseIndexedAttribute(clause) {
-        return clause.type === FILTER &&
-          clause.payload.hasOwnProperty(this.idAttribute);
-    }
-
-    _willClauseReduceResultSetSize({ type }) {
-        return type === FILTER || type === EXCLUDE;
-    }
-
     /**
      * Returns the default state for the data structure.
      * @return {Object} The default state for this {@link Backend} instance's data structure