MongoDB

2023. 03. 14.

🌭 장단점

장점

단점

🥗 데이터 삽입

DB명을 쓰고 collection 명을 써서 생성하고, insertOne을 이용해 하나의 데이터를 삽입할 수 있다.

아래 코드는 콜백을 활용한 방법이다.

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

const uri =
  'mongodb+srv://j56237:qwer1234@cluster0.03qkgmh.mongodb.net/?retryWrites=true&w=majority';

const client = new MongoClient(uri, {
  useNewUrlParser: true,
  useUnifiedTopology: true,
  serverApi: ServerApiVersion.v1,
});

client.connect((err) => {
  const test = client.db('kdt5').collection('test');
  test.deleteMany({}, (deleteErr, result) => {
    if (deleteErr) throw deleteErr;
    console.log(result);
    test.insertOne(
      {
        name: 'JKE',
        nickName: 'goorm',
      },
      (insertErr, result) => {
        console.log(result);
        const findCursor = test.find({});
        findCursor.toArray((err, data) => {
          console.log(data);
        });
      },
    );
  });
});

삽입한 데이터는 Atlas에서 확인할 수 있다.

find() 안에 객체가 빈 객체이므로 가지고 있는 모든 데이터를 찾는다.

콜백은 이용한 방법은 코드의 수정이 용이하지는 않다는 것을 알 수 있다.

insertOne

하나의 도큐먼트를 삽입한다.

client.connect((err) => {
	const test = client.db("kdt5").collection("test");
	test.deleteMany({}, (deleteErr, deleteResult) => {
	    if (deleteErr) throw deleteErr;
	    test.insertOne(
				{
					name: "pororo",
					age: 5,
	      },
	      (insertErr, insertResult) => {
	        if (insertErr) throw insertErr;
	        console.log(insertResult);
		  }
		);
	});
});

위쪽 deleteMany는 빈 객체를 가지고 있으므로 모든 데이터를 지우는 코드이다.

첫번째 인자에는 객체 데이터 / 두번째 인자에는 Err와 Result를 가진 콜백함수를 가진다.

insertMany

여러 도큐먼트를 한번에 삽입한다.

삽입할 도큐먼트는 배열에 담긴 객체 형태로 전달된다.

client.connect((err) => {
  const test = client.db('kdt5').collection('test');
  test.deleteMany({}, (deleteErr, deleteResult) => {
    if (deleteErr) throw deleteErr;
    console.log(deleteResult);

    test.insertMany(
      [
        { name: 'pororo', age: 5 },
        { name: 'crong', age: 4 },
        { name: 'loopy', age: 6 },
      ],
      (insertErr, insertResult) => {
        if (insertErr) throw insertErr;
        console.log(insertResult);
      },
    );
  });
});

🍞 데이터 삭제

deleteOne

조건을 만족하는 가장 처음의 도큐먼트 하나를 삭제한다.

조건은 객체 형태로서 deleteOne의 첫번째 인자로 전달한다.

client.connect((err) => {
  const test = client.db('kdt5').collection('test');
  test.deleteMany({}, (deleteErr, deleteResult) => {
    if (deleteErr) throw deleteErr;
    console.log(deleteResult);

    test.insertMany(
      [
        { name: 'pororo', age: 5 },
        { name: 'crong', age: 4 },
        { name: 'loopy', age: 6 },
      ],
      (insertErr, insertResult) => {
        if (insertErr) throw insertErr;
        console.log(insertResult);

        test.deleteOne({ name: 'crong' }, (deleteOneErr, deleteOneResult) => {
          if (deleteOneErr) throw deleteOneErr;
          console.log(deleteOneResult);
        });
      },
    );
  });
});

name이 ‘crong’인 값을 지워준다.

뽀로로와 루피만 DB에 남게된다.

deleteMany

조건을 만족하는 모든 도큐먼트를 삭제한다.

조건은 객체 형태로서 deleteOne의 첫번째 인자로 전달하면 된다.

