如何检查任何给定查询 return 是否在 knex 中有任何结果

Question

我有两个问题：

a) select id from ingredietns where name = my_param;

b) select word_id from synonyms where name = my_param;

return 0 或 1 行。如果需要，我还可以添加 limit 1（或在 knex first() 中）。

我可以像这样将每个翻译成 knex：

knex("ingredients").select('id').where('name', my_param) //do we need first()?

knex("synonyms").select('word_id').where('name', my_param) //do we need first()?

我需要名为“ingredientGetOrCreate(my_param)”的函数。此函数将

a) 检查以上任何查询是否有 return 结果 b) 如果这些 return 中的任何一个，那么 return ingredients.id 或 synonyms.word_id - 只有一个可以被 returned c) 如果记录不存在于任何表中，我需要执行 knex inesrt a 和 return newly added id from function

d) 后来我不确定我是否也理解如何调用这个新创建的函数。函数 ingredientGetOrCreate 稍后将用作单独的函数或在以下情况（如 "loop"）中使用，这对我也不起作用：

knex("products") // for each product
    .select("id", "name")
    .map(function (row) {
        var descriptionSplitByCommas = row.desc.split(",");
        Promise.all(descriptionSplitByCommas
            .map(function (my_param) {
                // here it comes - call method for each param and do insert
                ingredientGetOrCreate(my_param)
                  .then(function (id_of_ingredient) {
                          knex('ingredients_products').insert({ id_of_ingredient });                      

                  });
         ...

由于异步部分，我被 knex 和 Promise 查询困住了。请问有什么线索吗？我虽然可以以某种方式使用 Promise.all 或 Promise.some 来调用这两个查询。

P.S。这是我第一天使用 nodejs、Promise 和 knex。

Answer 1

据我解读你的问题，它由两部分组成：

(1) 您需要实现 upsert 逻辑（get-or-create 逻辑）。

(2) 您的 get 部分要求查询的不是单个 table，而是按特定顺序查询的一对 table。 Table 名称暗示这是您应用程序内部的某种别名引擎。

让我们从 (2) 开始。这绝对可以用两个查询来解决，就像你感觉到的那样。

function pick_name (rows)
{
    if (! rows.length) return null
    return rows[0].name
}

// you can sequence queries
function ingredient_get (name)
{
    return knex('ingredients')
    .select('id').where('name', name)
    .then(pick_name)
    .then(name =>
    {
        if (name) return name

        return knex('synonyms')
        .select('word_id').where('name', name)
        .then(pick_name)
    })
}

// or run em parallel
function ingredient_get (name)
{
    var q_ingredients = knex('ingredients')
    .select('id').where('name', name)
    .then(pick_name)

    var q_synonyms = knex('synonyms')
    .select('word_id').where('name', name)
    .then(pick_name)

    return Promise.all([ q_ingredients, q_synonyms ])
    .then(([name1, name2]) =>
    {
       return name1 || name2
    })
}

这里的重要概念：

两种形式都很好，return 第一次出现或 JS' null。
第一种形式优化了对数据库的查询次数。
第二种形式优化了回答时间。

但是，您可以更深入地使用更多SQL。有一个名为 COALESCE 的特殊工具可以完成此类任务。您可以查阅 SQL 文档，这里是 COLASCE of PostgreSQL 9。 COALESCE 的主要思想是 return 第一个非 NULL 参数或 NULL 否则。因此，您可以利用它来优化查询和回答时间。

function ingredient_get (name)
{
    // preparing but not executing both queries
    var q_ingredients = knex('ingredients')
    .select('id').where('name', name)

    var q_synonyms = knex('synonyms')
    .select('word_id').where('name', name)

    // put them in COALESCE
    return knex.raw('SELECT COALESCE(?, ?) AS name', [ q_ingredients, q_synonyms ])
    .then(pick_name)

此解决方案保证单一查询，而且数据库引擎可以以任何它认为合适的方式优化执行。

现在让我们解决 (1)：我们现在得到 ingredient_get(name)，其中 returns Promise<string | null>。我们可以使用它的输出来激活 create 逻辑或 return 我们的价值。

function ingredient_get_or_create (name, data)
{
    return ingredient_get(name)
    .then(name =>
    {
       if (name) return name

       // …do your insert logic here
       return knex('ingredients').insert({ name, ...data }) 
       // guarantee homohenic output across get/create calls:
       .then(() => name)
    })
}

现在ingredient_get_or_create执行您想要的更新插入逻辑。

UPD1: 我们已经在任何场景（获取或创建）中得到 ingredient_get_or_create 其中 returns Promise<name>。

a) 如果你之后需要做任何特定的逻辑，你可以使用 then:

ingredient_get_or_create(…)
.then(() => knex('another_table').insert(…))
.then(/* another logic after all */)

在承诺的语言中，意思是“如果之前没有问题，就执行该操作 (then) (ingredient_get_or_create)”。在大多数情况下，这就是您所需要的。

b) 要在 promise 中实现 for 循环，你有多种不同的习惯用法：

// use some form of parallelism
var qs = [ 'name1', 'name2', 'name3' ]
.map(name =>
{
   return ingredient_get_or_create(name, data)
})

var q = Promise.all(qs)

请注意，这是一种激进的并行机制，您将获得输入数组提供的最大并行查询数。

如果不需要，您需要限制并行度甚至运行顺序执行任务。 Bluebird 的 Promise.map 是运行 map 的一种方式，类似于上面的示例，但有 concurrency 选项可用。有关详细信息，请考虑文档。

还有 Bluebird 的 Promise.mapSeries，它在概念上类似于 for 循环，但带有 promises。这就像按顺序运行s 的地图。查看文档了解详细信息。

Promise.mapSeries([ 'name1', 'name2', 'name3' ],
(name) =>  ingredient_get_or_create(name, data))
.then(/* logic after all mapSeries are OK */)

我相信最后一个就是你需要的。

如何检查任何给定查询 return 是否在 knex 中有任何结果

how to check if any of given queries return any result in knex

node.js

knex.js