Node.js 데이터베이스 연동 완벽 가이드: RDBMS부터 NoSQL, 그리고 ORM까지

데이터베이스의 다양한 세계: RDBMS, NoSQL, 그리고 그래프 데이터베이스

데이터베이스는 데이터를 구조적으로 저장하고 관리하는 시스템입니다. 하지만 모든 데이터가 동일한 구조를 가지는 것은 아니며, 따라서 다양한 종류의 데이터베이스가 존재합니다. 각각의 데이터베이스는 특정 종류의 데이터를 저장하고 관리하는 데 최적화되어 있으며, 프로젝트 요구사항에 맞는 데이터베이스를 선택하는 것이 중요합니다.

1. 관계형 데이터베이스 (RDBMS)

관계형 데이터베이스(RDBMS)는 데이터를 테이블 형태로 구성하고, 테이블 간의 관계를 정의하여 데이터를 저장합니다. SQL(Structured Query Language)을 사용하여 데이터를 쿼리하고 조작합니다.

• 예시: MySQL, PostgreSQL, Oracle Database, Microsoft SQL Server
• 특징:
  • ACID (Atomicity, Consistency, Isolation, Durability) 속성: 트랜잭션의 안정성을 보장합니다.
  • 정형 데이터에 적합: 행과 열로 구성된 테이블 구조로 데이터를 표현하기에 정형화된 데이터에 적합합니다.
  • 복잡한 쿼리: JOIN 연산을 통해 여러 테이블의 데이터를 효율적으로 조회할 수 있습니다.
  • 스키마 정의: 엄격한 스키마를 정의하고 데이터 무결성을 유지해야 합니다.

실용 예제 (MySQL):
Node.js 애플리케이션에서 MySQL을 사용하여 사용자 정보를 저장하고 조회하는 예제 코드를 살펴보겠습니다. 먼저 mysql2 패키지를 설치해야 합니다.

npm install mysql2

다음은 MySQL 연결, 사용자 정보 추가, 및 조회 코드를 확장한 내용입니다.

const mysql = require('mysql2');

// MySQL 연결 설정
const connection = mysql.createConnection({
    host: 'localhost', // MySQL 서버 주소
    user: 'yourUsername', // MySQL 사용자 이름
    password: 'yourPassword', // MySQL 사용자 비밀번호
    database: 'yourDatabase' // 사용할 데이터베이스 이름
});

// 데이터베이스 연결 시도
connection.connect((err) => {
    if (err) {
        console.error('Database connection failed:', err);
        return;
    }
    console.log('Connected to the database!');
});

// 사용자 정보 추가 함수
function addUser(name, email, callback) {
    const addUserQuery = "INSERT INTO users (name, email) VALUES (?, ?)";
    connection.query(addUserQuery, [name, email], (err, results) => {
        if (err) return callback(err);
        console.log(`New user added with id: ${results.insertId}`);
        callback(null, results.insertId);
    });
}

// 모든 사용자 정보를 가져오는 함수
function getAllUsers(callback) {
    const getAllUsersQuery = "SELECT * FROM users";
    connection.query(getAllUsersQuery, (err, results) => {
        if (err) return callback(err);
        console.log('All users:', results);
        callback(null, results);
    });
}

// 특정 ID의 사용자 정보를 가져오는 함수
function getUserById(id, callback){
    const getUserByIdQuery = "SELECT * FROM users WHERE id = ?";
    connection.query(getUserByIdQuery, [id], (err, results)=>{
        if(err) return callback(err);
         console.log("User found:", results);
        callback(null, results[0]); //결과가 배열이므로 첫번째 요소를 반환
    })
}

// 사용자 정보 업데이트 함수
function updateUserEmail(id, newEmail, callback){
  const updateUserQuery = "UPDATE users SET email = ? WHERE id = ?";
    connection.query(updateUserQuery, [newEmail, id], (err, results)=>{
       if(err) return callback(err);
        console.log(`${results.affectedRows} user(s) updated`);
        callback(null, results);
    })
}

// 특정 사용자 삭제 함수
function deleteUserById(id, callback){
    const deleteUserQuery = "DELETE FROM users WHERE id = ?";
    connection.query(deleteUserQuery, [id], (err, results)=>{
        if(err) return callback(err);
        console.log(`${results.affectedRows} user(s) deleted`);
        callback(null, results);
    })
}

