약속을 사용하여 node.js에서 MySQL 반환 값을 처리합니다.

약속을 사용하여 node.js에서 MySQL 반환 값을 처리합니다.

저는 파이썬 배경을 가지고 있고 현재 node.js로 마이그레이션 중입니다.node.js는 비동기 특성상 적응에 문제가 있습니다.

예를 들어 MySQL 함수에서 값을 반환하려고 합니다.

function getLastRecord(name)
{
    var connection = getMySQL_connection();

    var query_str =
    "SELECT name, " +
    "FROM records " +   
    "WHERE (name = ?) " +
    "LIMIT 1 ";

    var query_var = [name];

    var query = connection.query(query_str, query_var, function (err, rows, fields) {
        //if (err) throw err;
        if (err) {
            //throw err;
            console.log(err);
            logger.info(err);
        }
        else {
            //console.log(rows);
            return rows;
        }
    }); //var query = connection.query(query_str, function (err, rows, fields) {
}

var rows = getLastRecord('name_record');

console.log(rows);

어느 정도 읽어보니 위 코드가 작동할 수 없고 node.js의 비동기적인 특성으로 인해 약속을 반환해야 한다는 것을 알게 되었습니다.python처럼 node.js 코드를 쓸 수 없습니다.법을 어떻게 wgetLastRecord()약속을 반환하고 반환된 값을 처리하려면 어떻게 해야 합니까?

사실 제가 하고 싶은 것은 이런 것입니다.

if (getLastRecord() > 20)
{
    console.log("action");
}

어떻게 node.js에서 읽을 수 있는 방법으로 이것을 할 수 있습니까?

이 경우 파랑새를 이용하여 어떻게 약속을 이행할 수 있는지를 보고 싶습니다.

이건 좀 흩어질거에요, 용서해주세요.

첫째, 이 코드가 mysql 드라이버 API를 정확하게 사용한다고 가정하면 네이티브 약속으로 작동하도록 랩핑할 수 있는 한 가지 방법이 있습니다.

function getLastRecord(name)
{
    return new Promise(function(resolve, reject) {
        // The Promise constructor should catch any errors thrown on
        // this tick. Alternately, try/catch and reject(err) on catch.
        var connection = getMySQL_connection();

        var query_str =
        "SELECT name, " +
        "FROM records " +   
        "WHERE (name = ?) " +
        "LIMIT 1 ";

        var query_var = [name];

        connection.query(query_str, query_var, function (err, rows, fields) {
            // Call reject on error states,
            // call resolve with results
            if (err) {
                return reject(err);
            }
            resolve(rows);
        });
    });
}

getLastRecord('name_record').then(function(rows) {
    // now you have your rows, you can see if there are <20 of them
}).catch((err) => setImmediate(() => { throw err; })); // Throw async to escape the promise chain

그래서 한 가지는.아직 콜백이 남아있습니다.콜백은 미래의 어느 시점에서 선택한 인수와 함께 호출할 대상에게 넘겨주는 기능일 뿐입니다.서의수는s의 .xs.map(fn) , , , , , , , , , , , , , , , , , , .(err, result)노드에 표시되는 함수와 약속 결과 및 오류 처리기는 모두 콜백입니다.이것은 사람들이 특정 종류의 콜백을 "콜백(callback)"이라고 부르는 것에 의해 다소 혼란스럽습니다.(err, result)노드 코어에서 사용되는 "연속 확장 스타일"은 자신을 별로 좋아하지 않는 사람들이 "노드백"이라고 부르기도 합니다.

지금으로서는 적어도 (결국에는) 약속을 채택하든 안하든 상관없이 콜백에 갇혀 있을 것입니다.

또한 약속이 즉각적이고 분명하게 도움이 되는 것은 아닙니다. 아직 콜백이 있기 때문입니다.약속은 당신이 그것들과 결합할 때만 빛납니다.Promise.all에게 la게라속고라m게고de속asArray.prototype.reduce. 하지만 그들은 때때로 빛을 발하고, 배울 가치가 있습니다.

Q(NPM module) 약속을 사용하도록 코드를 수정하였습니다.위의 토막글에서 지정한 'getLastRecord()' 함수가 올바르게 작동한다고 가정했습니다.

Q 모듈을 확보하려면 다음 링크를 참조할 수 있습니다.

여기 클릭 : Q 설명서

var q = require('q');

function getLastRecord(name)
{

var deferred = q.defer(); // Use Q 
var connection = getMySQL_connection();

var query_str =
"SELECT name, " +
"FROM records " +   
"WHERE (name = ?) " +
"LIMIT 1 ";

var query_var = [name];

var query = connection.query(query_str, query_var, function (err, rows, fields) {
    //if (err) throw err;
    if (err) {
        //throw err;           
        deferred.reject(err);
    }
    else {
        //console.log(rows);           
        deferred.resolve(rows);
    }
}); //var query = connection.query(query_str, function (err, rows, fields) {

return deferred.promise;
}



