gcloud/lib/src/db/db.dart - third_party/dart-pkg - Git at Google

 // Copyright (c) 2014, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.

 part of gcloud.db;

 /// A function definition for transactional functions.
 ///
 /// The function will be given a [Transaction] object which can be used to make
 /// lookups/queries and queue modifications (inserts/updates/deletes).
 typedef TransactionHandler = Future Function(Transaction transaction);

 /// A datastore transaction.
 ///
 /// It can be used for making lookups/queries and queue modifications
 /// (inserts/updates/deletes). Finally the transaction can be either committed
 /// or rolled back.
 class Transaction {
   static const int _TRANSACTION_STARTED = 0;
   static const int _TRANSACTION_ROLLED_BACK = 1;
   static const int _TRANSACTION_COMMITTED = 2;

   final DatastoreDB db;
   final ds.Transaction _datastoreTransaction;

   final List<Model> _inserts = [];
   final List<Key> _deletes = [];

   int _transactionState = _TRANSACTION_STARTED;

   Transaction(this.db, this._datastoreTransaction);

   /// Looks up [keys] within this transaction.
   Future<List<T>> lookup<T extends Model>(List<Key> keys) {
     return _lookupHelper<T>(db, keys,
         datastoreTransaction: _datastoreTransaction);
   }

   /// Enqueues [inserts] and [deletes] which should be committed at commit time.
   void queueMutations({List<Model> inserts, List<Key> deletes}) {
     _checkSealed();
     if (inserts != null) {
       _inserts.addAll(inserts);
     }
     if (deletes != null) {
       _deletes.addAll(deletes);
     }
   }

   /// Query for [kind] models with [ancestorKey].
   ///
   /// Note that [ancestorKey] is required, since a transaction is not allowed to
   /// touch/look at an arbitrary number of rows.
   Query<T> query<T extends Model>(Key ancestorKey, {Partition partition}) {
     // TODO(#25): The `partition` element is redundant and should be removed.
     if (partition == null) {
       partition = ancestorKey.partition;
     } else if (ancestorKey.partition != partition) {
       throw ArgumentError(
           'Ancestor queries must have the same partition in the ancestor key '
           'as the partition where the query executes in.');
     }
     _checkSealed();
     return Query<T>(db,
         partition: partition,
         ancestorKey: ancestorKey,
         datastoreTransaction: _datastoreTransaction);
   }

   /// Rolls this transaction back.
   Future rollback() {
     _checkSealed(changeState: _TRANSACTION_ROLLED_BACK);
     return db.datastore.rollback(_datastoreTransaction);
   }

   /// Commits this transaction including all of the queued mutations.
   Future commit() {
     _checkSealed(changeState: _TRANSACTION_COMMITTED);
     return _commitHelper(db,
         inserts: _inserts,
         deletes: _deletes,
         datastoreTransaction: _datastoreTransaction);
   }

   _checkSealed({int changeState}) {
     if (_transactionState == _TRANSACTION_COMMITTED) {
       throw StateError('The transaction has already been committed.');
     } else if (_transactionState == _TRANSACTION_ROLLED_BACK) {
       throw StateError('The transaction has already been rolled back.');
     }
     if (changeState != null) {
       _transactionState = changeState;
     }
   }
 }

 class Query<T extends Model> {
   final _relationMapping = const <String, ds.FilterRelation>{
     '<': ds.FilterRelation.LessThan,
     '<=': ds.FilterRelation.LessThanOrEqual,
     '>': ds.FilterRelation.GreatherThan,
     '>=': ds.FilterRelation.GreatherThanOrEqual,
     '=': ds.FilterRelation.Equal,
   };

   final DatastoreDB _db;
   final ds.Transaction _transaction;
   final String _kind;

   final Partition _partition;
   final Key _ancestorKey;

   final List<ds.Filter> _filters = [];
   final List<ds.Order> _orders = [];
   int _offset;
   int _limit;

   Query(DatastoreDB dbImpl,
       {Partition partition,
       Key ancestorKey,
       ds.Transaction datastoreTransaction})
       : _db = dbImpl,
         _kind = dbImpl.modelDB.kindName(T),
         _partition = partition,
         _ancestorKey = ancestorKey,
         _transaction = datastoreTransaction;

   /// Adds a filter to this [Query].
   ///
   /// [filterString] has form "name OP" where 'name' is a fieldName of the
   /// model and OP is an operator. The following operators are supported:
   ///
   ///   * '<' (less than)
   ///   * '<=' (less than or equal)
   ///   * '>' (greater than)
   ///   * '>=' (greater than or equal)
   ///   * '=' (equal)
   ///
   /// [comparisonObject] is the object for comparison.
   void filter(String filterString, Object comparisonObject) {
     var parts = filterString.split(' ');
     if (parts.length != 2 || !_relationMapping.containsKey(parts[1])) {
       throw ArgumentError("Invalid filter string '$filterString'.");
     }

     var name = parts[0];
     var comparison = parts[1];
     var propertyName = _convertToDatastoreName(name);

     // This is for backwards compatibility: We allow [datastore.Key]s for now.
     // TODO: We should remove the condition in a major version update of
     // `package:gcloud`.
     if (comparisonObject is! ds.Key) {
       comparisonObject = _db.modelDB
           .toDatastoreValue(_kind, name, comparisonObject, forComparison: true);
     }
     _filters.add(ds.Filter(
         _relationMapping[comparison], propertyName, comparisonObject));
   }

   /// Adds an order to this [Query].
   ///
   /// [orderString] has the form "-name" where 'name' is a fieldName of the model
   /// and the optional '-' says whether the order is descending or ascending.
   void order(String orderString) {
     // TODO: validate [orderString] (e.g. is name valid)
     if (orderString.startsWith('-')) {
       _orders.add(ds.Order(ds.OrderDirection.Decending,
           _convertToDatastoreName(orderString.substring(1))));
     } else {
       _orders.add(ds.Order(
           ds.OrderDirection.Ascending, _convertToDatastoreName(orderString)));
     }
   }

   /// Sets the [offset] of this [Query].
   ///
   /// When running this query, [offset] results will be skipped.
   void offset(int offset) {
     _offset = offset;
   }

   /// Sets the [limit] of this [Query].
   ///
   /// When running this query, a maximum of [limit] results will be returned.
   void limit(int limit) {
     _limit = limit;
   }

   /// Execute this [Query] on the datastore.
   ///
   /// Outside of transactions this method might return stale data or may not
   /// return the newest updates performed on the datastore since updates
   /// will be reflected in the indices in an eventual consistent way.
   Stream<T> run() {
     ds.Key ancestorKey;
     if (_ancestorKey != null) {
       ancestorKey = _db.modelDB.toDatastoreKey(_ancestorKey);
     }
     var query = ds.Query(
         ancestorKey: ancestorKey,
         kind: _kind,
         filters: _filters,
         orders: _orders,
         offset: _offset,
         limit: _limit);

     ds.Partition partition;
     if (_partition != null) {
       partition = ds.Partition(_partition.namespace);
     }

     return StreamFromPages<ds.Entity>((int pageSize) {
       return _db.datastore
           .query(query, transaction: _transaction, partition: partition);
     }).stream.map<T>(_db.modelDB.fromDatastoreEntity);
   }

   // TODO:
   // - add runPaged() returning Page<Model>
   // - add run*() method once we have EntityResult{Entity,Cursor} in low-level
   //   API.

   String _convertToDatastoreName(String name) {
     var propertyName = _db.modelDB.fieldNameToPropertyName(_kind, name);
     if (propertyName == null) {
       throw ArgumentError("Field $name is not available for kind $_kind");
     }
     return propertyName;
   }
 }

 class DatastoreDB {
   final ds.Datastore datastore;
   final ModelDB _modelDB;
   Partition _defaultPartition;

   DatastoreDB(this.datastore, {ModelDB modelDB, Partition defaultPartition})
       : _modelDB = modelDB != null ? modelDB : ModelDBImpl() {
     _defaultPartition =
         defaultPartition != null ? defaultPartition : Partition(null);
   }

   /// The [ModelDB] used to serialize/deserialize objects.
   ModelDB get modelDB => _modelDB;

   /// Gets the empty key using the default [Partition].
   ///
   /// Model keys with parent set to [emptyKey] will create their own entity
   /// groups.
   Key get emptyKey => defaultPartition.emptyKey;

   /// Gets the default [Partition].
   Partition get defaultPartition => _defaultPartition;

   /// Creates a new [Partition] with namespace [namespace].
   Partition newPartition(String namespace) {
     return Partition(namespace);
   }

   /// Begins a new a new transaction.
   ///
   /// A transaction can touch only a limited number of entity groups. This limit
   /// is currently 5.
   // TODO: Add retries and/or auto commit/rollback.
   Future withTransaction(TransactionHandler transactionHandler) {
     return datastore
         .beginTransaction(crossEntityGroup: true)
         .then((datastoreTransaction) {
       var transaction = Transaction(this, datastoreTransaction);
       return transactionHandler(transaction);
     });
   }

   /// Build a query for [kind] models.
   Query<T> query<T extends Model>({Partition partition, Key ancestorKey}) {
     // TODO(#26): There is only one case where `partition` is not redundant
     // Namely if `ancestorKey == null` and `partition != null`. We could
     // say we get rid of `partition` and enforce `ancestorKey` to
     // be `Partition.emptyKey`?
     if (partition == null) {
       if (ancestorKey != null) {
         partition = ancestorKey.partition;
       } else {
         partition = defaultPartition;
       }
     } else if (ancestorKey != null && partition != ancestorKey.partition) {
       throw ArgumentError(
           'Ancestor queries must have the same partition in the ancestor key '
           'as the partition where the query executes in.');
     }
     return Query<T>(this, partition: partition, ancestorKey: ancestorKey);
   }

   /// Looks up [keys] in the datastore and returns a list of [Model] objects.
   ///
   /// For transactions, please use [beginTransaction] and call the [lookup]
   /// method on it's returned [Transaction] object.
   Future<List<T>> lookup<T extends Model>(List<Key> keys) {
     return _lookupHelper<T>(this, keys);
   }

   /// Add [inserts] to the datastore and remove [deletes] from it.
   ///
   /// The order of inserts and deletes is not specified. When the commit is done
   /// direct lookups will see the effect but non-ancestor queries will see the
   /// change in an eventual consistent way.
   ///
   /// For transactions, please use `beginTransaction` and it's returned
   /// [Transaction] object.
   Future commit({List<Model> inserts, List<Key> deletes}) {
     return _commitHelper(this, inserts: inserts, deletes: deletes);
   }
 }

 Future _commitHelper(DatastoreDB db,
     {List<Model> inserts,
     List<Key> deletes,
     ds.Transaction datastoreTransaction}) {
   List<ds.Entity> entityInserts, entityAutoIdInserts;
   List<ds.Key> entityDeletes;
   var autoIdModelInserts;
   if (inserts != null) {
     entityInserts = <ds.Entity>[];
     entityAutoIdInserts = <ds.Entity>[];
     autoIdModelInserts = <Model>[];

     for (var model in inserts) {
       // If parent was not explicitly set, we assume this model will map to
       // it's own entity group.
       if (model.parentKey == null) {
         model.parentKey = db.defaultPartition.emptyKey;
       }
       if (model.id == null) {
         autoIdModelInserts.add(model);
         entityAutoIdInserts.add(db.modelDB.toDatastoreEntity(model));
       } else {
         entityInserts.add(db.modelDB.toDatastoreEntity(model));
       }
     }
   }
   if (deletes != null) {
     entityDeletes = deletes.map(db.modelDB.toDatastoreKey).toList();
   }

   return db.datastore
       .commit(
           inserts: entityInserts,
           autoIdInserts: entityAutoIdInserts,
           deletes: entityDeletes,
           transaction: datastoreTransaction)
       .then((ds.CommitResult result) {
     if (entityAutoIdInserts != null && entityAutoIdInserts.isNotEmpty) {
       for (var i = 0; i < result.autoIdInsertKeys.length; i++) {
         var key = db.modelDB.fromDatastoreKey(result.autoIdInsertKeys[i]);
         autoIdModelInserts[i].parentKey = key.parent;
         autoIdModelInserts[i].id = key.id;
       }
     }
   });
 }

 Future<List<T>> _lookupHelper<T extends Model>(DatastoreDB db, List<Key> keys,
     {ds.Transaction datastoreTransaction}) {
   var entityKeys = keys.map(db.modelDB.toDatastoreKey).toList();
   return db.datastore
       .lookup(entityKeys, transaction: datastoreTransaction)
       .then((List<ds.Entity> entities) {
     return entities.map<T>(db.modelDB.fromDatastoreEntity).toList();
   });
 }
	// Copyright (c) 2014, the Dart project authors. Please see the AUTHORS file
	// for details. All rights reserved. Use of this source code is governed by a
	// BSD-style license that can be found in the LICENSE file.

	part of gcloud.db;

	/// A function definition for transactional functions.
	///
	/// The function will be given a [Transaction] object which can be used to make
	/// lookups/queries and queue modifications (inserts/updates/deletes).
	typedef TransactionHandler = Future Function(Transaction transaction);

	/// A datastore transaction.
	///
	/// It can be used for making lookups/queries and queue modifications
	/// (inserts/updates/deletes). Finally the transaction can be either committed
	/// or rolled back.
	class Transaction {
	static const int _TRANSACTION_STARTED = 0;
	static const int _TRANSACTION_ROLLED_BACK = 1;
	static const int _TRANSACTION_COMMITTED = 2;

	final DatastoreDB db;
	final ds.Transaction _datastoreTransaction;

	final List<Model> _inserts = [];
	final List<Key> _deletes = [];

	int _transactionState = _TRANSACTION_STARTED;

	Transaction(this.db, this._datastoreTransaction);

	/// Looks up [keys] within this transaction.
	Future<List<T>> lookup<T extends Model>(List<Key> keys) {
	return _lookupHelper<T>(db, keys,
	datastoreTransaction: _datastoreTransaction);
	}

	/// Enqueues [inserts] and [deletes] which should be committed at commit time.
	void queueMutations({List<Model> inserts, List<Key> deletes}) {
	_checkSealed();
	if (inserts != null) {
	_inserts.addAll(inserts);
	}
	if (deletes != null) {
	_deletes.addAll(deletes);
	}
	}

	/// Query for [kind] models with [ancestorKey].
	///
	/// Note that [ancestorKey] is required, since a transaction is not allowed to
	/// touch/look at an arbitrary number of rows.
	Query<T> query<T extends Model>(Key ancestorKey, {Partition partition}) {
	// TODO(#25): The `partition` element is redundant and should be removed.
	if (partition == null) {
	partition = ancestorKey.partition;
	} else if (ancestorKey.partition != partition) {
	throw ArgumentError(
	'Ancestor queries must have the same partition in the ancestor key '
	'as the partition where the query executes in.');
	}
	_checkSealed();
	return Query<T>(db,
	partition: partition,
	ancestorKey: ancestorKey,
	datastoreTransaction: _datastoreTransaction);
	}

	/// Rolls this transaction back.
	Future rollback() {
	_checkSealed(changeState: _TRANSACTION_ROLLED_BACK);
	return db.datastore.rollback(_datastoreTransaction);
	}

	/// Commits this transaction including all of the queued mutations.
	Future commit() {
	_checkSealed(changeState: _TRANSACTION_COMMITTED);
	return _commitHelper(db,
	inserts: _inserts,
	deletes: _deletes,
	datastoreTransaction: _datastoreTransaction);
	}

	_checkSealed({int changeState}) {
	if (_transactionState == _TRANSACTION_COMMITTED) {
	throw StateError('The transaction has already been committed.');
	} else if (_transactionState == _TRANSACTION_ROLLED_BACK) {
	throw StateError('The transaction has already been rolled back.');
	}
	if (changeState != null) {
	_transactionState = changeState;
	}
	}
	}

	class Query<T extends Model> {
	final _relationMapping = const <String, ds.FilterRelation>{
	'<': ds.FilterRelation.LessThan,
	'<=': ds.FilterRelation.LessThanOrEqual,
	'>': ds.FilterRelation.GreatherThan,
	'>=': ds.FilterRelation.GreatherThanOrEqual,
	'=': ds.FilterRelation.Equal,
	};

	final DatastoreDB _db;
	final ds.Transaction _transaction;
	final String _kind;

	final Partition _partition;
	final Key _ancestorKey;

	final List<ds.Filter> _filters = [];
	final List<ds.Order> _orders = [];
	int _offset;
	int _limit;

	Query(DatastoreDB dbImpl,
	{Partition partition,
	Key ancestorKey,
	ds.Transaction datastoreTransaction})
	: _db = dbImpl,
	_kind = dbImpl.modelDB.kindName(T),
	_partition = partition,
	_ancestorKey = ancestorKey,
	_transaction = datastoreTransaction;

	/// Adds a filter to this [Query].
	///
	/// [filterString] has form "name OP" where 'name' is a fieldName of the
	/// model and OP is an operator. The following operators are supported:
	///
	/// * '<' (less than)
	/// * '<=' (less than or equal)
	/// * '>' (greater than)
	/// * '>=' (greater than or equal)
	/// * '=' (equal)
	///
	/// [comparisonObject] is the object for comparison.
	void filter(String filterString, Object comparisonObject) {
	var parts = filterString.split(' ');
	if (parts.length != 2 \|\| !_relationMapping.containsKey(parts[1])) {
	throw ArgumentError("Invalid filter string '$filterString'.");
	}

	var name = parts[0];
	var comparison = parts[1];
	var propertyName = _convertToDatastoreName(name);

	// This is for backwards compatibility: We allow [datastore.Key]s for now.
	// TODO: We should remove the condition in a major version update of
	// `package:gcloud`.
	if (comparisonObject is! ds.Key) {
	comparisonObject = _db.modelDB
	.toDatastoreValue(_kind, name, comparisonObject, forComparison: true);
	}
	_filters.add(ds.Filter(
	_relationMapping[comparison], propertyName, comparisonObject));
	}

	/// Adds an order to this [Query].
	///
	/// [orderString] has the form "-name" where 'name' is a fieldName of the model
	/// and the optional '-' says whether the order is descending or ascending.
	void order(String orderString) {
	// TODO: validate [orderString] (e.g. is name valid)
	if (orderString.startsWith('-')) {
	_orders.add(ds.Order(ds.OrderDirection.Decending,
	_convertToDatastoreName(orderString.substring(1))));
	} else {
	_orders.add(ds.Order(
	ds.OrderDirection.Ascending, _convertToDatastoreName(orderString)));
	}
	}

	/// Sets the [offset] of this [Query].
	///
	/// When running this query, [offset] results will be skipped.
	void offset(int offset) {
	_offset = offset;
	}

	/// Sets the [limit] of this [Query].
	///
	/// When running this query, a maximum of [limit] results will be returned.
	void limit(int limit) {
	_limit = limit;
	}

	/// Execute this [Query] on the datastore.
	///
	/// Outside of transactions this method might return stale data or may not
	/// return the newest updates performed on the datastore since updates
	/// will be reflected in the indices in an eventual consistent way.
	Stream<T> run() {
	ds.Key ancestorKey;
	if (_ancestorKey != null) {
	ancestorKey = _db.modelDB.toDatastoreKey(_ancestorKey);
	}
	var query = ds.Query(
	ancestorKey: ancestorKey,
	kind: _kind,
	filters: _filters,
	orders: _orders,
	offset: _offset,
	limit: _limit);

	ds.Partition partition;
	if (_partition != null) {
	partition = ds.Partition(_partition.namespace);
	}

	return StreamFromPages<ds.Entity>((int pageSize) {
	return _db.datastore
	.query(query, transaction: _transaction, partition: partition);
	}).stream.map<T>(_db.modelDB.fromDatastoreEntity);
	}

	// TODO:
	// - add runPaged() returning Page<Model>
	// - add run*() method once we have EntityResult{Entity,Cursor} in low-level
	// API.

	String _convertToDatastoreName(String name) {
	var propertyName = _db.modelDB.fieldNameToPropertyName(_kind, name);
	if (propertyName == null) {
	throw ArgumentError("Field $name is not available for kind $_kind");
	}
	return propertyName;
	}
	}

	class DatastoreDB {
	final ds.Datastore datastore;
	final ModelDB _modelDB;
	Partition _defaultPartition;

	DatastoreDB(this.datastore, {ModelDB modelDB, Partition defaultPartition})
	: _modelDB = modelDB != null ? modelDB : ModelDBImpl() {
	_defaultPartition =
	defaultPartition != null ? defaultPartition : Partition(null);
	}

	/// The [ModelDB] used to serialize/deserialize objects.
	ModelDB get modelDB => _modelDB;

	/// Gets the empty key using the default [Partition].
	///
	/// Model keys with parent set to [emptyKey] will create their own entity
	/// groups.
	Key get emptyKey => defaultPartition.emptyKey;

	/// Gets the default [Partition].
	Partition get defaultPartition => _defaultPartition;

	/// Creates a new [Partition] with namespace [namespace].
	Partition newPartition(String namespace) {
	return Partition(namespace);
	}

	/// Begins a new a new transaction.
	///
	/// A transaction can touch only a limited number of entity groups. This limit
	/// is currently 5.
	// TODO: Add retries and/or auto commit/rollback.
	Future withTransaction(TransactionHandler transactionHandler) {
	return datastore
	.beginTransaction(crossEntityGroup: true)
	.then((datastoreTransaction) {
	var transaction = Transaction(this, datastoreTransaction);
	return transactionHandler(transaction);
	});
	}

	/// Build a query for [kind] models.
	Query<T> query<T extends Model>({Partition partition, Key ancestorKey}) {
	// TODO(#26): There is only one case where `partition` is not redundant
	// Namely if `ancestorKey == null` and `partition != null`. We could
	// say we get rid of `partition` and enforce `ancestorKey` to
	// be `Partition.emptyKey`?
	if (partition == null) {
	if (ancestorKey != null) {
	partition = ancestorKey.partition;
	} else {
	partition = defaultPartition;
	}
	} else if (ancestorKey != null && partition != ancestorKey.partition) {
	throw ArgumentError(
	'Ancestor queries must have the same partition in the ancestor key '
	'as the partition where the query executes in.');
	}
	return Query<T>(this, partition: partition, ancestorKey: ancestorKey);
	}

	/// Looks up [keys] in the datastore and returns a list of [Model] objects.
	///
	/// For transactions, please use [beginTransaction] and call the [lookup]
	/// method on it's returned [Transaction] object.
	Future<List<T>> lookup<T extends Model>(List<Key> keys) {
	return _lookupHelper<T>(this, keys);
	}

	/// Add [inserts] to the datastore and remove [deletes] from it.
	///
	/// The order of inserts and deletes is not specified. When the commit is done
	/// direct lookups will see the effect but non-ancestor queries will see the
	/// change in an eventual consistent way.
	///
	/// For transactions, please use `beginTransaction` and it's returned
	/// [Transaction] object.
	Future commit({List<Model> inserts, List<Key> deletes}) {
	return _commitHelper(this, inserts: inserts, deletes: deletes);
	}
	}

	Future _commitHelper(DatastoreDB db,
	{List<Model> inserts,
	List<Key> deletes,
	ds.Transaction datastoreTransaction}) {
	List<ds.Entity> entityInserts, entityAutoIdInserts;
	List<ds.Key> entityDeletes;
	var autoIdModelInserts;
	if (inserts != null) {
	entityInserts = <ds.Entity>[];
	entityAutoIdInserts = <ds.Entity>[];
	autoIdModelInserts = <Model>[];

	for (var model in inserts) {
	// If parent was not explicitly set, we assume this model will map to
	// it's own entity group.
	if (model.parentKey == null) {
	model.parentKey = db.defaultPartition.emptyKey;
	}
	if (model.id == null) {
	autoIdModelInserts.add(model);
	entityAutoIdInserts.add(db.modelDB.toDatastoreEntity(model));
	} else {
	entityInserts.add(db.modelDB.toDatastoreEntity(model));
	}
	}
	}
	if (deletes != null) {
	entityDeletes = deletes.map(db.modelDB.toDatastoreKey).toList();
	}

	return db.datastore
	.commit(
	inserts: entityInserts,
	autoIdInserts: entityAutoIdInserts,
	deletes: entityDeletes,
	transaction: datastoreTransaction)
	.then((ds.CommitResult result) {
	if (entityAutoIdInserts != null && entityAutoIdInserts.isNotEmpty) {
	for (var i = 0; i < result.autoIdInsertKeys.length; i++) {
	var key = db.modelDB.fromDatastoreKey(result.autoIdInsertKeys[i]);
	autoIdModelInserts[i].parentKey = key.parent;
	autoIdModelInserts[i].id = key.id;
	}
	}
	});
	}

	Future<List<T>> _lookupHelper<T extends Model>(DatastoreDB db, List<Key> keys,
	{ds.Transaction datastoreTransaction}) {
	var entityKeys = keys.map(db.modelDB.toDatastoreKey).toList();
	return db.datastore
	.lookup(entityKeys, transaction: datastoreTransaction)
	.then((List<ds.Entity> entities) {
	return entities.map<T>(db.modelDB.fromDatastoreEntity).toList();
	});
	}