// 데이터베이스 작업 실행
async function executeDatabaseOperations() {
  try{
    // 새로운 사용자 추가
    await new Promise((resolve, reject) => {
      addUser('John Doe', 'john.doe@example.com', (err, id) => {
        if(err) return reject(err);
        console.log(`Added user with ID: ${id}`);
          resolve();
      });
    });

    await new Promise((resolve, reject) => {
        addUser('Jane Smith', 'jane.smith@example.com', (err, id) => {
            if(err) return reject(err);
            console.log(`Added user with ID: ${id}`);
            resolve();
        });
    });

      // 모든 사용자 정보 가져오기
     await new Promise((resolve, reject) => {
        getAllUsers((err, users)=>{
            if(err) return reject(err);
             console.log("Retrieved all users: ", users);
            resolve();
        })
     });

    //특정 사용자 정보 가져오기
      await new Promise((resolve, reject) => {
          getUserById(1, (err, user)=>{
              if(err) return reject(err);
                console.log("Retrieved user with ID 1: ", user);
              resolve();
          })
      });

       // 특정 사용자 이메일 업데이트
      await new Promise((resolve, reject) => {
        updateUserEmail(1, 'new.email@example.com', (err, results) => {
           if(err) return reject(err);
           console.log("Update results: ", results)
          resolve();
        });
      });

      // 특정 사용자 삭제
    await new Promise((resolve, reject) => {
       deleteUserById(2, (err, results)=>{
           if(err) return reject(err);
          console.log("Delete results: ", results);
           resolve();
       });
    });

  } catch (error) {
    console.error("An error occurred:", error);
  } finally{
    connection.end();
  }
}

executeDatabaseOperations();

코드 설명:

• 각 기능별로 함수를 만들어 코드를 구조화했습니다. addUser, getAllUsers, getUserById, updateUserEmail, deleteUserById 함수를 통해 각 CRUD 작업을 수행합니다.
• Promise를 사용하여 비동기 작업을 순차적으로 실행하도록 했습니다.
• 새로운 사용자 추가, 모든 사용자 목록 가져오기, 특정 사용자 조회, 특정 사용자 업데이트, 그리고 사용자 삭제 기능을 추가하여 예제를 확장했습니다.

2. 비관계형 데이터베이스 (NoSQL)

비관계형 데이터베이스(NoSQL)는 스키마가 없거나 느슨하게 정의된 구조로 데이터를 저장합니다. JSON과 같은 형식을 사용하여 데이터를 표현하며, 유연성과 확장성이 필요한 경우에 적합합니다.

• 예시: MongoDB, CouchDB, Cassandra, Redis
• 특징:
  • 유연한 스키마: 데이터 구조를 미리 정의할 필요가 없으며, 필요에 따라 자유롭게 변경할 수 있습니다.
  • 비정형 데이터에 적합: JSON 문서와 같은 비정형 또는 반정형 데이터를 효율적으로 처리할 수 있습니다.
  • 수평적 확장성: 대량의 데이터를 처리하고 확장하기에 용이합니다.
  • 빠른 읽기/쓰기 성능: 스키마가 없어 데이터 처리 속도가 빠릅니다.

실용 예제 (MongoDB):
Node.js 애플리케이션에서 MongoDB를 사용하여 사용자 정보를 저장, 조회, 업데이트, 삭제하는 예제 코드를 확장하여 살펴보겠습니다. 먼저 mongodb 패키지를 설치해야 합니다.

npm install mongodb

const { MongoClient, ObjectId } = require('mongodb');

const uri = "mongodb://localhost:27017"; // MongoDB 연결 URI
const client = new MongoClient(uri);