// Call the method like this
getLastRecord('name_record')
 .then(function(rows){
   // This function get called, when success
   console.log(rows);
  },function(error){
   // This function get called, when error
   console.log(error);

 });

Node.js와 약속은 처음입니다.저는 제 요구에 맞는 것을 찾고 있었는데, 제가 발견한 몇 가지 예시를 종합해서 사용하게 되었습니다.완료된 후 하는 기능을 (을가된후로할수다는을여(다i을는t당 )querySql또는 풀에서 연결을 가져와 Promise.scope를 사용하거나 원할 때 언제든지 해제(getSqlConnection이 방법을 사용하면 여러 쿼리를 중첩하지 않고 연속적으로 정렬할 수 있습니다.

db.js

var mysql = require('mysql');
var Promise = require("bluebird");

Promise.promisifyAll(mysql);
Promise.promisifyAll(require("mysql/lib/Connection").prototype);
Promise.promisifyAll(require("mysql/lib/Pool").prototype);

var pool = mysql.createPool({
    host: 'my_aws_host',
    port: '3306',
    user: 'my_user',
    password: 'my_password',
    database: 'db_name'
});

function getSqlConnection() {
    return pool.getConnectionAsync().disposer(function (connection) {
        console.log("Releasing connection back to pool")
        connection.release();
    });
}

function querySql (query, params) {
    return Promise.using(getSqlConnection(), function (connection) {
        console.log("Got connection from pool");
        if (typeof params !== 'undefined'){
            return connection.queryAsync(query, params);
        } else {
            return connection.queryAsync(query);
        }
    });
};

module.exports = {
    getSqlConnection : getSqlConnection,
    querySql : querySql
};

use_graphics.js

var express = require('express');
var router = express.Router();

var dateFormat = require('dateformat');
var db = require('../my_modules/db');
var getSqlConnection = db.getSqlConnection;
var querySql = db.querySql;

var Promise = require("bluebird");

function retrieveUser(token) {
  var userQuery = "select id, email from users where token = ?";
  return querySql(userQuery, [token])
     .then(function(rows){
        if (rows.length == 0) {
          return Promise.reject("did not find user");
        }

        var user = rows[0];
        return user;
     });
}

router.post('/', function (req, res, next) {

  Promise.resolve().then(function () {
    return retrieveUser(req.body.token);
  })
    .then(function (user){
      email = user.email;
      res.status(200).json({ "code": 0, "message": "success", "email": email});
    })
    .catch(function (err) {
      console.error("got error: " + err);
      if (err instanceof Error) {
        res.status(400).send("General error");
      } else {
        res.status(200).json({ "code": 1000, "message": err });
      }
    });
});

module.exports = router;

아직 노드가 처음이라 뭔가를 놓쳤나 봅니다. 어떻게 되는지 알려주세요.비동기 노드를 트리거하는 대신 사용자에게 강요하기 때문에 미리 생각하고 계획해야 합니다.

const mysql = require('mysql');
const db = mysql.createConnection({
          host: 'localhost', 
          user: 'user', password: 'password', 
          database: 'database',
      });
      db.connect((err) => {
          // you should probably add reject instead of throwing error
          // reject(new Error()); 
          if(err){throw err;}
          console.log('Mysql: Connected');
      });
      db.promise = (sql) => {
          return new Promise((resolve, reject) => {
              db.query(sql, (err, result) => {
                if(err){reject(new Error());}
                else{resolve(result);}
              });
          });
      };

여기서 나는 mysql 모듈을 일반적인 것처럼 사용하고 있지만 대신 dbcst에 추가하여 약속을 미리 처리할 수 있는 새로운 기능을 만들었습니다.(많은 노드 예에서 이를 "연결"로 볼 수 있습니다.

이제 약속을 사용하여 mysql 쿼리를 호출합니다.

      db.promise("SELECT * FROM users WHERE username='john doe' LIMIT 1;")
      .then((result)=>{
          console.log(result);
      }).catch((err)=>{
          console.log(err);
      });

첫 번째 쿼리를 기반으로 두 번째 쿼리를 수행해야 하는 경우에 유용합니다.

      db.promise("SELECT * FROM users WHERE username='john doe' LIMIT 1;")
      .then((result)=>{
          console.log(result);
          var sql = "SELECT * FROM friends WHERE username='";
              sql = result[0];
              sql = "';"
          return db.promise(sql);
      }).then((result)=>{
          console.log(result);
      }).catch((err)=>{
          console.log(err);
      });

실제로는 mysql 변수를 사용해야 하지만, 적어도 mysql 모듈과의 약속을 사용하는 예를 들어줘야 합니다.

또한 위와 같이 db를 계속 사용할 수 있습니다.이러한 약속 내에서 언제든지 정상적인 방법을 쿼리합니다. 그들은 그저 정상적인 것처럼 작동합니다.

이것이 죽음의 삼각관계에 도움이 되기를 바랍니다.

약속을 사용할 필요가 없고 콜백 기능을 사용할 수 있습니다.

function getLastRecord(name, next)
{
    var connection = getMySQL_connection();

    var query_str =
    "SELECT name, " +
    "FROM records " +    
    "LIMIT 1 ";

    var query_var = [name];

    var query = connection.query(query_str, query_var, function (err, rows, fields) {
        //if (err) throw err;
        if (err) {
            //throw err;
            console.log(err);
            logger.info(err);
            next(err);
        }
        else {
            //console.log(rows);
            next(null, rows);
        }
    }); //var query = connection.query(query_str, function (err, rows, fields) {
}

getLastRecord('name_record', function(err, data) {
   if(err) {
      // handle the error
   } else {
      // handle your data

   }
});

패키지 promise-mysql을 사용하는 논리는 다음을 사용하여 약속을 연결하는 것입니다(함수(응답){your code}).

그리고.

catch(function(response){your code})를 사용하여 catch 블록 앞에 있는 "그때" 블록에서 오류를 잡습니다.

이 논리에 따라 블록의 끝에 있는 반환을 사용하여 개체 또는 배열에 쿼리 결과를 전달합니다.반환은 쿼리 결과를 다음 블록으로 전달하는 데 도움이 됩니다.그런 다음 함수 인수에서 결과를 찾습니다(여기서는 test1입니다).이 논리를 사용하면 여러 MySql 쿼리와 결과를 조작하는 데 필요한 코드를 체인으로 연결하여 원하는 작업을 수행할 수 있습니다.

모든 블록에서 생성되는 모든 개체와 변수는 로컬만이므로 Connection 개체는 전역으로 생성됩니다."그때" 블록을 더 많이 연결할 수 있다는 것을 잊지 마세요.

var config = {
    host     : 'host',
    user     : 'user',
    password : 'pass',
    database : 'database',

  };
  var mysql = require('promise-mysql');
  var connection;
  let thename =""; // which can also be an argument if you embed this code in a function

  mysql.createConnection(config
  ).then(function(conn){
      connection = conn;
      let test = connection.query('select name from records WHERE name=? LIMIT 1',[thename]);
      return test;
  }).then(function(test1){
      console.log("test1"+JSON.stringify(test1)); // result of previous block
      var result = connection.query('select * from users'); // A second query if you want
      connection.end();
 connection = {};
      return result;
  }).catch(function(error){
      if (connection && connection.end) connection.end();
      //logs out the error from the previous block (if there is any issue add a second catch behind this one)
      console.log(error);
  });

처음 질문에 대답하기어떻게 node.js에서 읽을 수 있는 방법으로 이것을 할 수 있습니까?

동기 워크플로우에서 비동기 코드를 작성할 수 있는 "라는 라이브러리가 있습니다.그냥 한번 봐봐요.npm install co.

그 접근법으로 자주 직면하는 문제는, 당신이 이해하지 못한다는 것입니다.Promise당신이 사용하고 싶은 모든 도서관에서 돌아옵니다.하거나(@ Holbrook의) 를 찾거나변(@Joshua Holbrook)e:npm install mysql-promise)

(의 워크플로우를 할 수 있습니다(Btw: 를 ES7 의 를 으로 할 에 하여 에 할 async await, node: node feature list에 아직 없습니다.)

이 작업은 아주 간단하게 수행할 수 있습니다. 예를 들어, 요청하신 대로 파랑새를 사용하면 다음과 같이 수행할 수 있습니다.

var Promise = require('bluebird');

function getLastRecord(name)
{
    return new Promise(function(resolve, reject){
        var connection = getMySQL_connection();

        var query_str =
            "SELECT name, " +
            "FROM records " +
            "WHERE (name = ?) " +
            "LIMIT 1 ";

        var query_var = [name];

        var query = connection.query(query_str, query_var, function (err, rows, fields) {
            //if (err) throw err;
            if (err) {
                //throw err;
                console.log(err);
                logger.info(err);
                reject(err);
            }
            else {
                resolve(rows);
                //console.log(rows);
            }
        }); //var query = connection.query(query_str, function (err, rows, fields) {
    });
}


getLastRecord('name_record')
    .then(function(rows){
        if (rows > 20) {
            console.log("action");
        }
    })
    .error(function(e){console.log("Error handler " + e)})
    .catch(function(e){console.log("Catch handler " + e)});

@Dillon Burnet 답변을 확장하여 다른 사람들에게 도움이 될 수 있습니다.

비동기/대기 및 파라미터 사용

db.promise = (sql, params) => {
    return new Promise((resolve, reject) => {
      db.query(sql,params, (err, result) => {
          if(err){reject(new Error());}
             else{resolve(result);}
          });
       });
};
module.exports = db;

   

 async connection(){
    const result = await db.promise("SELECT * FROM users WHERE username=?",[username]);
       return result;
    }

언급URL : https://stackoverflow.com/questions/36547292/use-promise-to-process-mysql-return-value-in-node-js