client.connect((err) => {
  const test = client.db('kdt5').collection('test');
  test.deleteMany({}, (deleteErr, deleteResult) => {
    if (deleteErr) throw deleteErr;
    console.log(deleteResult);

    test.insertMany(
      [
        { name: 'pororo', age: 5 },
        { name: 'crong', age: 4 },
        { name: 'loopy', age: 6 },
      ],
      (insertErr, insertResult) => {
        if (insertErr) throw insertErr;
        console.log(insertResult);

        test.deleteMany(
          { age: { $gte: 5 } },
          (deleteManyErr, deleteManyResult) => {
            if (deleteManyErr) throw deleteManyErr;
            console.log(deleteManyResult);
          },
        );
      },
    );
  });
});

gte는 Greater Than Eqaul의 약자로 크거나 작을때를 뜻한다.

따라서 위 코드는 age가 5이상이면 지우게 된다.

크롱만 DB에 남게된다.

🧈 데이터 수정

updateOne

조건을 만족하는 가장 처음의 도큐먼트 하나를 수정한다.

조건은 첫번째 인자로 전달하고, 변경점은 두번째 인자로 전달한다.

변경부분은 $set:을 사용한다.

client.connect((err) => {
  const test = client.db('kdt5').collection('test');
  test.deleteMany({}, (deleteErr, deleteResult) => {
    if (deleteErr) throw deleteErr;
    console.log(deleteResult);

    test.insertMany(
      [
        { name: 'pororo', age: 5 },
        { name: 'crong', age: 4 },
        { name: 'loopy', age: 6 },
      ],
      (insertErr, insertResult) => {
        if (insertErr) throw insertErr;
        console.log(insertResult);

        test.updateOne(
          { name: 'loopy' },
          { $set: { name: '루피' } },
          (updateOneErr, updateOneResult) => {
            if (updateOneErr) throw updateOneErr;
            console.log(updateOneResult);
          },
        );
      },
    );
  });
});

이렇게 되면 loopy만 이름이 한글 ‘루피’로 변하게 된다.

updateMany

조건을 만족하는 모든 도큐먼트를 수정한다.

조건은 첫번째 인자로 전달하고, 변경점은 두번째 인자로 전달한다.

변경부분은 $set:을 사용한다.

client.connect((err) => {
  const test = client.db('kdt5').collection('test');
  test.deleteMany({}, (deleteErr, deleteResult) => {
    if (deleteErr) throw deleteErr;
    console.log(deleteResult);

    test.insertMany(
      [
        { name: 'pororo', age: 5 },
        { name: 'crong', age: 4 },
        { name: 'loopy', age: 6 },
      ],
      (insertErr, insertResult) => {
        if (insertErr) throw insertErr;
        console.log(insertResult);

        test.updateMany(
          { age: { $gte: 5 } },
          { $set: { name: '나이가 5살 이상인 친구들' } },
          (updateManyErr, updateManyResult) => {
            if (updateManyErr) throw updateManyErr;
            console.log(updateManyResult);
          },
        );
      },
    );
  });
});

이렇게 하면 뽀로로와 루피의 name이 ‘나이가 5살 이상인 친구들’로 변경된다.

$set 말고 $inc도 존재한다. 이는 원래 값에 +를 시켜준다.

🌯 데이터 검색

findOne

검색 조건을 만족하는 최초의 도큐먼트 하나를 찾아준다.

client.connect((err) => {
  const test = client.db('kdt5').collection('test');
  test.deleteMany({}, (deleteErr, deleteResult) => {
    if (deleteErr) throw deleteErr;
    console.log(deleteResult);

    test.insertMany(
      [
        { name: 'pororo', age: 5 },
        { name: 'crong', age: 4 },
        { name: 'loopy', age: 6 },
      ],
      (insertErr, insertResult) => {
        if (insertErr) throw insertErr;
        console.log(insertResult);

        test.findOne({ name: 'loopy' }, (findOneErr, findOneData) => {
          if (findOneErr) throw findOneErr;
          console.log(findOneData);
        });
      },
    );
  });
});

