persistence-rails 0.0.1

data/vendor/assets/javascript/persistence.pool.js

@@ -0,0 +1,47 @@
+//= require persistence.core
+
+var sys = require('sys');
+var mysql = require('mysql');
+
+function log(o) {
+  sys.print(sys.inspect(o) + "\n");
+}
+
+function ConnectionPool(getSession, initialPoolSize) {
+  this.newConnection = getSession;
+  this.pool = [];
+  for(var i = 0; i < initialPoolSize; i++) {
+    this.pool.push({available: true, session: getSession()});
+  }
+}
+
+ConnectionPool.prototype.obtain = function() {
+  var session = null;
+  for(var i = 0; i < this.pool.length; i++) {
+    if(this.pool[i].available) {
+      var pool = this.pool[i];
+      session = pool.session;
+      pool.available = false;
+      pool.claimed = new Date();
+      break;
+    }
+  }
+  if(!session) {
+    session = getSession();
+    this.pool.push({available: false, session: session, claimed: new Date() });
+  }
+};
+
+ConnectionPool.prototype.release = function(session) {
+  for(var i = 0; i < this.pool.length; i++) {
+    if(this.pool[i].session === session) {
+      var pool = this.pool[i];
+      pool.available = true;
+      pool.claimed = null;
+      return;
+    }
+  }
+  return false;
+};
+
+exports.ConnectionPool = ConnectionPool;

data/vendor/assets/javascript/persistence.search.js