async function main() {
    try {
        await client.connect();
        console.log('Connected to MongoDB!');
        const database = client.db('mydatabase');
        const usersCollection = database.collection('users');


        // ** CREATE (생성) **
        async function createUser(name, age, email) {
           const user = {name, age, email};
           const result = await usersCollection.insertOne(user);
            console.log(`New user created with ID: ${result.insertedId}`);
             return result.insertedId;
        }

        // ** READ (읽기) **
       async function getAllUsers() {
          const users = await usersCollection.find({}).toArray();
            console.log("All users:", users);
            return users;
        }

        // 특정 사용자 ID로 조회
        async function findUserById(id) {
          const user = await usersCollection.findOne({ _id: new ObjectId(id) });
             console.log("User found:", user);
             return user
        }

        // ** UPDATE (업데이트) **
        async function updateUserEmail(id, newEmail) {
           const result = await usersCollection.updateOne(
               {_id: new ObjectId(id)},
                {$set: {email: newEmail}}
           );
          console.log(`${result.modifiedCount} user(s) updated`);
             return result;
         }

        // ** DELETE (삭제) **
        async function deleteUserById(id){
            const result = await usersCollection.deleteOne(
                { _id: new ObjectId(id) }
            );
            console.log(`${result.deletedCount} user(s) deleted`);
            return result;
        }

        // 여러 개의 문서를 한번에 삽입
         async function createMultipleUsers(){
            const users = [
              {name:"User1", age:20, email:"user1@example.com"},
                {name:"User2", age:25, email:"user2@example.com"},
                {name:"User3", age:30, email:"user3@example.com"}
            ];

             const result = await usersCollection.insertMany(users);
             console.log(`${result.insertedCount} users added.`);
            return result;
        }


        // 데이터베이스 작업 실행
        const userId1 = await createUser('John Doe', 30, 'john.doe@example.com');
        const userId2 = await createUser('Jane Smith', 25, 'jane.smith@example.com');
        await getAllUsers();
        const user = await findUserById(userId1);
        await updateUserEmail(userId1, 'new.john.doe@example.com');
        await deleteUserById(userId2);
        await createMultipleUsers();

     }catch(err){
        console.error("An error occurred:", err);
     }finally {
        await client.close();
        console.log("MongoDB connection closed.");
    }
}
main().catch(console.error);

코드 설명:

• 각 기능별로 함수를 만들어 코드를 구조화했습니다. createUser, getAllUsers, findUserById, updateUserEmail, deleteUserById, createMultipleUsers 함수를 통해 각 CRUD 작업을 수행합니다.
• 새로운 사용자 추가, 모든 사용자 목록 가져오기, 특정 사용자 조회, 특정 사용자 업데이트, 사용자 삭제, 그리고 여러 사용자 추가 기능을 확장하여 예제를 강화했습니다.

3. 그래프 데이터베이스

그래프 데이터베이스는 노드(Node), 엣지(Edge), 속성(Property)의 세 가지 기본 요소로 구성되어 있어 복잡한 관계를 표현하기에 유리합니다.

• 예시: Neo4j, Amazon Neptune
• 특징:
  • 관계 중심 데이터: 데이터 간의 관계를 강조하고, 관계를 쉽게 탐색할 수 있습니다.
  • 복잡한 연결 분석: 소셜 네트워크 분석, 추천 시스템, 지식 그래프 등에 적합합니다.
  • 유연한 데이터 모델: 노드와 엣지를 통해 다양한 관계를 표현할 수 있습니다.
• 실용 예제 (간단한 그래프 데이터 모델):*
  간단한 예시로, 사람(노드)과 그들의 관계(엣지)를 표현해보겠습니다.
• 노드: 사람 (이름, 나이)*
• 엣지: 친구 관계 (since 속성)*

이 예시는 코드로는 표현하지 않고 개념적인 설명을 추가하여 그래프 데이터베이스가 어떻게 동작하는지를 보여드리겠습니다.

Node.js와 MongoDB 완벽 연동 가이드

MongoDB는 Node.js 환경에서 매우 인기 있는 NoSQL 데이터베이스입니다. MongoDB는 JSON과 유사한 형식의 문서(Document)로 데이터를 저장하기 때문에, JavaScript와의 호환성이 뛰어나고 동적인 구조를 지원합니다.

Node.js에서 MongoDB 연동하기

MongoDB와 Node.js를 연동하는 과정은 다음과 같습니다.

1. MongoDB 설치 및 실행: 로컬 또는 클라우드 환경에 MongoDB 서버를 설치하고 실행해야 합니다. MongoDB Atlas를 사용하면 클라우드 기반의 무료 계정을 만들 수 있습니다.
2. Node.js 프로젝트 생성 및 패키지 설치:

   mkdir myapp
   cd myapp
   npm init -y
   npm install mongodb

3. MongoDB 연결 및 확장된 CRUD 작업: 아래 코드는 기본적인 MongoDB 연결, 문서 추가, 조회, 업데이트, 삭제 기능을 확장하여 더 많은 예제를 보여줍니다.

const { MongoClient, ObjectId } = require('mongodb');

