MySQL과 함께 사용하는 node.js 비동기/wait

MySQL과 함께 사용하는 node.js 비동기/wait

모든 결과를 동기화하고 c#와 같은 비동기/대기 키워드가 있는 문자열에 추가해야 합니다.

나는 node.js에 익숙하지 않아서 이 새로운 구문을 내 코드에 적용할 수 없습니다.

var string1 = '';
var string2 = '';
var string3 = '';
var string4 = '';

DatabasePool.getConnection(function(err, connection) {

        connection.query(query,function (err, result) {
            if (err){};
            string1 = result;
        });

        connection.query(query,function (err, result) {
            if (err){};
            string2 = result;
        });     

        connection.query(query,function (err, result) {
            if (err){};
            string3 = result;   
        });

        connection.query(query,function (err, result) {
            if (err){};
            string4 = result;
        }); 

       //I need to append all these strings to appended_text but  
       //all variables remain blank because below code runs first.
       var appended_text = string1 + string2 + string3 + string4;
});

Node 8+에 있는 경우 네이티브를 활용할 수 있습니다.util.promisify()mysql 노드를 사용합니다.

로 전화하는 것을 잊지 마십시오.bind()그래서this망치지 않음:

const mysql = require('mysql'); // or use import if you use TS
const util = require('util');
const conn = mysql.createConnection({yourHOST/USER/PW/DB});

// node native promisify
const query = util.promisify(conn.query).bind(conn);

(async () => {
  try {
    const rows = await query('select count(*) as count from file_managed');
    console.log(rows);
  } finally {
    conn.end();
  }
})()

mysql2 패킷을 사용합니다.약속 래퍼가 있으므로 다음을 수행할 수 있습니다.

async function example1 () {
  const mysql = require('mysql2/promise');
  const conn = await mysql.createConnection({ database: test });
  let [rows, fields] = await conn.execute('select ?+? as sum', [2, 2]);
}

ORM에서 약속 기반으로 사용한다고 가정하면 다음과 같은 작업을 수행할 수 있습니다.

async function buildString() {
  try {
    const connection = await DatabasePool.getConnection();
    const string1 = await connection.query(query);
    const string2 = await connection.query(query);
    const string3 = await connection.query(query);
    const string4 = await connection.query(query);

    return string1 + string2 + string3 + string4;
  } catch (err) {
    // do something
  }
}

모든 약속은 다음을 수행하여 비동기/대기와 함께 사용할 수 있습니다.await전화 앞에서.그러나 이 기능은 다음과 같이 사용해야 합니다.async함수 "discovery".의 오류를 처리해야 합니다.try/catch블록들

이 4개의 쿼리가 동시에 실행되지 않는다는 점도 지적하고 싶습니다.Promise를 계속 사용해야 합니다.그 때문에

mysql(mysqljs라고도 함)을 사용하려면 래퍼를 사용하지 않으려면 약간의 작업을 해야 합니다.하지만 충분히 쉽습니다.연결 기능은 다음과 같습니다.

const mysql = require('mysql')

var my_connection = mysql.createConnection({ ... })

async function connect()
{
    try
    {
        await new Promise((resolve, reject) => {
            my_connection.connect(err => {
                return err ? reject(err) : resolve()
            })
        })
    }
    catch(err)
    {
        ...handle errors...
    }
}

connect()

보시다시피 대기자는 약속을 처리하는 방법을 알게 될 것입니다.이러한 기능을 만들고 콜백 구현에서 해결/거부 기능을 사용합니다.데이터베이스에 많이 액세스하지 않는 한 포장지를 사용하는 것이 다소 부담스러울 수 있습니다.

또는 mysql-async-simple을 사용합니다.

https://www.npmjs.com/package/mysql-async-simple

const { makeDb } = require('mysql-async-simple');
const mysql = require("mysql");
 
const connection = mysql.createConnection({
    host: process.env.HOST,
    user: process.env.USER,
    password: process.env.PASSWORD,
    database: process.env.DB
});
const db = makeDb();
await db.connect(connection);
 
try {
    const users = await db.query(connection, 'SELECT * FROM users');
} catch (e) {
    // handle exception
} finally {
    await db.close(connection);
}