name이 ‘loopy’인 것을 찾아 console에 찍어준다.

find

findMany는 없고 find가 있다.

조건에 맞는 도큐먼트를 전부 찾아준다.

단, find는 독특한 특성을 가진다.

client.connect((err) => {
  const test = client.db('kdt5').collection('test');
  test.deleteMany({}, (deleteErr, deleteResult) => {
    if (deleteErr) throw deleteErr;
    console.log(deleteResult);

    test.insertMany(
      [
        { name: 'pororo', age: 5 },
        { name: 'crong', age: 4 },
        { name: 'loopy', age: 6 },
      ],
      (insertErr, insertResult) => {
        if (insertErr) throw insertErr;
        console.log(insertResult);

        const findCursor = test.find({ age: { $gte: 5 } });
        console.log(findCursor);

        findCursor.toArray((toArrErr, arrData) => console.log(arrData));
      },
    );
  });
});

이렇게 하면 5살 이상인 뽀로로와 루피만 가져오게 된다.

findCursor는 다음처럼 바로 사용할 수 있는 데이터가 아니다.

🍠 비교식

$eq: 같을 때

$gt: 클 때

$gte: 크거나 같을 때

$lt: 작을 때

$lte: 작거나 같을 때

$ne: 다를 때

$in: 배열에 지정된 값 중 하나와 일치한 값

$nin: 배열에 지정된 값과 일치하지 않는 값

users.updateMany( 
	{
	  name: { $ne: 'loopy' },
  },
	{
		$set: {
			name: '루피 아님', 
		},
	},

🥯 논리식

$or: 조건들 중 하나라도 true면 반환

$and: 조건들이 모두 true일 때 반환

$not: 조건이 false일때 반환

$nor: 조건들이 모두 false일 때 반환

const cusor = users.find({
    $and: [{ age: { $gte: 5 } }, { name: 'loopy' }],
});
cursor.toArray((err, data) => {
   console.log(data);
});

🦴 Async / Await로 바꾸기

콜백함수는 유지보수가 불편한 단점이 있다.

async function main() {
  try {
    await client.connect();
    const test = client.db('kdt5').collection('test');

    await test.deleteMany({});
    await test.insertOne({ name: 'pororo', age: 5 });

    await test.deleteMany({});
    await test.insertMany([
      { name: 'pororo', age: 5 },
      { name: 'crong', age: 4 },
      { name: 'loopy', age: 6 },
    ]);
    await test.deleteOne({ name: 'crong' });

    await test.deleteMany({});
    await test.insertMany([
      { name: 'pororo', age: 5 },
      { name: 'crong', age: 4 },
      { name: 'loopy', age: 6 },
    ]);
    await test.updateMany({ age: { $gte: 5 } }, { $set: { age: 10 } });
    const findCursor = test.find({ age: { $gte: 10 } });
    const dataArr = await findCursor.toArray();
    console.log(dataArr);
  } catch (err) {
    console.error(err);
  }
}

main();

async / await로 표현하면 다음과 같이 표현할 수 있다.

코드 가독성이 좋아지고 양도 줄은 것을 볼 수 있다.

🥃 Mongoose

MongoDB는 사용상의 제약이 전혀 없어서 편리하다.

그러나 이 때문에 key의 값이 달라지는 등 버그가 발생할 수 있다.

이는 Mongoose로 해결할 수 있다.

스키마 생성

/models/user.js

const mongoose = require('mongoose');

const { Schema } = mongoose;
const userSchema = new Schema(
  {
    id: {
      type: String,
      required: true,
      unique: true,
    },
    password: {
      type: String,
      required: true,
    },
    createAt: {
      type: Date,
      default: Date.now,
    },
  },
  {
    collection: 'mongoose-user',
  },
);

module.exports = mongoose.model('User', userSchema);

위처럼 타입과 required 등을 정해줄 수 있다.

CRUD 쿼리

mongoDB와 모두 동일하지만 insertOne 대신 create를 사용하면 된다.