Optional locks for getMany, getById, tryGetById, getFirst, tryGetFirst

mySql/newTransaction.js

@@ -1,6 +1,7 @@
 var wrapQuery = require('./wrapQuery');
 var wrapQueryStream = require('./wrapQueryStream');
 var deleteFromSql = require('./deleteFromSql');
+var selectForUpdateSql = require('./selectForUpdateSql');
 var encodeDate = require('./encodeDate');
 
 function newResolveTransaction(domain, pool) {
@@ -22,6 +23,7 @@ function newResolveTransaction(domain, pool) {
             rdb.encodeBuffer = connection.escape.bind(connection);
             rdb.encodeDate = encodeDate;
             rdb.deleteFromSql = deleteFromSql;
+            rdb.selectForUpdateSql = selectForUpdateSql;
             domain.rdb = rdb;    
             onSuccess();
         }

mySql/newTransactionSpec/new.js

@@ -9,6 +9,7 @@ function act(c){
 
 	c.wrapQuery = c.requireMock('./wrapQuery');
 	c.deleteFromSql = c.requireMock('./deleteFromSql');
+	c.selectForUpdateSql = c.requireMock('./selectForUpdateSql');
 	c.encodeDate = c.requireMock('./encodeDate');
 
 

mySql/newTransactionSpec/new/runDomain/whenResolveSuccess.js

@@ -8,5 +8,6 @@ when(c)
     .it('should attach escape to rdb.encodeBuffer').assertEqual(c.boundEscape, c.domain.rdb.encodeBuffer)
     .it('should attach encodeDate to rdb.encodeDate').assertEqual(c.encodeDate, c.domain.rdb.encodeDate)
     .it('should attach deleteFromSql to rdb').assertEqual(c.deleteFromSql, c.domain.rdb.deleteFromSql)    
+    .it('should attach selectForUpdateSql to rdb').assertEqual(c.selectForUpdateSql, c.domain.rdb.selectForUpdateSql)    
     .it('should invoke success callback').assertDoesNotThrow(c.onSuccess.verify)
     .it('should set wrappedQuery').assertEqual(c.wrappedQuery, c.connection.executeQuery)

mySql/selectForUpdateSql.js

@@ -0,0 +1,3 @@
+module.exports = function(alias) {
+	return ' FOR UPDATE';
+}

table/query/singleQuery/negotiateExlusiveSpec/negotiate.js → mySql/selectForUpdateSqlSpec/getSql.js

@@ -6,11 +6,7 @@ function act(c){
 	c.expectRequire = a.expectRequire;
 	c.then = a.then;
 
-	c.table = {};
-	c.tableWithExclusive = {
-		_exclusive: true
-	};
-	c.sut = require('../negotiateExclusive');
+	c.returned = require('../selectForUpdateSql')('alias');
 }
 
 module.exports = act;

mySql/selectForUpdateSqlSpec/whenGetSql.js

@@ -0,0 +1,5 @@
+var when = require('a').when;
+var c = {};
+
+when(c)
+.it('should return sql').assertEqual(' FOR UPDATE', c.returned)

package.json

@@ -27,7 +27,7 @@
     "promise": "^6.1.0"
   },
   "devDependencies": {
-    "a": "^1.0.2"
+    "a": "^2.1.0"
   },
   "repository": {
     "type": "git",

pg/newTransaction.js

@@ -3,6 +3,7 @@ var wrapQueryStream = require('./wrapQueryStream');
 var encodeBuffer = require('./encodeBuffer');
 var encodeDate = require('./encodeDate');
 var deleteFromSql = require('./deleteFromSql');
+var selectForUpdateSql = require('./selectForUpdateSql');
 
 function newResolveTransaction(domain, pool) {
 
@@ -22,6 +23,7 @@ function newResolveTransaction(domain, pool) {
             rdb.encodeBuffer = encodeBuffer;
             rdb.encodeDate = encodeDate;
             rdb.deleteFromSql = deleteFromSql;
+            rdb.selectForUpdateSql = selectForUpdateSql;
             domain.rdb = rdb;    
             onSuccess();
         }

pg/newTransactionSpec/new.js

@@ -16,6 +16,7 @@ function act(c){
 
 
 	c.deleteFromSql = c.requireMock('./deleteFromSql');
+	c.selectForUpdateSql = c.requireMock('./selectForUpdateSql');
 
 	c.sut = require('../newTransaction')(c.domain, c.pool);
 }

pg/newTransactionSpec/new/runDomain/whenResolveSuccess.js

@@ -8,6 +8,7 @@ when(c)
     .it('should set rdb.encodeBuffer').assertEqual(c.encodeBuffer, c.domain.rdb.encodeBuffer)
     .it('should set rdb.encodeDate').assertEqual(c.encodeDate, c.domain.rdb.encodeDate)
     .it('should set rdb.deleteFromSql').assertEqual(c.deleteFromSql, c.domain.rdb.deleteFromSql)
+    .it('should set rdb.selectForUpdateSql').assertEqual(c.selectForUpdateSql, c.domain.rdb.selectForUpdateSql)
     .it('should invoke success callback').assertDoesNotThrow(c.onSuccess.verify)
     .it('should set executeQuery').assertEqual(c.wrappedQuery, c.client.executeQuery)
     .it('should set streamQuery').assertEqual(c.wrappedQueryStream, c.client.streamQuery)

pg/selectForUpdateSql.js

@@ -0,0 +1,3 @@
+module.exports = function(alias) {
+	return ' FOR UPDATE OF ' + alias;
+}

pg/selectForUpdateSqlSpec/getSql.js

@@ -0,0 +1,12 @@
+var a = require('a');
+
+function act(c){
+	c.mock = a.mock;
+	c.requireMock = a.requireMock;
+	c.expectRequire = a.expectRequire;
+	c.then = a.then;
+
+	c.returned = require('../selectForUpdateSql')('alias');
+}
+
+module.exports = act;

pg/selectForUpdateSqlSpec/whenGetSql.js

@@ -0,0 +1,5 @@
+var when = require('a').when;
+var c = {};
+
+when(c)
+.it('should return sql').assertEqual(' FOR UPDATE OF alias', c.returned)

table.js

@@ -52,9 +52,16 @@ function _new(tableName) {
         return call(getMany, arguments);
     };
 
+    table.getMany.exclusive = function() {
+        return call(getMany.exclusive, arguments);        
+    };
+
     table.tryGetFirst = function() {
         return call(tryGetFirst, arguments);
     };
+    table.tryGetFirst.exclusive = function() {
+        return call(tryGetFirst.exclusive, arguments);
+    };
 
     function call(func, args) {
         var mergedArgs = [table];
@@ -67,11 +74,19 @@ function _new(tableName) {
     table.getById = function() {
         return call(getById, arguments);
     };
+    table.getById.exclusive = function() {
+        return call(getById.exclusive, arguments);
+    };
+
 
     table.tryGetById = function() {
         return call(tryGetById, arguments);
     };
 
+    table.tryGetById.exclusive = function() {
+        return call(tryGetById.exclusive, arguments);
+    };
+
     table.columnDiscriminators = function() {
         for (var i = 0; i < arguments.length; i++) {
             table._columnDiscriminators.push(arguments[i]);

table/delete.js

@@ -1,9 +1,11 @@
 var pushCommand = require('./commands/pushCommand');
 var newDeleteCommand = require('./commands/newDeleteCommand');
 var extractDeleteStrategy = require('./extractDeleteStrategy');
+var negotiateRawSqlFilter = require('./column/negotiateRawSqlFilter');
 var emptyPromise = require('./resultToPromise')();
 
 function _delete(table, filter, strategy) {
+	var filter = negotiateRawSqlFilter(filter);
 	strategy = extractDeleteStrategy(strategy);
 	var relations = [];
 	var cmds = [];

table/deleteSessionContextSpec/delete.js

@@ -6,10 +6,12 @@ function act(c){
 	c.expectRequire = a.expectRequire;
 	c.then = a.then;
 
-	process.domain = {};
+	var oldDomain = process.domain;
+	c.domain = {};
+	process.domain = c.domain;
 	process.domain.rdb = {};
-
 	c.sut = require('../deleteSessionContext')();
+	process.domain = oldDomain;
 }
 
 module.exports = act;

table/deleteSessionContextSpec/whenDelete.js

@@ -2,4 +2,4 @@ var when = require('a').when;
 var c = {};
 
 when(c)
-.it('should should delete rdb property from domain').assertEqual(false, 'rdb' in process.domain)
+.it('should should delete rdb property from domain').assertEqual(false, 'rdb' in c.domain)

table/deleteSpec/req.js

@@ -10,6 +10,8 @@ function act(c){
 	c.newDeleteCommand = c.requireMock('./commands/newDeleteCommand');
 	c.extractDeleteStrategy = c.requireMock('./extractDeleteStrategy');
 	c.resultToPromise = c.requireMock('./resultToPromise');
+	c.negotiateRawSqlFilter = c.requireMock('./column/negotiateRawSqlFilter');
+
 	c.emptyPromise = {};
 	c.resultToPromise.expect().return(c.emptyPromise);
 

table/deleteSpec/req/delete.js

@@ -1,6 +1,7 @@
 function act(c){
 	c.table = {};
 	c.initialStrategy = {};
+	c.initialFilter = {};
 	c.filter = {};
 	c.strategy = {};
 	c.command = {};
@@ -10,14 +11,16 @@ function act(c){
 	c.relations = [];
 	c.initialCmds = [];
 
+	c.negotiateRawSqlFilter.expect(c.initialFilter).return(c.filter);
+
 	c.newDeleteCommand.expect(c.initialCmds, c.table, c.filter, c.strategy, c.relations).return(c.commands);	
 
 	c.extractDeleteStrategy.expect(c.initialStrategy).return(c.strategy);
 
 	c.pushCommand.expect(c.command);
 	c.pushCommand.expect(c.command2);
 
-	c.returned = c.sut(c.table, c.filter, c.initialStrategy);
+	c.returned = c.sut(c.table, c.initialFilter, c.initialStrategy);
 }
 
 module.exports = act;

table/getById.js

@@ -2,11 +2,18 @@
  var getFromDbById = require('./getFromDbById');
  var resultToPromise = require('./resultToPromise');
 
-function get() {
+function getById() {
 	var cached =  tryGetFromCacheById.apply(null,arguments);
 	if (cached)
 		return resultToPromise(cached);
 	return getFromDbById.apply(null,arguments);
 }
 
-module.exports = get;
+getById.exclusive = function() {
+	var cached =  tryGetFromCacheById.apply(null,arguments);
+	if (cached)
+		return resultToPromise(cached);
+	return getFromDbById.exclusive.apply(null,arguments);
+}
+
+module.exports = getById;

table/getByIdSpec/exclusive/isCached/get.js

@@ -0,0 +1,11 @@
+var expected = {};
+var cached = {};
+
+function act(c) {
+	c.expected = expected;
+	c.tryGetFromCacheById.expect(c.table,c.arg1,c.arg2,c.strategy).return(cached);
+	c.resultToPromise.expect(cached).return(expected);
+	c.getExclusive();
+}
+
+module.exports = act;

table/getByIdSpec/exclusive/notCached/get.js

@@ -0,0 +1,9 @@
+var expected = {};
+function act(c) {
+	c.expected = expected;
+	c.tryGetFromCacheById.expect(c.table,c.arg1,c.arg2,c.strategy).return(null);
+	c.getFromDbById.exclusive.expect(c.table,c.arg1,c.arg2,c.strategy).return(expected);
+	c.getExclusive();
+}
+
+module.exports = act;

table/getByIdSpec/new.js

@@ -1,4 +1,5 @@
-var requireMock = require('a').requireMock;
+var a = require('a');
+var requireMock = a.requireMock;
 var tryGetFromCacheById = requireMock('./tryGetFromCacheById');
 var getFromDbById = requireMock('./getFromDbById');
 var resultToPromise = requireMock('./resultToPromise');
@@ -9,20 +10,28 @@ var table = {};
 var strategy = {};
 
 function act(c) {
+	c.mock = a.mock;
 	c.resultToPromise = resultToPromise;
 	c.table = table;
 	c.arg1 = arg1;
 	c.arg2 = arg2;
 	c.strategy = strategy;
 	c.tryGetFromCacheById = tryGetFromCacheById;
 	c.getFromDbById = getFromDbById;
+	c.getFromDbById.exclusive = c.mock();
+
 	c.sut = require('../getById');
 	c.get = get;
+	c.getExclusive = getExclusive;
 
 	function get() {
 		c.returned = c.sut(table,arg1,arg2,strategy);
 	}
 
+	function getExclusive() {
+		c.returned = c.sut.exclusive(table,arg1,arg2,strategy);
+	}
+
 }
 
 

table/getByIdSpec/new/isCached/whenGet.js → table/getByIdSpec/notExclusive/isCached/whenGet.js

@@ -1,5 +1,5 @@
 var when  = require('a').when;
 var c = {};
 
-when('./get',c).
+when(c).
 	it('should return expected').assertEqual(c.expected,c.returned);

table/getByIdSpec/new/notCached/get.js → table/getByIdSpec/notExclusive/notCached/get.js

@@ -6,5 +6,4 @@ function act(c) {
 	c.get();
 }
 
-act.base = '../../new';
 module.exports = act;

table/getByIdSpec/new/notCached/whenGet.js → table/getByIdSpec/notExclusive/notCached/whenGet.js

@@ -1,5 +1,5 @@
 var when  = require('a').when;
 var c = {};
 
-when('./get',c).
+when(c).
 	it('should return expected').assertEqual(c.expected,c.returned);

table/getFromDbById.js

@@ -1,13 +1,23 @@
 var tryGetFromDbById = require('./tryGetFromDbById');
 
-	function get()  {
-	return tryGetFromDbById.apply(null,arguments).then(onResult);
-
-	function onResult(row) {
-		if (row === null)
-			throw new Error("Row not found.");
-		return row;
-	}
+function get() {
+    return tryGetFromDbById.apply(null, arguments).then(onResult);
+
+    function onResult(row) {
+        if (row === null)
+            throw new Error("Row not found.");
+        return row;
+    }
+}
+
+get.exclusive = function() {
+    return tryGetFromDbById.exclusive.apply(null, arguments).then(onResult);
+
+    function onResult(row) {
+        if (row === null)
+            throw new Error("Row not found.");
+        return row;
+    }
 }
 
-module.exports = get;
+module.exports = get;

table/getFromDbByIdSpec/exclusive/exists/get.js

@@ -0,0 +1,11 @@
+var expected = {};
+
+function act(c) {
+	c.row = {};
+
+	c.tryGetFromDbById.exclusive.expect(c.table,c.id,c.strategy).resolve(c.row);
+
+	return c.getExclusive();
+}
+
+module.exports = act;

table/getFromDbByIdSpec/exclusive/exists/when_get.js

@@ -0,0 +1,6 @@
+var when = require('a').when;
+var c = {};
+
+when(c).then(function(it) {
+	it('returns row').assertEqual(c.row, c.returned);
+})