LeOn - Han Li에 의해 언급된 바와 같이, 저는 결과에 대해 작업해야 했기 때문에 작은 수정 사항을 포함합니다.

var mysql = require('mysql');
const util = require('util');

const conn = mysql.createConnection({
  host     : '127.0.0.1',
  user     : 'user',
  password : 'password',
  database : 'database'
});

const query = util.promisify(conn.query).bind(conn);

let result = async function() {
    var userCourse = [];
    try {
        const rows = await query('select * as count from file_managed');
    } finally {
        conn.end();
        return userCourse;
    }
};

result()
.then(value => {
    console.log(value)
});

패키지는 다음과 같이 사용할 수 있습니다.

const mysql = require('promise-mysql')

const getDbConnection = async () => {
  return await mysql.createConnection({
    host: process.env.HOST,
    user: process.env.USER,
    password: process.env.PASSWORD,
    database: process.env.DB
  })
}

const getUsers = async () => {
  const db = await getDbConnection()
  const users = await db.query("SELECT * FROM users")
  await db.end()
  return users
}

사용 중인 mysql 라이브러리가 다음에 필요한 약속을 지원하는지 확인해야 합니다.async/await또는 Bluebird's와 같은 도구를 사용하여 라이브러리를 포장합니다.

async function appendedText() {
  const connection = await DatabasePool.getConnectionAsync();
  const [string1, string2, string3, string4] = await [
    connection.query(query1),
    connection.query(query2),
    connection.query(query3),
    connection.query(query4),
  ];
  return string1 + string2 + string3 + string4;
}

호출에 유의하십시오.appendedText()실제로는 값이 아닌 약속을 반환합니다.

appendedText().then(appended_text => {});

const { makeDb } = require('mysql-async-simple');
const mysql = require("mysql");
 
const connection = mysql.createConnection({
    host: process.env.HOST,
    user: process.env.USER,
    password: process.env.PASSWORD,
    database: process.env.DB
});
const db = makeDb();
await db.connect(connection);
 
try {
    const users = await db.query(connection, 'SELECT * FROM users');
} catch (e) {
    // handle exception
} finally {
    await db.close(connection);
}

당신은 약속된 기반 라이브러리가 아닌 mysqljs를 사용하는 것 같습니다.그래서 당신은 이 도서관을 이용해서 당신이 원하는 것을 이룰 수 없습니다.따라서 다음과 같이 Sequitize와 같은 약속된 기반 라이브러리를 사용할 수 있습니다.

Bluebird의 약속과 같은 도구를 사용합니다.모두 도서관을 포장합니다.

저는 포장에 대해 잘 모릅니다. 그래서 제가 한 일은 속편으로 바꾸는 것이었습니다.

util 또는 promise/mysql을 사용하는 대신 mysql.connect 내에서 promise를 구현할 수 있습니다.

varcon = required ";

var mysql = con.createConnection({
    host: "localhost",
    user: "root",
    password: "pass",
    database: "test"
});

async function asyncAwait(req, res) {
    var promise1;
    mysql.connect((err) => {
        promise1 = new Promise((resolve, reject) => {
            console.log('Mysql: Connected');
            resolve(response.write(uc.upperCase('Connected\n')));
        });
        promise1
            .then(() => {
             //Implement the logic here
            })
            .catch(error => {
                console.log(error)
            });
    })
}
await asyncAwait();

나의 경우 약속이고 다음과 같이 해결되는 도우미 기능을 만들어야 했습니다.

const mysqlQuery = async (connection, queryConfig) => {
    const config = { ...queryConfig, timeout: 4000 }

   return new Promise((resolve, reject) => {
     return connection.query(config, function (error, results, fields) {
        if (error) {
            reject(error);
        }
        resolve(results);
      });
   })
}

이제 나는 위의 것들을 쉽게 사용할 수 있습니다.

    const response = await mysqlQuery(connection, {
       sql: 'SELECT * FROM `user`',
    });

     console.log(response)

연결은 어디에 있습니까? 아래와 같이 mysql 연결입니다.

    var connection = mysql.createConnection({
        host,
        user, //
        password, //
        database,
        port
    })
   
    connection.connect(async (err) => {
          if(err){
             //connection error
             return;
           }

         //successifull connection
     })

언급URL : https://stackoverflow.com/questions/44004418/node-js-async-await-using-with-mysql