const url = 'mongodb://localhost:27017'; // MongoDB 연결 URL
const client = new MongoClient(url);

async function run() {
    try {
        await client.connect();
        console.log("Connected to MongoDB");

        const database = client.db('mydatabase');
        const usersCollection = database.collection('users');

        // ** CREATE (생성) **
       async function createUser(name, age, email, interests){
            const user = { name, age, email, interests};
            const result = await usersCollection.insertOne(user);
            console.log(`New user created with ID: ${result.insertedId}`);
           return result.insertedId;
        }

        // ** READ (읽기) **
         async function getAllUsers(){
            const users = await usersCollection.find({}).toArray();
            console.log("All users:", users);
            return users;
        }

         // 특정 사용자 ID로 조회
        async function findUserById(id){
            const user = await usersCollection.findOne({ _id: new ObjectId(id) });
            console.log("User found:", user);
           return user;
        }
        // 특정 조건으로 사용자 조회
        async function findUsersByAge(age){
             const users = await usersCollection.find({age}).toArray();
            console.log(`Users with age ${age}:`, users);
            return users;
        }

        // ** UPDATE (업데이트) **
        async function updateUserEmail(id, newEmail){
             const result = await usersCollection.updateOne(
                 {_id: new ObjectId(id)},
                 {$set: {email: newEmail}}
                 );
            console.log(`${result.modifiedCount} user(s) updated`);
            return result;
        }
        //여러 개의 필드 업데이트
        async function updateUserProfile(id, newName, newAge){
            const result = await usersCollection.updateOne(
                {_id: new ObjectId(id)},
                 {$set: {name: newName, age: newAge}}
            )
            console.log(`${result.modifiedCount} user(s) updated`);
           return result;
        }

        // ** DELETE (삭제) **
        async function deleteUserById(id){
            const result = await usersCollection.deleteOne({_id: new ObjectId(id)});
            console.log(`${result.deletedCount} user(s) deleted`);
            return result;
        }
        //특정 조건에 맞는 모든 사용자 삭제
        async function deleteUsersByAge(age){
          const result = await usersCollection.deleteMany({age});
           console.log(`${result.deletedCount} users deleted with age ${age}`)
            return result;
        }

        // 사용자 추가, 조회, 수정, 삭제 작업 실행
        const userId1 = await createUser('John Doe', 30, 'john.doe@example.com', ['coding', 'hiking']);
        const userId2 = await createUser('Jane Smith', 25, 'jane.smith@example.com', ['reading', 'painting']);
        await getAllUsers();
        await findUserById(userId1);
        await findUsersByAge(30);
        await updateUserEmail(userId1, 'new.email@example.com');
        await updateUserProfile(userId2, "Jane Doe", 26);
        await deleteUserById(userId2);
        await deleteUsersByAge(30);

    }catch (err){
        console.error("An error occurred:", err);
    }finally {
        await client.close();
        console.log("MongoDB connection closed.");
    }
}

run().catch(console.error);

코드 설명:

• createUser 함수는 새 사용자 추가 기능에 interests 필드를 추가하였습니다.
• getAllUsers 함수는 모든 사용자를 조회하는 기능을 유지합니다.
• findUserById 함수는 특정 ID로 사용자를 조회하는 기능을 제공합니다.
• findUsersByAge 함수는 특정 나이의 사용자들을 조회하는 기능을 추가하였습니다.
• updateUserEmail 함수는 특정 사용자의 이메일을 업데이트하는 기능을 유지합니다.
• updateUserProfile 함수는 특정 사용자의 이름과 나이를 동시에 업데이트하는 기능을 추가하였습니다.
• deleteUserById 함수는 특정 ID의 사용자를 삭제하는 기능을 유지합니다.
• deleteUsersByAge 함수는 특정 나이의 사용자를 삭제하는 기능을 추가하였습니다.
• 각 함수를 실행하는 코드 부분을 추가하여 기능이 잘 작동하는지 확인합니다.

Node.js와 MySQL 완벽 연동 가이드

MySQL은 관계형 데이터베이스의 대표적인 예시로, Node.js에서도 많이 사용됩니다. Node.js에서 MySQL을 사용하려면 mysql2 패키지를 설치해야 합니다.

Node.js에서 MySQL 연동하기

MySQL과 Node.js를 연동하는 과정은 다음과 같습니다.

