Node.js + OracleDb - 多次插入最后一个日期答案

【问题标题】：Node.js + OracleDb - Insert the last date many timesNode.js + OracleDb - 多次插入最后一个日期
【发布时间】：2017-08-13 05:30:36
【问题描述】：

我收到了这个 JSON：

{
  "TOTAL_RECORDS": 1029,
  "REGISTROS": [
    {
      "CODIGO": "1",
      "ATENDIMENTO": "1",
      "PAGAMENTO": "1",
      "VENCIMENTO": "2016-12-17 00:00:00",
      "PROCESSAMENTO": "2016-12-10 00:00:00",
      "VALOR": "1800.00000",
      "NOSSO_NUMERO": "xxxxxxx",
      "NUMERO_DOCUMENTO": "xxxxx",
      "CODIGO_BANCO": "123",
      "LINHA_DIGITAVEL": "XXX70110000180000",
      "CODIGO_BARRAS": "XXX90940"
    },
    {
      "CODIGO": "2",
      "ATENDIMENTO": "2",
      "PAGAMENTO": "2",
      "VENCIMENTO": "2016-12-17 00:00:00",
      "PROCESSAMENTO": "2016-12-10 00:00:00",
      "VALOR": "2700.00000",
      "NOSSO_NUMERO": "xxxxxxx",
      "NUMERO_DOCUMENTO": "xxxxx",
      "CODIGO_BANCO": "123",
      "LINHA_DIGITAVEL": "XXX70110000180000",
      "CODIGO_BARRAS": "XXX90940"
    },...

然后我需要捕获这些信息并保存在 DB Oracle 中，所以我这样做：

module.exports = function (object, callback) {

     var oracledb = require('oracledb');    
     for(const prop in object['REGISTROS']){                    

        codigo = object['REGISTROS'][prop]['CODIGO'];               

        atendimento = object['REGISTROS'][prop]['ATENDIMENTO'];

        pagamento = object['REGISTROS'][prop]['PAGAMENTO'];

        vencimento = object['REGISTROS'][prop]['VENCIMENTO'];

        processamento = object['REGISTROS'][prop]['PROCESSAMENTO'];

        valor = parseInt(object['REGISTROS'][prop]['VALOR']);

        nossoNumero = object['REGISTROS'][prop]['NOSSO_NUMERO'];

        numeroDocumento = object['REGISTROS'][prop]['NUMERO_DOCUMENTO'];

        codigoBanco = object['REGISTROS'][prop]['CODIGO_BANCO'];

        linhaDigitavel = object['REGISTROS'][prop]['LINHA_DIGITAVEL'];              

        codigoBarras = object['REGISTROS'][prop]['CODIGO_BARRAS'];

        oracledb.getConnection({            
            user: "x",
            password:"xxx",
            connectString: "mycon/string"  
        },
        function(err, connection){  
            if (err){  
                console.error(err.message);  
                return;  
            }

            connection.execute(
                "INSERT INTO USU_TBOLETO VALUES (:USU_CODIGO, :USU_ATEND, :USU_PAGAMENTO, " +
                ":USU_VENCIMENTO, :USU_PROCESSA, :USU_VALOR, :USU_NOSSONUM, :NUMERODOC, :USU_CODBANCO, " +
                ":USU_LINHADIG , :USU_CODBARRAS)",

            [codigo, atendimento, pagamento, vencimento, processamento, valor, nossoNumero, 
            numeroDocumento, codigoBanco, linhaDigitavel, codigoBarras], 
            { autoCommit: true},            
            function(err, result){

                if (err){  
                    console.error(err.message);            
                    doRelease(connection);  
                    return;  
                }
                console.log(codigo + ' - ' + atendimento + ' - ' + pagamento + ' - ' + vencimento);
                ///console.log(result.metaData);  
                ///console.log(result.rows);  
                doRelease(connection);  
            });                  
        }); 
    }   


    function doRelease(connection) {        
        connection.release(  
            function(err){  
                if (err) { console.error(err.message); }  
            }  
        );  
    }
}

问题是它只是在我的数据库中插入了最后一条记录，1029 次，就像总记录一样。为什么？我不明白为什么。 INSERT 代码在 FOR 条件中。

正确的是插入 1029 次，从 codigo 1 开始直到 1029。

Att. 迪奥戈

【问题讨论】：

您的数据库插入是异步的，可能需要一些时间。虽然您的 for 循环几乎立即执行，因此插入将采用上次迭代的值。
看看这个stackoverflow.com/questions/11488014/…

标签： javascript node.js node-oracledb

【解决方案1】：

for 循环几乎立即执行，而数据库操作是异步且缓慢的。 for 循环必须在执行异步操作的回调时完成，因此它只会在循环的最后一次迭代中看到值。

为避免这种情况，您可以使用 ES6s const 声明变量，这将创建块作用域变量。将您的代码更改为此，它应该可以工作：

module.exports = function(object, callback) {

    var oracledb = require('oracledb');
    for (const prop in object['REGISTROS']) {

        const codigo = object['REGISTROS'][prop]['CODIGO'];

        const atendimento = object['REGISTROS'][prop]['ATENDIMENTO'];

        const pagamento = object['REGISTROS'][prop]['PAGAMENTO'];

        const vencimento = object['REGISTROS'][prop]['VENCIMENTO'];

        const processamento = object['REGISTROS'][prop]['PROCESSAMENTO'];

        const valor = parseInt(object['REGISTROS'][prop]['VALOR']);

        const nossoNumero = object['REGISTROS'][prop]['NOSSO_NUMERO'];

        const numeroDocumento = object['REGISTROS'][prop]['NUMERO_DOCUMENTO'];

        const codigoBanco = object['REGISTROS'][prop]['CODIGO_BANCO'];

        const linhaDigitavel = object['REGISTROS'][prop]['LINHA_DIGITAVEL'];

        const codigoBarras = object['REGISTROS'][prop]['CODIGO_BARRAS'];

        oracledb.getConnection({
                user: "x",
                password: "xxx",
                connectString: "mycon/string"
            },
            function(err, connection) {
                if (err) {
                    console.error(err.message);
                    return;
                }

                connection.execute(
                    "INSERT INTO USU_TBOLETO VALUES (:USU_CODIGO, :USU_ATEND, :USU_PAGAMENTO, " +
                    ":USU_VENCIMENTO, :USU_PROCESSA, :USU_VALOR, :USU_NOSSONUM, :NUMERODOC, :USU_CODBANCO, " +
                    ":USU_LINHADIG , :USU_CODBARRAS)",

                    [codigo, atendimento, pagamento, vencimento, processamento, valor, nossoNumero,
                        numeroDocumento, codigoBanco, linhaDigitavel, codigoBarras
                    ], {
                        autoCommit: true
                    },
                    function(err, result) {

                        if (err) {
                            console.error(err.message);
                            doRelease(connection);
                            return;
                        }
                        console.log(codigo + ' - ' + atendimento + ' - ' + pagamento + ' - ' + vencimento);
                        ///console.log(result.metaData);  
                        ///console.log(result.rows);  
                        doRelease(connection);
                    });
            });
    }


    function doRelease(connection) {
        connection.release(
            function(err) {
                if (err) {
                    console.error(err.message);
                }
            }
        );
    }
}

更多关于循环和闭包的信息：

Javascript infamous Loop issue?

JavaScript closure inside loops – simple practical example

Asynchronous Process inside a javascript for loop

【讨论】：

你摇滚@abhishekkannoija 我会研究你为我指出的这个链接。

【解决方案2】：

当您按照当前的结构运行代码时，它会将许多异步操作发送到 libuv 的工作队列，并且您的 JavaScript 代码会失去控制。我建议使用 async module's eachSeries method 来维护控制或承诺链（或 Node.js 7.6+ 中的 async/await）。

此外，为循环的每次迭代建立一个新连接会大大减慢速度！此操作只需要一个连接。您应该获取连接、处理数据、关闭连接。

要重新考虑的另一件事是 autoCommit: true 的使用。如果您对每一行都执行此操作，则您将每个插入视为其自己的事务。如果失败发生在中途，找出哪里出了问题并修复它（插入剩余的行）将是困难的和手动的。我建议在插入所有内容后对连接对象使用 commit 方法（或在循环的最后一次迭代中使用 autoCommit: true ）。

这是一个例子：

const oracledb = require('oracledb');
const config = require('./dbConfig.js');

module.exports = function(object, callback) {
    let conn;

    function insertRegistro(registro, commit) {
        if (commit) {
            console.log('Last iteration of the loop, committing with this one');
        }

        return conn.execute(
            `insert into usu_tboleto (
               usu_codigo, usu_atend, usu_pagamento, usu_vencimento, usu_processa, usu_valor, 
               usu_nossonum, numerodoc, usu_codbanco, usu_linhadig, usu_codbarras
             ) values (
               :usu_codigo, :usu_atend, :usu_pagamento, :usu_vencimento, :usu_processa, :usu_valor, 
               :usu_nossonum, :numerodoc, :usu_codbanco, :usu_linhadig , :usu_codbarras
            )`,
            {
                usu_codigo: registro.CODIGO,
                usu_atend: registro.ATENDIMENTO,
                usu_pagamento: registro.PAGAMENTO,
                usu_vencimento: registro.VENCIMENTO,
                usu_processa: registro.PROCESSAMENTO,
                usu_valor: registro.VALOR,
                usu_nossonum: registro.NOSSO_NUMERO,
                numerodoc: registro.NUMERO_DOCUMENTO,
                usu_codbanco: registro.CODIGO_BANCO,
                usu_linhadig: registro.LINHA_DIGITAVEL,
                usu_codbarras: registro.CODIGO_BARRAS
            },
            {
                autoCommit: commit
            }
        );
    }

    oracledb.getConnection(config)
        .then(function(c) {
            conn = c;

            console.log('Got connection, starting loop');

            let promiseChain = Promise.resolve();

            object['REGISTROS'].forEach(function(registro, index) {
                promiseChain = promiseChain
                    .then(function() {
                        return insertRegistro(registro, object['REGISTROS'].length === index + 1);
                    });
            });

            return promiseChain;
        })
        .catch(function(err) {
            console.log(err);
            console.log('Encountered error, rolling back transaction');

            return conn.rollback()
                .then(function() {
                    console.log('Transaction rolled back');
                })
                .catch(function(err) {
                    console.log('Error rolling back', err);
                });
        })
        .then(function() {
            return conn.close();
        })
        .then(function() {
            console.log('Connection closed');
        })
        .catch(function(err) {
            console.log(err);
        });
}

您可以通过将往返次数从 1029 次减少到 1 次（一次全部执行）或 3 次（如果您一次执行 500 组）来进一步优化这一点。这将大大提高性能。这是一个以 500 个为一组进行批量插入的示例。

const oracledb = require('oracledb');
const config = require('./dbConfig.js');

module.exports = function(object, callback) {
  let conn;

  function insertRegistros(opts) {
    if (opts.commit) {
        console.log('Last iteration of the loop, committing with this one');
    }

    return conn.execute(
     `declare
        type varchar2_aat is table of varchar2(50)
          index by pls_integer;

        l_usu_codigo_vals varchar2_aat;

      begin

        l_usu_codigo_vals := :usu_codigo_vals;

        forall x in 1 .. l_usu_codigo_vals.count
        insert into usu_tboleto (
          usu_codigo, usu_atend, usu_pagamento, usu_vencimento, usu_processa, usu_valor, 
          usu_nossonum, numerodoc, usu_codbanco, usu_linhadig, usu_codbarras
        ) values (
          :usu_codigo_vals(x), :usu_atend_vals(x), :usu_pagamento_vals(x), :usu_vencimento_vals(x), :usu_processa_vals(x), :usu_valor_vals(x), 
          :usu_nossonum_vals(x), :numerodoc_vals(x), :usu_codbanco_vals(x), :usu_linhadig_vals(x) , :usu_codbarras_vals(x)
        );

      end;`,
      {
        usu_codigo_vals: {type: oracledb.STRING, dir: oracledb.BIND_IN, val: opts.usu_codigo_vals},
        usu_atend_vals: {type: oracledb.STRING, dir: oracledb.BIND_IN, val: opts.usu_atend_vals},
        usu_pagamento_vals: {type: oracledb.STRING, dir: oracledb.BIND_IN, val: opts.usu_pagamento_vals},
        usu_vencimento_vals: {type: oracledb.STRING, dir: oracledb.BIND_IN, val: opts.usu_vencimento_vals},
        usu_processa_vals: {type: oracledb.STRING, dir: oracledb.BIND_IN, val: opts.usu_processa_vals},
        usu_valor_vals: {type: oracledb.STRING, dir: oracledb.BIND_IN, val: opts.usu_valor_vals},
        usu_nossonum_vals: {type: oracledb.STRING, dir: oracledb.BIND_IN, val: opts.usu_nossonum_vals},
        numerodoc_vals: {type: oracledb.STRING, dir: oracledb.BIND_IN, val: opts.numerodoc_vals},
        usu_codbanco_vals: {type: oracledb.STRING, dir: oracledb.BIND_IN, val: opts.usu_codbanco_vals},
        usu_linhadig_vals: {type: oracledb.STRING, dir: oracledb.BIND_IN, val: opts.usu_linhadig_vals},
        usu_codbarras_vals: {type: oracledb.STRING, dir: oracledb.BIND_IN, val: opts.usu_codbarras_vals}
      },
      {
        autoCommit: opts.commit
      }
    );
  }

  oracledb.getConnection(config)
    .then(function(c) {
      conn = c;

      console.log('Got connection, starting loop');

      const batchRowCount = 500;
      const loops = Math.ceil(object['REGISTROS'].length / batchRowCount);

      let promiseChain = Promise.resolve();
      let registrosIdx = 0;

      for (let outerIndex = 0; outerIndex < loops; outerIndex += 1) {
        (function() {
          const usu_codigo_vals = [];
          const usu_atend_vals = [];
          const usu_pagamento_vals = [];
          const usu_vencimento_vals = [];
          const usu_processa_vals = [];
          const usu_valor_vals = [];
          const usu_nossonum_vals = [];
          const numerodoc_vals = [];
          const usu_codbanco_vals = [];
          const usu_linhadig_vals = [];
          const usu_codbarras_vals = [];

          for (let idx = 0; idx < batchRowCount; idx += 1) {
            if (registrosIdx === object['REGISTROS'].length) {
              break;
            }

            usu_codigo_vals.push(object['REGISTROS'][registrosIdx].CODIGO);
            usu_atend_vals.push(object['REGISTROS'][registrosIdx].ATENDIMENTO);
            usu_pagamento_vals.push(object['REGISTROS'][registrosIdx].PAGAMENTO);
            usu_vencimento_vals.push(object['REGISTROS'][registrosIdx].VENCIMENTO);
            usu_processa_vals.push(object['REGISTROS'][registrosIdx].PROCESSAMENTO);
            usu_valor_vals.push(object['REGISTROS'][registrosIdx].VALOR);
            usu_nossonum_vals.push(object['REGISTROS'][registrosIdx].NOSSO_NUMERO);
            numerodoc_vals.push(object['REGISTROS'][registrosIdx].NUMERO_DOCUMENTO);
            usu_codbanco_vals.push(object['REGISTROS'][registrosIdx].CODIGO_BANCO);
            usu_linhadig_vals.push(object['REGISTROS'][registrosIdx].LINHA_DIGITAVEL);
            usu_codbarras_vals.push(object['REGISTROS'][registrosIdx].CODIGO_BARRAS);

            registrosIdx += 1;
          }

          promiseChain = promiseChain
            .then(function() {
              return insertRegistros({
                usu_codigo_vals: usu_codigo_vals, 
                usu_atend_vals: usu_atend_vals,
                usu_pagamento_vals: usu_pagamento_vals,
                usu_vencimento_vals: usu_vencimento_vals,
                usu_processa_vals: usu_processa_vals,
                usu_valor_vals: usu_valor_vals,
                usu_nossonum_vals: usu_nossonum_vals,
                numerodoc_vals: numerodoc_vals,
                usu_codbanco_vals: usu_codbanco_vals,
                usu_linhadig_vals: usu_linhadig_vals,
                usu_codbarras_vals: usu_codbarras_vals,
                commit: outerIndex + 1 === loops
              });
            });
        })();
      }

      return promiseChain;
    })
    .catch(function(err) {
      console.log(err);
      console.log('Encountered error, rolling back transaction');

      return conn.rollback()
        .then(function() {
          console.log('Transaction rolled back');
        })
        .catch(function(err) {
          console.log('Error rolling back', err);
        });
    })
    .then(function() {
        return conn.close();
    })
    .then(function() {
        console.log('Connection closed');
    })
    .catch(function(err) {
        console.log(err);
    });
}

如您所见，代码有点棘手。但是，当驱动程序添加对绑定记录数组的支持而不仅仅是字符串或数字时，这应该会变得更简单。

您可以在此处在我的博客上阅读有关此内容以及我正在使用的解决方法的更多信息： https://jsao.io/2017/01/plsql-record-types-and-the-node-js-driver/

【讨论】：

谢谢丹！如您所见，我是 JS 新手，您的解释对我帮助很大！我超级感兴趣！
嗨 Diogo，我已经用一个批量示例更新了答案。我希望这会有所帮助！