@@ -0,0 +1,293 @@
+//= require persistence.core
+
+/**
+ * @license
+ * Copyright (c) 2010 Zef Hemel <zef@zef.me>
+ * 
+ * Permission is hereby granted, free of charge, to any person
+ * obtaining a copy of this software and associated documentation
+ * files (the "Software"), to deal in the Software without
+ * restriction, including without limitation the rights to use,
+ * copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following
+ * conditions:
+ * 
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ * 
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+ * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+ * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+ * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+ * OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+try {
+  if(!window) {
+    window = {};
+  }
+} catch(e) {
+  window = {};
+  exports.console = console;
+}
+
+var persistence = (window && window.persistence) ? window.persistence : {}; 
+
+persistence.search = {};
+
+persistence.search.config = function(persistence, dialect) {
+  var filteredWords = {'and':true, 'the': true, 'are': true};
+
+  var argspec = persistence.argspec;
+
+  function normalizeWord(word, filterShortWords) {
+    if(!(word in filteredWords || (filterShortWords && word.length < 3))) {
+      word = word.replace(/ies$/, 'y');
+      word = word.length > 3 ? word.replace(/s$/, '') : word;
+      return word;
+    } else {
+      return false;
+    }
+  }
+
+  /**
+   * Does extremely basic tokenizing of text. Also includes some basic stemming.
+   */
+  function searchTokenizer(text) {
+    var words = text.toLowerCase().split(/[^\w\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF]+/);
+    var wordDict = {};
+    // Prefixing words with _ to also index Javascript keywords and special fiels like 'constructor'
+    for(var i = 0; i < words.length; i++) {
+      var normalizedWord = normalizeWord(words[i]);
+      if(normalizedWord) {
+        var word = '_' + normalizedWord;
+        // Some extremely basic stemming
+        if(word in wordDict) {
+          wordDict[word]++;
+        } else {
+          wordDict[word] = 1;
+        }
+      }
+    }
+    return wordDict;
+  }
+
+  /**
+   * Parses a search query and returns it as list SQL parts later to be OR'ed or AND'ed.
+   */
+  function searchPhraseParser(query, indexTbl, prefixByDefault) {
+    query = query.toLowerCase().replace(/['"]/, '').replace(/(^\s+|\s+$)/g, '');
+    var words = query.split(/\s+/);
+    var sqlParts = [];
+    var restrictedToColumn = null;
+    for(var i = 0; i < words.length; i++) {
+      var word = normalizeWord(words[i]);
+      if(!word) {
+        continue;
+      }
+      if(word.search(/:$/) !== -1) {
+        restrictedToColumn = word.substring(0, word.length-1);
+        continue;
+      } 
+      var sql = '(';
+      if(word.search(/\*/) !== -1) {
+        sql += "`" + indexTbl + "`.`word` LIKE '" + word.replace(/\*/g, '%') + "'";
+      } else if(prefixByDefault) {
+        sql += "`" + indexTbl + "`.`word` LIKE '" + word + "%'";
+      } else {
+        sql += "`" + indexTbl + "`.`word` = '" + word + "'";
+      }
+      if(restrictedToColumn) {
+        sql += ' AND `' + indexTbl + "`.`prop` = '" + restrictedToColumn + "'";
+      }
+      sql += ')';
+      sqlParts.push(sql);
+    }
+    return sqlParts.length === 0 ? ["1=1"] : sqlParts;
+  }
+
+  var queryCollSubscribers = {}; // entityName -> subscription obj
+  persistence.searchQueryCollSubscribers = queryCollSubscribers;
+
+  function SearchFilter(query, entityName) {
+    this.query = query;
+    this.entityName = entityName;
+  }
+
+  SearchFilter.prototype.match = function (o) {
+    var meta = persistence.getMeta(this.entityName);
+    var query = this.query.toLowerCase();
+    var text = '';
+    for(var p in o) {
+      if(meta.textIndex.hasOwnProperty(p)) {
+        if(o[p]) {
+          text += o[p];
+        }
+      }
+    }
+    text = text.toLowerCase();
+    return text && text.indexOf(query) !== -1;
+  }
+
+  SearchFilter.prototype.sql = function (o) {
+    return "1=1";
+  }
+
+  SearchFilter.prototype.subscribeGlobally = function(coll, entityName) {
+    var meta = persistence.getMeta(entityName);
+    for(var p in meta.textIndex) {
+      if(meta.textIndex.hasOwnProperty(p)) {
+        persistence.subscribeToGlobalPropertyListener(coll, entityName, p);
+      }
+    }
+  };
+
+  SearchFilter.prototype.unsubscribeGlobally = function(coll, entityName) {
+    var meta = persistence.getMeta(entityName);
+    for(var p in meta.textIndex) {
+      if(meta.textIndex.hasOwnProperty(p)) {
+        persistence.unsubscribeFromGlobalPropertyListener(coll, entityName, p);
+      }
+    }
+  };
+
+  SearchFilter.prototype.toUniqueString = function() {
+    return "SEARCH: " + this.query;
+  }
+
+  function SearchQueryCollection(session, entityName, query, prefixByDefault) {
+    this.init(session, entityName, SearchQueryCollection);
+    this.subscribers = queryCollSubscribers[entityName];
+    this._filter = new SearchFilter(query, entityName);
+
+
+    if(query) {
+      this._additionalJoinSqls.push(', `' + entityName + '_Index`');
+      this._additionalWhereSqls.push('`root`.id = `' + entityName + '_Index`.`entityId`');
+      this._additionalWhereSqls.push('(' + searchPhraseParser(query, entityName + '_Index', prefixByDefault).join(' OR ') + ')');
+      this._additionalGroupSqls.push(' GROUP BY (`' + entityName + '_Index`.`entityId`)');
+      this._additionalGroupSqls.push(' ORDER BY SUM(`' + entityName + '_Index`.`occurrences`) DESC');
+    }
+  }
+
+  SearchQueryCollection.prototype = new persistence.DbQueryCollection();
+
+  SearchQueryCollection.prototype.oldClone = SearchQueryCollection.prototype.clone;
+
+
+  SearchQueryCollection.prototype.clone = function() {
+    var clone = this.oldClone(false);
+    var entityName = this._entityName;
+    clone.subscribers = queryCollSubscribers[entityName];
+    return clone;
+  };
+
+  SearchQueryCollection.prototype.order = function() {
+    throw new Error("Imposing additional orderings is not support for search query collections.");
+  };
+
+  /*
+  SearchQueryCollection.prototype.filter = function (property, operator, value) {
+    var c = this.clone();
+    c._filter = new persistence.AndFilter(this._filter, new persistence.PropertyFilter(property, operator, value));
+    // Add global listener (TODO: memory leak waiting to happen!)
+    //session.subscribeToGlobalPropertyListener(c, this._entityName, property);
+    return c;
+  };
+  */
+
+  persistence.entityDecoratorHooks.push(function(Entity) {
+      /**
+       * Declares a property to be full-text indexed.
+       */
+      Entity.textIndex = function(prop) {
+        if(!Entity.meta.textIndex) {
+          Entity.meta.textIndex = {};
+        }
+        Entity.meta.textIndex[prop] = true;
+        // Subscribe
+        var entityName = Entity.meta.name;
+        if(!queryCollSubscribers[entityName]) {
+          queryCollSubscribers[entityName] = {};
+        }
+      };
+
+      /**
+       * Returns a query collection representing the result of a search
+       * @param query an object with the following fields:
+       */
+      Entity.search = function(session, query, prefixByDefault) {
+        var args = argspec.getArgs(arguments, [
+            { name: 'session', optional: true, check: function(obj) { return obj.schemaSync; }, defaultValue: persistence },
+            { name: 'query', optional: false, check: argspec.hasType('string') },
+            { name: 'prefixByDefault', optional: false }
+          ]);
+        session = args.session;
+        query = args.query;
+        prefixByDefault = args.prefixByDefault;
+
+        return session.uniqueQueryCollection(new SearchQueryCollection(session, Entity.meta.name, query, prefixByDefault));
+      };
+    });
+
+  persistence.schemaSyncHooks.push(function(tx) {
+      var entityMeta = persistence.getEntityMeta();
+      var queries = [];
+      for(var entityName in entityMeta) {
+        var meta = entityMeta[entityName];
+        if(meta.textIndex) {
+          queries.push([dialect.createTable(entityName + '_Index', [['entityId', 'VARCHAR(32)'], ['prop', 'VARCHAR(30)'], ['word', 'VARCHAR(100)'], ['occurrences', 'INT']]), null]);
+          queries.push([dialect.createIndex(entityName + '_Index', ['prop', 'word']), null]);
+          queries.push([dialect.createIndex(entityName + '_Index', ['word']), null]);
+          persistence.generatedTables[entityName + '_Index'] = true;
+        }
+      }
+      queries.reverse();
+      persistence.executeQueriesSeq(tx, queries);
+    });
+
+
+  persistence.flushHooks.push(function(session, tx, callback) {
+      var queries = [];
+      for (var id in session.getTrackedObjects()) {
+        if (session.getTrackedObjects().hasOwnProperty(id)) {
+          var obj = session.getTrackedObjects()[id];
+          var meta = session.define(obj._type).meta;
+          var indexTbl = obj._type + '_Index';
+          if(meta.textIndex) {
+            for ( var p in obj._dirtyProperties) {
+              if (obj._dirtyProperties.hasOwnProperty(p) && p in meta.textIndex) {
+                queries.push(['DELETE FROM `' + indexTbl + '` WHERE `entityId` = ? AND `prop` = ?', [id, p]]);
+                var occurrences = searchTokenizer(obj._data[p]);
+                for(var word in occurrences) {
+                  if(occurrences.hasOwnProperty(word)) {
+                    queries.push(['INSERT INTO `' + indexTbl + '` VALUES (?, ?, ?, ?)', [obj.id, p, word.substring(1), occurrences[word]]]);
+                  }
+                }
+              }
+            }
+          }
+        }
+      }
+      for (var id in persistence.getObjectsToRemove()) {
+        if (persistence.getObjectsToRemove().hasOwnProperty(id)) {
+          var obj = persistence.getObjectsToRemove()[id];
+          var meta = persistence.getEntityMeta()[obj._type];
+          if(meta.textIndex) {
+            queries.push(['DELETE FROM `' + obj._type + '_Index` WHERE `entityId` = ?', [id]]);
+          }
+        }
+      }
+      queries.reverse();
+      persistence.executeQueriesSeq(tx, queries, callback);
+    });
+};
+
+if(typeof exports === 'object') {
+  exports.config = persistence.search.config;
+}
+

data/vendor/assets/javascript/persistence.store.appengine.js

@@ -0,0 +1,412 @@
+//= require persistence.core
+
+var jdatastore = Packages.com.google.appengine.api.datastore,
+    JDatastoreServiceFactory = jdatastore.DatastoreServiceFactory,
+    JKeyFactory = jdatastore.KeyFactory,
+    JDatastoreService = jdatastore.DatastoreService,
+    JFilterOperator = jdatastore.Query.FilterOperator,
+    JSortDirection = jdatastore.Query.SortDirection,
+    JQuery = jdatastore.Query,
+    JInteger = java.lang.Integer;
+
+exports.config = function(persistence) {
+  var argspec = persistence.argspec;
+
+  exports.getSession = function() {
+    var session = new persistence.Session();
+    session.dsService = JDatastoreServiceFactory.getDatastoreService();
+    session.transaction = function (fn) {
+      fn({executeSql: function() {}});
+    };
+
+    session.close = function() { };
+    return session;
+  };
+
+  /**
+   * Converts a value from the data store to a value suitable for the entity
+   * (also does type conversions, if necessary)
+   */
+  function dbValToEntityVal(val, type) {
+    if (val === null || val === undefined) {
+      return val;
+    }
+    switch (type) {
+    case 'DATE':
+      // SQL is in seconds and JS in miliseconds
+        if (val > 1000000000000) {
+          // usually in seconds, but sometimes it's milliseconds
+          return new Date(parseInt(val, 10));
+        } else {
+          return new Date(parseInt(val, 10) * 1000);
+        }
+    case 'BOOL':
+      return val === 1 || val === '1';
+      break;
+    case 'INT':
+      return +val;
+      break;
+    case 'BIGINT':
+      return +val;
+      break;
+    case 'JSON':
+      if (val) {
+        return JSON.parse(val);
+      }
+      else {
+        return val;
+      }
+      break;
+    default:
+      return val;
+    }
+  }
+
+  /**
+   * Converts an entity value to a data store value, inverse of
+   *   dbValToEntityVal
+   */
+  function entityValToDbVal(val, type) {
+    if (val === undefined || val === null) {
+      return null;
+    } else if (type === 'JSON' && val) {
+      return JSON.stringify(val);
+    } else if (val.id) {
+      return val.id;
+    } else if (type === 'BOOL') {
+      return (val === 'false') ? 0 : (val ? 1 : 0);
+    } else if (type === 'DATE' || val.getTime) {
+      val = new Date(val);
+      return new JInteger(Math.round(val.getTime() / 1000));
+    } else {
+      return val;
+    }
+  }
+
+  /**
+   * Converts a data store entity to an entity object
+   */
+  function aeEntityToEntity(session, aeEnt, Entity) {
+    if(!aeEnt) return null;
+
+    var o = new Entity(session);
+    var meta = Entity.meta;
+    o.id = aeEnt.key.name;
+    var propMap = aeEnt.properties;
+    for(var prop in Iterator(propMap.keySet())) {
+      persistence.set(o, prop, dbValToEntityVal(propMap.get(prop), meta.fields[prop]));
+    }
+    return o;
+  }
+
+  /**
+   * Converts a data store entity to an entity object
+   */
+  function entityToAEEntity(meta, o) {
+    var ent = new jdatastore.Entity(o._type, o.id);
+    for(var k in meta.fields) {
+      if(meta.fields.hasOwnProperty(k)) {
+        ent.setProperty(k, entityValToDbVal(o._data[k], meta.fields[k]));
+      }
+    }
+    for(var k in meta.hasOne) {
+      if(meta.hasOne.hasOwnProperty(k)) {
+        ent.setProperty(k, entityValToDbVal(o._data[k], meta.fields[k]));
+      }
+    }
+    return ent;
+  }
+
+  var allEntities = [];
+
+  persistence.schemaSync = function (tx, callback, emulate) {
+    var args = argspec.getArgs(arguments, [
+        { name: "tx", optional: true, check: persistence.isTransaction, defaultValue: null },
+        { name: "callback", optional: true, check: argspec.isCallback(), defaultValue: function(){} },
+        { name: "emulate", optional: true, check: argspec.hasType('boolean') }
+      ]);
+    tx = args.tx;
+    callback = args.callback;
+
+    var entityMeta = persistence.getEntityMeta();
+    for (var entityName in entityMeta) {
+      if (entityMeta.hasOwnProperty(entityName)) {
+        allEntities.push(persistence.define(entityName));
+      }
+    }
+
+    callback();
+  };
+
+  persistence.flush = function (tx, callback) {
+    var args = argspec.getArgs(arguments, [
+        { name: "tx", optional: true, check: persistence.isTransaction },
+        { name: "callback", optional: true, check: argspec.isCallback(), defaultValue: null }
+      ]);
+    tx = args.tx;
+    callback = args.callback;
+
+    var session = this;
+    var fns = persistence.flushHooks;
+    persistence.asyncForEach(fns, function(fn, callback) {
+        fn(session, tx, callback);
+      }, function() {
+        // After applying the hooks
+        var entitiesToPersist = [];
+        var removeArrayList = new java.util.ArrayList();
+
+        for (var id in session.trackedObjects) {
+          if (session.trackedObjects.hasOwnProperty(id)) {
+            var ent = prepareDbEntity(session.trackedObjects[id]);
+            if(ent) {
+              entitiesToPersist.push(ent);
+            }
+          }
+        }
+        for (var id in session.objectsToRemove) {
+          if (session.objectsToRemove.hasOwnProperty(id)) {
+            removeArrayList.add(JKeyFactory.createKey(session.trackedObjects[id]._type, id));
+            delete session.trackedObjects[id]; // Stop tracking
+          }
+        }
+        if(entitiesToPersist.length > 0) {
+          session.dsService.put(entitiesToPersist);
+        }
+        if(removeArrayList.size() > 0) {
+          session.dsService['delete'](removeArrayList);
+        }
+        callback();
+      });
+  };
+  
+  persistence.reset = function (tx, callback) {
+    var args = argspec.getArgs(arguments, [
+        { name: "tx", optional: true, check: persistence.isTransaction, defaultValue: null },
+        { name: "callback", optional: true, check: argspec.isCallback(), defaultValue: function(){} }
+      ]);
+    callback = args.callback;
+
+    var session = this;
+
+    persistence.asyncParForEach(allEntities, function(Entity, callback) {
+        Entity.all(session).destroyAll(callback);
+      }, callback);
+  };
+
+  /**
+   * Internal function to persist an object to the database
+   * this function is invoked by persistence.flush()
+   */
+  function prepareDbEntity(obj) {
+    var meta = persistence.getMeta(obj._type);
+    var isDirty = obj._new;
+    if(Object.keys(obj._dirtyProperties).length > 0) {
+      isDirty = true;
+    }
+    if(isDirty) {
+      return entityToAEEntity(meta, obj);
+    } else {
+      return null; // no saving required
+    }
+  }
+
+  /////////////////////////// QueryCollection patches to work in AppEngine environment
+
+  persistence.NullFilter.prototype.addFilter = function (meta, query) {
+  };
+
+  persistence.AndFilter.prototype.addFilter = function (meta, query) {
+    this.left.addFilter(meta, query);
+    this.right.addFilter(meta, query);
+  };
+
+  persistence.OrFilter.prototype.addFilter = function (meta, query) {
+    throw new Error("OrFilter Not supported");
+  };
+
+  persistence.PropertyFilter.prototype.addFilter = function (meta, query) {
+    var filterOp;
+    var value = this.value;
+    switch(this.operator) {
+    case '=':
+      filterOp = JFilterOperator.EQUAL;
+      break;
+    case '!=':
+      filterOp = JFilterOperator.NOT_EQUAL;
+      break;
+    case '>':
+      filterOp = JFilterOperator.GREATER_THAN;
+      break;
+    case '>=':
+      filterOp = JFilterOperator.GREATER_THAN_OR_EQUAL;
+      break;
+    case '<':
+      filterOp = JFilterOperator.LESS_THAN;
+      break;
+    case '<=':
+      filterOp = JFilterOperator.LESS_THAN_OR_EQUAL;
+      break;
+    case 'in':
+      var values = new java.util.ArrayList();
+      var type = meta.fields[this.property];
+      for(var i = 0; i < value.length; i++) {
+        values.add(entityValToDbVal(value[i], type));
+      }
+      value = values;
+      filterOp = JFilterOperator.IN;
+      break;
+    };
+    query.addFilter(this.property, filterOp, entityValToDbVal(value, meta.fields[this.property]));
+  };
+
+
+  function prepareQuery(coll, callback) {
+    var session = coll._session;
+    var entityName = coll._entityName;
+    var meta = persistence.getMeta(entityName);
+    
+    // handles mixin case -- this logic is generic and could be in persistence.
+    if (meta.isMixin) {
+      var result = [];
+      persistence.asyncForEach(meta.mixedIns, function(realMeta, next) {
+        var query = coll.clone();
+        query._entityName = realMeta.name;
+        query.list(tx, function(array) {
+          result = result.concat(array);
+          next();
+        });
+      }, function() {
+        var query = new persistence.LocalQueryCollection(result);
+        query._orderColumns = coll._orderColumns;
+        query._reverse = coll._reverse;
+        // TODO: handle skip and limit -- do we really want to do it?
+        query.list(null, callback);
+      });
+      return;
+    }    
+
+    var query = new JQuery(entityName); // Not tbe confused with jQuery
+    coll._filter.addFilter(meta, query);
+
+    coll._orderColumns.forEach(function(col) {
+        query.addSort(col[0], col[1] ? JSortDirection.ASCENDING : JSortDirection.DESCENDING);
+      });
+
+    callback(session.dsService.prepare(query));
+  }
+
+
+  /**
+   * Asynchronous call to actually fetch the items in the collection
+   * @param tx transaction to use
+   * @param callback function to be called taking an array with 
+   *   result objects as argument
+   */
+  persistence.DbQueryCollection.prototype.list = function (tx, callback) {
+    var args = argspec.getArgs(arguments, [
+        { name: 'tx', optional: true, check: persistence.isTransaction, defaultValue: null },
+        { name: 'callback', optional: false, check: argspec.isCallback() }
+      ]);
+    callback = args.callback;
+    var that = this;
+    var entityName = this._entityName;
+    var session = this._session;
+
+    // TODO: Check if filtering for 'id' property, then use key lookup
+    //
+    if(this._filter.right && this._filter.right.property && this._filter.right.property === 'id') {
+      var idToLoad = this._filter.right.value;
+      var obj;
+      try {
+        obj = session.dsService.get(JKeyFactory.createKey(entityName, idToLoad));
+      } catch(e) { // com.google.appengine.api.datastore.EntityNotFoundException
+        obj = null;
+      }
+      if(obj) {
+        callback([aeEntityToEntity(session, obj, persistence.define(entityName))]);
+      } else {
+        callback([]);
+      }
+    } else {
+      session.flush(function() {
+          prepareQuery(that, function(preparedQuery) {
+              if(that._limit === 1) {
+                var row = preparedQuery.asSingleEntity();
+                var e = aeEntityToEntity(session, row, persistence.define(entityName));
+                callback([e]);
+              } else {
+                var rows = preparedQuery.asList(jdatastore.FetchOptions.Builder.withLimit(that._limit === -1 ? 1000 : that._limit).offset(that._skip));
+                var results = [];
+
+                var Entity = persistence.define(entityName);
+                for (var i = 0; i < rows.size(); i++) {
+                  var r = rows.get(i);
+                  var e = aeEntityToEntity(session, r, Entity);
+                  results.push(e);
+                  session.add(e);
+                }
+                if(that._reverse) {
+                  results.reverse();
+                }
+                that.triggerEvent('list', that, results);
+                callback(results);
+              }
+            });
+        });
+    }
+  };
+
+  persistence.DbQueryCollection.prototype.destroyAll = function (tx, callback) {
+    var args = argspec.getArgs(arguments, [
+        { name: 'tx', optional: true, check: persistence.isTransaction, defaultValue: null },
+        { name: 'callback', optional: true, check: argspec.isCallback(), defaultValue: function(){} }
+      ]);
+    callback = args.callback;
+
+    var that = this;
+    var session = this._session;
+
+    session.flush(function() {
+        prepareQuery(that, function(preparedQuery) {
+            var rows = preparedQuery.asList(jdatastore.FetchOptions.Builder.withLimit(that._limit === -1 ? 1000 : that._limit).offset(that._skip));
+            var keys = new java.util.ArrayList();
+            for (var i = 0; i < rows.size(); i++) {
+              var r = rows.get(i);
+              keys.add(r.getKey());
+            }
+            that._session.dsService['delete'](keys);
+            that.triggerEvent('change', that);
+            callback();
+          });
+      });
+  };
+
+  persistence.DbQueryCollection.prototype.count = function (tx, callback) {
+    var args = argspec.getArgs(arguments, [
+        { name: 'tx', optional: true, check: persistence.isTransaction, defaultValue: null },
+        { name: 'callback', optional: false, check: argspec.isCallback() }
+      ]);
+    tx = args.tx;
+    callback = args.callback;
+
+    var that = this;
+    var session = this._session;
+
+    session.flush(function() {
+        prepareQuery(that, function(preparedQuery) {
+            var n = preparedQuery.countEntities(jdatastore.FetchOptions.Builder.withDefaults());
+            callback(n);
+          });
+      });
+
+  };
+
+  persistence.isSession = function(obj) {
+    var isSession = !obj || (obj && obj.schemaSync);
+    if(!isSession) {
+      throw Error("No session argument passed, you should!");
+    }
+    return isSession;
+  };
+};
+