Knex Query Build - Build-Kette dynamisch

Question

Ich habe Knoten-DBI für Knex gehandelt, weil es mehr Funktion, die ich brauche. Bis jetzt würde ich die gleiche Wahl wieder treffen, aber nur eine Sache hält mich zurück: abstrakte Methoden schreiben, die eine Optionenvariable nehmen, wo params wie wo, innerjoin und so enthalten sind. Mit node-dbi könnte ich leicht eine schmieden Zeichenkette mit diesen Variablen, aber ich kann nicht scheinen, die Knex-Kette dynamisch zu erstellen, weil nach dem Verwenden eines Schalters, erhalten Sie knex.Methode ist keine Funktion.

Irgendeine Idee, wie man das löst?

Ich bin auf der Suche nach etwas, wie in

`getData(table,options){ 
var knex=knex 
    if(options.select) 
    /** append the select data using knex.select() 
    if(options.where) 
    /** append the where data using knex.where(data)*/ 
    if(options.innerJoin) 
    /** append innerjoin data*/ 
}` 

So kann ich es vermeiden kann eine Menge von DB-Funktionen zu schreiben und mein Geschäft logische Schichten Händel den Anfragen

Answer 1

/*This function serves as the core of our DB layer 
This will generate a SQL query and execute it whilest returning the response prematurely 
@param obj:{Object} this is the options object that contain all of the query options 
@return Promise{Object}: returns a promise that will be reject or resolved based on the outcome of the query 
The reasoning behind this kind of logic is that we want to abstract our layer as much as possible, if evne the slightest 
sytnax change occurs in the near future, we can easily update all our code by updating this one 
We are using knex as a query builder and are thus relying on Knex to communicate with our DB*/ 
/*Can also be used to build custom query functions from a data.service. This way our database service will remain 
unpolluted from many different functions and logic will be contained in a BLL*/ 
/* All available options 
var options = { 
    table:'table', 
    where:{operand:'=',value:'value',valueToEqual:'val2'}, 
    andWhere:[{operand:'=',value:'value',valueToEqual:'val2'}], 
    orWhere:[{operand:'=',value:'value',valueToEqual:'val2'}], 
    select:{value:['*']}, 
    insert:{data:{}}, 
    innerJoin:[{table:'tableName',value:'value',valueToEqual:'val2'}], 
    update:{data:{}} 
}*/ 
/*Test object*/ 
/*var testobj = { 
    table:'advantage', 
    where:{operand:'>',value:'id',valueToEqual:'3'}, 
    select:{value:['*']}, 
    innerJoin:{table:'User_Advantage',value:'User_Advantage.Advantageid',valueToEqual:'id'} 
} 
var testobj = { 
    table:'advantage', 
    where:{operand:'>',value:'id',valueToEqual:'3'}, 
    select:{value:['*']}, 
    innerJoin:{table:'User_Advantage',value:'User_Advantage.Advantageid',valueToEqual:'id'} 
} 
queryBuilder(testobj)*/ 
function queryBuilder(options){ 
var promise = new Promise(function (resolve, reject) { 
    var query; 
    for (var prop in options) { 
     /*logger.info(prop)*/ 
     if (options.hasOwnProperty(prop)) { 
      switch (prop) { 
       case 'table': 
       query = knex(options[prop]); 
       break; 
       case 'where': 
       query[prop](options[prop].value, options[prop].operand, options[prop].valueToEqual); 
       break; 
       /*andWhere and orWhere share the same syntax*/ 
       case 'andWhere': 
       case 'orWhere': 
       for(let i=0, len=options[prop].length;i<len;i++){ 
        query[prop](options[prop][i].value, options[prop][i].operand, options[prop][i].valueToEqual); 
       } 
       break; 
       case 'select': 
       query[prop](options[prop].value); 
       break; 
       /*Same syntax for update and insert -- switch fallthrough*/ 
       case 'insert': 
       case 'update': 
       query[prop](options[prop].data); 
       break; 
       case 'innerJoin': 
       for(let i=0, len=options[prop].length;i<len;i++){ 
        query[prop](options[prop][i].table, options[prop][i].value, options[prop][i].valueToEqual); 
       } 
       break; 
      } 
     } 
    } 
    return query 
    .then(function (res) { 
     return resolve(res); 
    }, function (error) { 
     logger.error(error) 
     return reject(error); 
    }) 
    return reject('Options wrongly formatted'); 
}); 
return promise 
} 

Dank Molda Ich konnte den obigen Code erstellen. Dieser verwendet ein Objekt namens options in als Parameter und baut die Knex-Kette basierend auf diesem Wert auf. Siehe die Kommentare für die Syntax des Objekts Nicht jede Knex-Abfrageoption wurde aufgenommen, aber dies wird als gute Basis für alle dienen, die versuchen, einen ähnlichen Effekt zu erzielen.

Einige Beispiele dieses zu verwenden:

/*Will return all values from a certain table 
@param: table{String}: string of the table to query 
@param: select{Array[String]}: Array of strings of columns to be select -- defaults to ['*'] */ 
function getAll(table,select) { 
    /*Select * from table as default*/ 
    var selectVal=select||['*'] 
    var options={ 
     table:table, 
     select:{value:selectVal} 
    } 
    return queryBuilder(options) 
} 

oder einen spezifischeren Anwendungsfall:

function getUserAdvantages(userid){ 
    var options = { 
     table:'advantage', 
     innerJoin:[{table:TABLE,value:'advantage.id',valueToEqual:'user_advantage.Advantageid'}], 
     where:{operand:'=',value:'user_advantage.Userid',valueToEqual:userid} 
    } 
    return sqlService.queryBuilder(options) 
} 

Anmerkung: das SqlService ist ein Modul des Knotens, den ich die Methode Querybuilder enthält exportieren.

Edit: Ich wollte hinzufügen, dass der einzige Roadblock, den ich hatte, war die .from/.insert von Knex. Ich verwende diese Methoden nicht mehr, da sie bei der Verwendung zu Fehlern führten. Ich habe Knex (Tabelle) als kommentiert verwendet.