MySQL2

npm install mysql2

const mysql = require('mysql2');

const connection = mysql.createConnection({
  host: 'localhost',
  port: 3306,
  user: 'root',
  password: 'password',
  database: 'my_database',
});

connection.query('SELECT * FROM users WHERE id = ?', [1], (err, results) => {
  if (err) throw err;
  console.log(results);
});

connection.end();

const mysql = require('mysql2');

const pool = mysql.createPool({
  host: 'localhost',
  port: 3306,
  user: 'root',
  password: 'password',
  database: 'my_database',
  connectionLimit: 10,       // 최대 커넥션 수
  waitForConnections: true,  // 풀이 꽉 차면 대기할지 여부
  queueLimit: 0,             // 대기 큐 제한 (0 = 무제한)
});

// 방법 1: pool.query() — 간단한 단일 쿼리
pool.query('SELECT * FROM users WHERE id = ?', [1], (err, results) => {
  // 커넥션을 자동으로 가져오고 반환한다
  console.log(results);
});

// 방법 2: pool.getConnection() — 여러 쿼리를 하나의 커넥션에서 실행
pool.getConnection((err, connection) => {
  if (err) throw err;

  connection.query('SELECT * FROM users', (err, results) => {
    console.log(results);
    connection.release(); // 반드시 반환해야 한다!
  });
});

let connection;
try {
  connection = await pool.promise().getConnection();
  const [rows] = await connection.query('SELECT * FROM users');
  return rows;
} catch (error) {
  console.error('쿼리 실행 오류:', error.message);
  throw error;
} finally {
  if (connection) connection.release(); // 에러가 나든 안 나든 반환
}

const mysql = require('mysql2/promise');

async function main() {
  const pool = mysql.createPool({
    host: 'localhost',
    user: 'root',
    password: 'password',
    database: 'my_database',
    connectionLimit: 10,
  });

  // async/await으로 깔끔하게 사용
  const [rows, fields] = await pool.query('SELECT * FROM users WHERE age > ?', [20]);
  console.log(rows);    // 결과 배열
  console.log(fields);  // 컬럼 메타데이터
}

const mysql = require('mysql2');

// 콜백 방식으로 풀 생성
const pool = mysql.createPool({ /* ... */ });

// Promise 래퍼 획득
const promisePool = pool.promise();

// 이제 async/await 사용 가능
const [rows] = await promisePool.query('SELECT 1');

// ❌ 위험: 문자열 결합
const query = `SELECT * FROM users WHERE name = '${userInput}'`;

// ✅ 안전: Prepared Statement
const [rows] = await pool.execute('SELECT * FROM users WHERE name = ?', [userInput]);

// execute()는 서버 사이드 Prepared Statement를 사용
const [rows] = await pool.execute('SELECT * FROM users WHERE age > ?', [20]);

// query()는 클라이언트 사이드 치환만 한다
const [rows2] = await pool.query('SELECT * FROM users WHERE age > ?', [20]);

const pool = mysql.createPool({
  // ...
  maxPreparedStatements: 200, // 커넥션당 최대 Prepared Statement 수 (기본: 16000)
});

const pool = mysql.createPool({
  // ...
  supportBigNumbers: true,   // BigInt 값을 안전하게 처리
  bigNumberStrings: true,    // BigInt를 String으로 반환
});

const pool = mysql.createPool({
  // ...
  typeCast: function (field, next) {
    if (field.type === 'BIT' && field.length === 1) {
      // BIT(1)을 boolean으로 변환
      const bytes = field.buffer();
      return bytes ? bytes[0] === 1 : null;
    }
    return next(); // 나머지는 기본 변환
  },
});

const pool = mysql.createPool({
  // ...
  namedPlaceholders: true,
});

const [rows] = await pool.execute(
  'SELECT * FROM users WHERE name = :name AND age > :minAge',
  { name: 'Alice', minAge: 20 }
);

await pool.execute(
  `INSERT INTO users (name, email, age, role, status)
   VALUES (:name, :email, :age, :role, :status)`,
  { name: 'Bob', email: 'bob@example.com', age: 25, role: 'user', status: 'active' }
);

const stream = pool.pool          // 내부 풀 객체 접근
  .query('SELECT * FROM large_table')
  .stream();

stream.on('data', (row) => {
  // 한 행씩 처리
  processRow(row);
});

stream.on('end', () => {
  console.log('모든 행 처리 완료');
});

stream.on('error', (err) => {
  console.error('스트리밍 에러:', err);
});

const connection = await pool.getConnection();

try {
  await connection.beginTransaction();

  await connection.execute(
    'UPDATE accounts SET balance = balance - ? WHERE id = ?',
    [100, fromAccountId]
  );
  await connection.execute(
    'UPDATE accounts SET balance = balance + ? WHERE id = ?',
    [100, toAccountId]
  );

  await connection.commit();
} catch (error) {
  await connection.rollback();
  throw error;
} finally {
  connection.release();
}

// TypeORM이 내부적으로 mysql2를 사용
const dataSource = new DataSource({
  type: 'mysql',        // mysql2 드라이버를 사용
  host: 'localhost',
  port: 3306,
  username: 'root',
  password: 'password',
  database: 'my_database',
  extra: {
    connectionLimit: 10,    // mysql2 풀 옵션을 extra로 전달
    maxPreparedStatements: 200,
  },
});

import * as mysql from 'mysql2/promise';
import { PoolConnection } from 'mysql2/promise';

export class DatabaseAccess {
  private pool: mysql.Pool;

  constructor() {
    this.pool = mysql.createPool({
      host: process.env.DB_HOST,
      port: parseInt(process.env.DB_PORT),
      user: process.env.DB_USER,
      password: process.env.DB_PASSWORD,
      database: process.env.DB_NAME,
      connectionLimit: 10,
    });
  }

  async executeQuery<T>(query: string, params: any[] = []): Promise<T[] | null> {
    let connection: PoolConnection;
    try {
      connection = await this.pool.getConnection();
      const [rows] = await connection.query(query, params);
      return rows as T[];
    } catch (error) {
      console.error(`쿼리 실행 오류: ${error.message}`);
      return null;
    } finally {
      if (connection) connection.release();
    }
  }

  async end(): Promise<void> {
    await this.pool.end();
  }
}