1. MySQL 설치 및 설정: 로컬 또는 클라우드 환경에 MySQL 서버를 설치하고 필요한 데이터베이스와 사용자를 생성합니다.
2. Node.js 프로젝트 생성 및 패키지 설치:

   mkdir my_node_app
   cd my_node_app
   npm init -y
   npm install mysql2

3. MySQL 연결 및 확장된 CRUD 작업: 아래 코드는 기본적인 MySQL 연결, 사용자 추가, 조회, 업데이트, 삭제 기능을 확장하여 더 많은 예제를 보여줍니다.

const mysql = require('mysql2');

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

connection.connect((err) => {
    if (err) {
        console.error('DB 연결 실패:', err);
        return;
    }
    console.log('DB에 성공적으로 연결되었습니다.');
});


// 사용자 추가 함수
function createUser(name, age, email, callback) {
    const createUserQuery = "INSERT INTO users (name, age, email) VALUES (?, ?, ?)";
    connection.query(createUserQuery, [name, age, email], (err, results) => {
        if (err) return callback(err);
        console.log('사용자 추가됨:', results.insertId);
        callback(null, results.insertId)
    });
}


// 특정 사용자 조회 함수
function findUserById(id, callback) {
  const findUserQuery = "SELECT * FROM users WHERE id = ?";
    connection.query(findUserQuery, [id], (err, results)=>{
        if(err) return callback(err);
        console.log("User Found:", results[0]);
        callback(null, results[0]);
    })
}

// 모든 사용자 조회 함수
function getAllUsers(callback) {
    const readUsersQuery = "SELECT * FROM users";
    connection.query(readUsersQuery, (err, results) => {
         if (err) return callback(err);
        console.log('사용자 목록:', results);
        callback(null, results);
    });
}

// 특정 조건으로 사용자 조회 함수
function getUsersByAge(age, callback){
    const getUsersByAgeQuery = "SELECT * FROM users WHERE age = ?";
    connection.query(getUsersByAgeQuery, [age], (err, results)=>{
        if(err) return callback(err);
        console.log(`Users with age ${age}:`, results);
       callback(null, results);
    })
}

// 사용자 정보 업데이트 함수
function updateUserEmail(id, newEmail, callback) {
    const updateUserQuery = "UPDATE users SET email = ? WHERE id = ?";
    connection.query(updateUserQuery, [newEmail, id], (err, results) => {
         if (err) return callback(err);
        console.log('사용자 정보 업데이트됨:', results.message);
       callback(null, results)
    });
}

// 사용자 이름과 나이를 동시에 업데이트
function updateUserProfile(id, newName, newAge, callback){
    const updateUserQuery = "UPDATE users SET name = ?, age = ? WHERE id = ?";
    connection.query(updateUserQuery, [newName, newAge, id], (err, results)=>{
        if(err) return callback(err);
        console.log(`${results.affectedRows} user(s) updated.`);
      callback(null, results);
    })
}


// 특정 사용자 삭제 함수
function deleteUserById(id, callback) {
  const deleteUserQuery = "DELETE FROM users WHERE id = ?";
    connection.query(deleteUserQuery, [id], (err, results) => {
         if(err) return callback(err);
        console.log("사용자 삭제됨:", results.message);
      callback(null, results);
    });
}

//특정 조건에 맞는 모든 사용자 삭제
function deleteUsersByAge(age, callback){
    const deleteUsersQuery = "DELETE FROM users WHERE age = ?";
    connection.query(deleteUsersQuery, [age], (err, results)=>{
        if(err) return callback(err);
        console.log(`${results.affectedRows} user(s) deleted`);
        callback(null, results);
    })
}

