envolver WebSQL ExecuteSQL llama en una promesa

Question

La especificación jQuery diferido/html5 para ExecuteSQL incluye una devolución de llamada de éxito y una falla de devolución de llamada:

db.transaction(function(tx) {  
    tx.executeSql('SELECT * FROM MyTable WHERE CategoryField = ?', 
    [ selectedCategory ], 
    function (tx, rs) { displayMyResult(rs); }, 
    function (tx, err) { displayMyError(err); }); 
}); 

Si estuviera usando jQuery, ¿hay una forma de implementar esto usando la nueva jQuery promesa/calor diferido?

Answer 1

He estado esperando una respuesta, pero nada tan lejos, así que voy a tomar una foto. No puedo ejecutar esto, así que me disculpo por cualquier error.

¿Estás buscando algo como:

function deferredTransaction(db,transaction,transactionFunction(transaction)) { 
    me=this; 
    return $.Deferred(function(deferedObject){ 
     db.transaction(transactionFunction(transaction), 
     function(tx,rs) { me.resolve(tx,rs); }, 
     function(tx,err) { me.reject(tx,err); }); 
    }).promise(); 
} 

dtx=deferredTransaction(db,tx,function(tx) {  
    tx.executeSql('SELECT * FROM MyTable WHERE CategoryField = ?', 
    [ selectedCategory ]); 
dtx.then(function (tx, rs) { displayMyResult(rs); }, 
    function (tx, err) { displayMyError(err); }); 

Answer 2

Tropezamos con esta pregunta mientras se busca otra cosa, pero creo que tengo algo de código de plantilla que le ayudará a empezar envolviendo consultas WebSQL en promesas jQuery.

Este es un ejemplo sqlProviderBase a $.extend en su propio proveedor. Tengo un ejemplo con un taskProvider y una página que llamaría al taskProvider en el evento de mostrar página. Es bastante escaso, pero espero que ayude a orientar a los demás en la dirección correcta para envolver las consultas en una promesa de un mejor manejo.

var sqlProviderBase = { 

    _executeSql: function (sql, parms) { 

     parms = parms || []; 

     var def = new $.Deferred(); 

     // TODO: Write your own getDb(), see http://www.html5rocks.com/en/tutorials/webdatabase/todo/ 
     var db = getDb(); 

     db.transaction(function (tx) { 
      tx.executeSql(sql, parms, 
      // On Success 
      function (itx, results) { 
       // Resolve with the results and the transaction. 
       def.resolve(results, itx); 
      }, 
      // On Error 
      function (etx, err) { 
       // Reject with the error and the transaction. 
       def.reject(err, etx); 
      }); 
     }); 

     return def.promise(); 
    } 
}; 

var taskProvider = $.extend({}, sqlProviderBase, { 

    getAllTasks: function() { 

     return this._executeQuery("select * from Tasks"); 

    } 

}); 

var pageThatGetsTasks = { 
    show: function() { 

     taskProvider.getAllTasks() 
        .then(function(tasksResult) { 

         for(var i = 0; i < tasksResult.rows.length; i++) { 
          var task = tasksResult.rows.item(i); 

          // TODO: Do some crazy stuff with the task... 
          renderTask(task.Id, task.Description, task.IsComplete); 

         } 

        }, function(err, etx) { 

         alert("Show me your error'd face: ;-[ "); 

        }); 

    } 
}; 

Answer 3

Solo quería añadir un ejemplo más.

(function() { 
    // size the database to 3mb. 
    var dbSize = 3 * 1024 * 1024, 
     myDb = window.openDatabase('myDb', '1.0', 'My Database', dbSize); 

    function runQuery() { 
     return $.Deferred(function (d) { 
      myDb.transaction(function (tx) { 
       tx.executeSql("select ? as Name", ['Josh'], 
       successWrapper(d), failureWrapper(d)); 
      }); 
     }); 
    }; 

    function successWrapper(d) { 
     return (function (tx, data) { 
      d.resolve(data) 
     }) 
    }; 

    function failureWrapper(d) { 
     return (function (tx, error) { 
      d.reject(error) 
     }) 
    }; 

    $.when(runQuery()).done(function (dta) { 
     alert('Hello ' + dta.rows.item(0).Name + '!'); 
    }).fail(function (err) { 
     alert('An error has occured.'); 
     console.log(err); 
    }); 

})() 

Answer 4

me parece que si se envuelve la transacción diferida en una función y devolver la promesa crea un aspecto y reutilizable aplicación limpia del patrón/promesa diferido.

var selectCategory = function() { 
    var $d = $.Deferred(); 

    db.transaction(
     function(tx) { 
      tx.executeSql(
       "SELECT * FROM MyTable WHERE CategoryField = ?" 
       , [selectedCategory] 
       , success 
       , error 
      ) 
     } 
    ); 

    function success(tx, rs) { 
     $d.resolve(rs); 
    } 

    function error(tx, error) { 
     $d.reject(error); 
    } 

    return $d.promise(); 
}; 

selectCategory() 
    .done(function(rs){ 
     displayMyResult(rs); 
    }) 
    .fail(function(err){ 
     displayMyError(err); 
    });