async function executeDatabaseOperations(){
    try {
        // 사용자 추가
         await new Promise((resolve, reject)=>{
             createUser('홍길동', 30, 'hong@example.com', (err, id)=>{
                if(err) return reject(err);
                 console.log(`Added user with ID: ${id}`);
                 resolve();
            });
         });
        await new Promise((resolve, reject) => {
             createUser('김철수', 25, 'kim@example.com', (err, id)=>{
                 if(err) return reject(err);
                 console.log(`Added user with ID: ${id}`);
                 resolve();
            });
        });

        // 특정 사용자 조회
        await new Promise((resolve, reject)=>{
            findUserById(1, (err, user)=>{
                if(err) return reject(err);
                console.log("User with id 1:", user);
                resolve();
            })
        });

        // 모든 사용자 조회
        await new Promise((resolve, reject)=>{
           getAllUsers((err, users)=>{
               if(err) return reject(err);
             console.log("Retrieved all users:", users);
            resolve();
           });
        });

        // 특정 조건으로 사용자 조회
        await new Promise((resolve, reject)=>{
           getUsersByAge(30, (err, users)=>{
                if(err) return reject(err);
               console.log(`Users with age 30:`, users);
            resolve();
           });
        });

        // 사용자 이메일 업데이트
        await new Promise((resolve, reject)=>{
            updateUserEmail(1, 'newemail@example.com', (err, results)=>{
                if(err) return reject(err);
               console.log("Update email results:", results)
                resolve();
            });
        });

        //사용자 이름과 나이 업데이트
        await new Promise((resolve, reject)=>{
           updateUserProfile(2, "김철수 (업데이트됨)", 26, (err, results)=>{
               if(err) return reject(err);
               console.log("Update results:", results);
               resolve();
           })
        })

        // 특정 사용자 삭제
        await new Promise((resolve, reject)=>{
            deleteUserById(1, (err, results)=>{
                if(err) return reject(err);
                console.log("Delete Results: ", results)
                resolve();
            });
        });

        // 특정 조건으로 사용자 삭제
        await new Promise((resolve, reject)=>{
            deleteUsersByAge(26, (err, results)=>{
                if(err) return reject(err);
                console.log("Delete Users By Age results: ", results);
                 resolve();
            })
        })
    } catch (error) {
        console.error("An error occurred:", error);
    } finally {
        connection.end();
    }
}

executeDatabaseOperations();

코드 설명:

• createUser 함수는 새 사용자를 추가하고, findUserById 함수는 특정 ID로 사용자를 조회하는 기능을 추가합니다.
• getAllUsers 함수는 모든 사용자 정보를 가져옵니다.
• getUsersByAge 함수는 특정 나이의 사용자를 조회합니다.
• updateUserEmail 함수는 사용자 이메일 업데이트 기능을 유지하고, updateUserProfile 함수는 이름과 나이를 업데이트하는 기능을 추가합니다.
• deleteUserById 함수는 특정 사용자를 삭제하는 기능을 유지하며, deleteUsersByAge함수는 특정 나이의 사용자를 모두 삭제합니다.
• 비동기 작업을 처리하기 위해 Promise와 async/await를 사용하여 가독성을 높였습니다.
• 각 함수를 실행하는 코드 부분을 추가하여 기능이 잘 작동하는지 확인합니다.

Sequelize ORM: 데이터베이스 작업을 더 쉽게

ORM(Object-Relational Mapping)은 객체 지향 프로그래밍 언어의 객체와 관계형 데이터베이스의 테이블 간의 매핑을 제공합니다. Sequelize는 Node.js에서 널리 사용되는 ORM 라이브러리 중 하나입니다. Sequelize를 사용하면 SQL 쿼리를 직접 작성하지 않고도 데이터베이스 작업을 수행할 수 있으며, 코드 가독성을 높이고 생산성을 향상시킬 수 있습니다.

Sequelize 사용하기

1. Sequelize 설치:

   npm install sequelize mysql2

2. Sequelize 인스턴스 생성 및 모델 정의:

const { Sequelize, DataTypes, Model } = require('sequelize');

// Sequelize 인스턴스 생성
const sequelize = new Sequelize('my_database', 'my_user', 'password', {
    host: 'localhost',
    dialect: 'mysql'
});

class User extends Model {}

User.init({
        username: {
            type: DataTypes.STRING,
            allowNull: false,
            unique: true
        },
        password: {
            type: DataTypes.STRING,
            allowNull: false
        },
        email: {
            type: DataTypes.STRING,
            allowNull: false,
            unique: true
        },
        age:{
            type: DataTypes.INTEGER,
            allowNull: false
        },
        interests:{
          type: DataTypes.JSON, //JSON 형식의 배열을 저장
            defaultValue: []
        }

    }, {
        sequelize,
        modelName: 'user'
    });


// 데이터베이스 동기화
sequelize.sync({ force: false }).then(()=> {
    console.log("Database synchronized.")
});

// 사용자 생성 함수
async function createUser(username, password, email, age, interests) {
    return await User.create({ username, password, email, age, interests });
}

// 모든 사용자 조회 함수
async function getAllUsers() {
    return await User.findAll();
}
// 특정 ID로 사용자 조회
async function findUserById(id){
    return await User.findByPk(id);
}

// 특정 조건으로 사용자 조회 (나이)
async function findUsersByAge(age){
    return await User.findAll({where: {age}});
}

// 사용자 업데이트 함수 (이메일 업데이트)
async function updateUserEmail(id, newEmail) {
   const user = await User.findByPk(id);
    if(user) {
       user.email = newEmail;
        return await user.save();
    }
}

// 사용자 프로필 업데이트 함수(이름, 나이)
async function updateUserProfile(id, newName, newAge){
    const user = await User.findByPk(id);
    if(user) {
        user.username = newName;
       user.age = newAge;
        return await user.save();
    }
}

// 특정 사용자 삭제 함수
async function deleteUserById(id) {
   const user = await User.findByPk(id);
    if(user) {
        return await user.destroy();
    }
}

//특정 조건에 맞는 모든 사용자 삭제 (나이)
async function deleteUsersByAge(age){
     return await User.destroy({where: {age}});
}


async function main() {
    try{
        // Create User
        const newUser1 = await createUser('testuser1', 'testpassword', 'test1@example.com', 25, ['coding', 'hiking']);
        console.log("New User created: ", newUser1.toJSON());
        const newUser2 = await createUser('testuser2', 'testpassword2', 'test2@example.com', 30, ['reading', 'painting']);
        console.log("New User created: ", newUser2.toJSON());

        // Read Users
        const allUsers = await getAllUsers();
        console.log("All users:", allUsers.map(user => user.toJSON()));

        // 특정 ID로 사용자 조회
        const user = await findUserById(1);
        if (user) {
            console.log("User found:", user.toJSON());
        }

        // 특정 조건으로 사용자 조회 (나이)
        const usersWithAge = await findUsersByAge(30);
        if (usersWithAge) {
            console.log("Users with age 30:", usersWithAge.map(user => user.toJSON()));
        }

        //Update User
        if (allUsers.length > 0) {
            const updatedUser = await updateUserEmail(allUsers[0].id, "updated.email@example.com");
            console.log("Updated user:", updatedUser.toJSON())
             const updatedProfileUser = await updateUserProfile(allUsers[1].id, "UpdatedUsername", 31);
              console.log("Updated user Profile:", updatedProfileUser.toJSON())
        }


        //Delete User
        if(allUsers.length > 0) {
            await deleteUserById(allUsers[0].id);
            console.log("User Deleted")
             await deleteUsersByAge(30);
             console.log("Users with age 30 deleted");
        }
    } catch(error){
        console.error("An error occurred:", error);
    }
}
main();

코드 설명:

• User.init()에 email, age, interests 속성을 추가하여 모델을 확장하였습니다.
• createUser 함수에서 새로운 필드들을 추가하여 사용자 생성 기능을 강화했습니다.
• findUserById함수를 추가하여 특정 ID의 사용자 정보를 조회하는 기능을 제공합니다.
• findUsersByAge 함수를 추가하여 특정 나이의 사용자들을 조회하는 기능을 제공합니다.
• updateUserEmail 함수는 이메일 업데이트 기능을 유지하며, updateUserProfile 함수는 이름과 나이를 동시에 업데이트하는 기능을 추가합니다.
• deleteUserById 함수는 특정 사용자를 삭제하는 기능을 유지하고, deleteUsersByAge 함수는 특정 나이의 사용자를 삭제하는 기능을 제공합니다.
• sequelize.sync({ force: false })로 데이터베이스를 동기화하여 기존 데이터베이스 스키마를 유지합니다.
• 각 함수를 실행하는 코드 부분을 추가하여 기능이 잘 작동하는지 확인합니다.

결론

Node.js 애플리케이션에서 데이터베이스 연동은 중요한 부분이며, 데이터베이스 종류와 상황에 맞는 적절한 도구를 선택하는 것이 중요합니다. 이 포스트에서는 관계형 데이터베이스(MySQL), 비관계형 데이터베이스(MongoDB), 그리고 ORM 도구(Sequelize)를 사용한 Node.js 데이터베이스 연동 방법을 확장된 예제와 함께 자세히 다루었습니다. 실제 프로젝트에 적용해보면서 각 도구의 장단점을 파악하고, 자신에게 맞는 최적의 조합을 찾는 것이 중요합니다.