MySQL

지금까지는 모든 데이터를 변수에 저장했다.
변수에 저장했다는 것은 컴퓨터 메모리에 저장했다는 뜻.
서버가 종료되면 메모리가 정리되면서 저장한 데이터도 사라짐.
이를 방지하기 위해 데이터베이스르 사용해야 한다.

다양한 db 중 MySQL과 몽고db를 사용할 예정.
MySQL은 SQL언어 사용하는 관계형 db관리 시스템의 대표 주자고,
=> SQL(Structured Query Language): 관계형 db 관리 시스템 데이터 관리 위한 언어
몽고db는 NoSQL의 대표 주자이다.

• 데이터베이스란?
  db는 관련성을 가지며 중복이 없는 데이터들의 집합.
  이러한 db를 관리하는 시스템을 DBMS(Database Management System)이라고 부른다.

보통 서버의 하드 디스크나 SSD등의 저장 매체에 데이터를 저장.
이 경우 서버 종료 여부와 상관없이 데아터 지속적으로 사용 가능.
또한 서버에 db올리면 여러 사람이 동시에 사용 가능.
각 사람들에게 다른 권한 줘서 어떤 사람을 읽기만, 어떤 사람은 모든 작업 가능하게 할 수 있다.
db를 관리하는 DBMS중에서 RDBMS(Relational DBMS) 라고 부르는 관계형 DBMS가 많이 쓰임.
대표적으로 Oracle, MySQL, MSSQL 등이 있다.
이들은 SQL 언어를 사용해 데이터를 관리한다.

• MySQL 설치
  설치 완료 후 MySQL에 접속해보자.
  MySQL 설치된 폴더(C:\Program Files\MySQL\MySQL Server 8.0\bin)로 이동 후 다음 명령어 입력

mysql -h localhost -u root -p

-h 뒤에는 접속할 주소, -u 뒤에는 사용자명 입력. -p는 password 사용하겠다는 뜻.

프롬프트가 mysql> 로 바뀌면 접속된 것.
앞으로 여기에 SQL 명령어 입력하면 됨.
exit 명령어로 콘솔로 되돌아가기.

• 워크밴치 설치
  콘솔로 데이터 한눈에 보기엔 무리.
  워크밴치(MySQL Workbench) 사용하면 데이터베이스 내부에 저장된 데이터 시각적으로 관리할 수 있어 편리. (필수는 아니며 콘솔로도 동일 작업 가능)

• 데이터베이스 생성하기
  MySQL 프롬프트에 접속하고 CREATE SCHEMA '데이터베이스명' 이 데이터베이스 생성하는 명령어.
  MySQL 에서 데이터베이스와 스키마는 같은 개념.
  nodejs 라는 이름의 db 생성해보자.
  그 후 use nodejs; 명령어 입력해 앞으로 noejs db사용하겠다는 것 MySQL에 알림.

mysql> CREATE SCHEMA `nodejs` DEFAULT CHARACTER SET utf8;
Query OK, 1 row affected (0.01sec)
mysql> use nodejs;
Database changed

DEFAULT CHARACTER SET utf8 은 한글 사용할 수 있도록.
SQL 구문은 마지막에 세미콜론 붙여야 실행 됨.
(안붙이면 다음줄로 넘어가 다음 입력 들어오기 기다림.)

CREATE SCHEMA처럼 MySQL이 기본적으로 알고 있는 구문을 예약어라고 부름.
(소문자로 써도 되지만)대문자로 쓰는 것이 좋다.
nodejs 처럼 사용자가 직접만든 이름과 구분하기 위해.

• 테이블 생성하기
  db 생성했다면 테이블을 만든다.
  테이블은 데이터가 들어갈 수 있는 틀이며, 테이블에 맞는 데이터만 들어갈 수 있음.
  다음과 같이 입력한다.

mysql> CREATE TABLE nodejs.users (
  -> id INT NOT NULL AUTO_INCREMENT,
  -> name VARCHAR(20) NOT NULL,
  -> age INT UNSIGNED NOT NULL,
  -> married TINYINT NOT NULL,
  -> comment TEXT NULL,
  -> created_at DATETIME NOT NULL DEFAULT now(),
  -> PRIMARY KEY(id),
  -> UNIQUE INDEX name_UNIQUE (name ASC))
  -> COMMENT = '사용자 정보'
  -> DEFAULT CHARACTER SET = utf8
  -> ENGINE = InnoDB;
Query OK, 0 row affected (0.09 sec)

CREATE TABLE은 db명.테이블명 은 테이블 생성 명령어.
nodejs db내에 users테이블 생성하는 것.
순서대로 id, name, age, married, comment, created_at(로우 생성일).
컬럼 정의해두면 앞으로 데이터 넣을 때 컬럼 규칙에 맞는 정보들만 넣을 수 있음.

age 컬럼에는 모두 age 관련 정보만 들어있음.
컬럼과 로우가 교차하는 칸 하나를 필드라고 부름.
컬럼은 세로, 로우는 가로 필드의 집합.
테이블에 데이터 넣을때는 미리 컬럼 정의해두고 컬럼에 맞춰 데이터 넣으면 됨.

각 컬럼 이름 옆 INT, VATCHAR 등은 자료형.

• INT는 정수.
• VARCHAR(자릿수, 고정 길이), CHAR(자릿수, 가변 길이)
  CHAR(10)이면 반드시 길이가 10인 문자열만 넣어야 함.
  VARCHAR(10)인 경우 길이 0~10인 문자열. 부족한 자릿수는 스페이스.
• TEXT는 긴 글 저장시 사용. 보통 수백자 이내 문자열은 VARCHAR, 그 이상은 TEXT 사용.
• TINYINT는 -128~127 까지의 정수
• DATETIME은 날짜, 시간관련 정보.

자료형 뒤 NULL, NOT NULL, UNSIGNED, AUTO_INCREMENT, DEFAULT 등은 옵션.

• NULL, NOT NULL은 빈칸 허용 여부. NOT NULL은 반드시 데이터 입력해야 함.
  -UNSIGNED는 음수 무시하고 양수 두배로 저장. 음수 못나오는 데이터(나이 등) 저장시 체크.
• AUTO_INCREMENT는 숫자 자동으로 증가. 사람 추가할때 자동으로 id값 1,2,3.. 부여.
• DEFAULT now() 옵션은 db저장시 해당 컬럼 값 없다면 MySQL이 기본값 대신 넣음. now()는 현재 시각 넣으라는 뜻.

만들어진 테이블 확인하는 명령어는 DESC 테이블명 이다.

잘못 만든 경우 DROP TABLE users; 명령어로 제거 후 다시 생성.

워크벤치로 테이블 만들면 이해 쉽다.

db 아래의 Tables를 우클릭 해 Create Table을 선택.

컬럼의 속성을 설정한다.

사용자의 댓글을 저장하는 테이블을 만들어보자.

mysql> CREATE TABLE nodejs.comments (
  -> id INT NOT NULL AUTO_INCREMENT,
  -> commenter INT NOT NULL,
  -> comment VARCHAR(100) NOT NULL,
  -> created_at DATETIME NOT NULL DEFAULT now(),
  -> PRIMARY KEY(id),
  -> INDEX commenter_idx (commenter ASC),
  -> CONSTRAINT commenter
  -> FOREIGN KEY (commenter)
  -> REFERENCES nodejs.users (id)
  -> ON DELETE CASCADE
  -> ON UPDATE CASCADE)
  -> COMMENT = '댓글'
  -> DEFAULT CHARSET=utf8mb4
  -> ENGINE=InnoDB;
Query OK, 0 row affected (0.09 sec)

nodejs db에 comments 테이블을 생성.
comments 테이블에는 id, commenter(댓글 쓴 사용자 아이디), comment(댓글 내용), create_at(로우 생성일) 컬럼이 존재.

commenter 컬럼에는 댓글 쓴 사용자의 id 저장.
이렇게 다른 테이블의 기본 키 저장하는 컬럼을 외래 키(fereign key)라고 부름.
'CONSTRAINT 제약조건명 FOREIGN KEY 컬럼명 REFERENCES 참고하는 컬럼명' 으로 외래 키 지정.
위에서는 commenter 컬럼과 users 테이블의 id 컬럼은 연결.

CASCADE는 사용자 정보가 수정, 삭제되면 그와 연결된 댓글 정보도 같이 수정, 삭제한다는 뜻.
그래야 데이터 불일치 일어나지 않음.

다음 명령어로 users 테이블과 comments 테이블 제대로 생성됐는지 확인.

mysql > SHOW TABLES;

테이블을 만들었으니 안에 데이터를 넣어보자.

• CRUD 작업하기
  CRUD는 Create, Read, Update, Delete 로 db에서 가장 많이 수행하는 네 가지 작업 뜻함.

• Create
  데이터를 생성해서 db에 넣는 작업.
  nodejs db의 users 테이블에 데이터를 넣어보자.
  
  데이터 넣는 명령어는 INSERT INTO 테이블명 (컬럼1, 컬럼2,..) VALUES(값1, 값2,..)
  id는 AUTO_INCREMENT에 의해, created_at은 DEFAULT값에 의해 자동으로 들어감.

comments 테이블에 데이터를 넣어보자.

• Read
  db에 있는 데이터 조회하는 작업.
  
  
  SELECT * FROM 테이블명 형식.
  users 테이블의 모든 데이터 조회하는 SQL문.

특정 컬럼만 조회하려면 SELECT 다음에 * 대신 조회 원하는 칼럼 넣기.

이름, 결혼 여부만 조회한 모습.

WHERE 이용해 특정 조건 가진 데이터만 조회 가능.

ORDER BY 컬럼명 ASC(오름차순)/DESC(내림차순) 사용해 정렬.

LIMIT 숫자 키워드로 조회할 로우 개수 설정.
로우 개수 설정하면서 몇개 건너뛸지 설정 가능.
게시판등 페이지네이션 기능 구현 시 용이.
첫 페이지에서 1~20번 게시물 조회했다면 두번째 페이지는 21~40번 게시물 조회해야 함.
이처럼 처음 20개 건너뛰고 다음 20개 게시물 조회하라는 식의 명령 가능.
OFFSET 건너뛸 숫자 키워드 사용.

• Update
  db에 있는 데이터 수정.
  수정 명령어는 UPFATE 테이블명 SET 컬럼명=바꿀 값 WHERE 조건.
  
  
  위에서는 id가 2인 로우(nero)의 comment 수정함.

• Delete
  db의 데이터 삭제하는 작업. 로우를 제거해보자.
  명령어는 DELETE FROM 테이블명 WHERE 조건
  
  id가 2인 로우를 삭제했다.

• 시퀄라이즈(Sequelize)
  이제 MySQL을 노드와 연동해 서버에서 db를 조작할수 있게 해야한다.
  시퀄라이즈는 노드와 MySQL연동해줄 뿐만 아니라 SQL문 작성 도와주는 라이브러리.
  js 구문을 알아서 SQL문으로 바꿔줌.

시퀄라이즈는 ORM(Object-relational Mapping)이며, ORM은 js 객체와 db의 릴레이션을 매핑해주는 도구.
SQL언어 직접 사용 안해도 js만으로 MySQL 조작 가능.

패키지들을 설치하고 sequelize init 명령어를 호출.
생성된 models 폴더 안의 index.js폴더를 다음과 같이 수정

// models/index.js
const Sequelize = require('sequelize');
// Sequelize는 패키지이자 생성자.
const env = process.env.NODE_ENV || 'development';
const config = require('../config/config')[env];
const db = {};

// Sequelize는 패키지이자 생성자. config/config.json에서 db설정 불러온 후 MySQL 연결 객체 생성
const sequelize = new Sequelize(config.database, config.username, config.password, config);
db.sequelize = sequelize; // 연결 객체 나중에 재사용하기 위해 db.sequelize에 넣음

module.exports = db;

• MySQL 연결하기
  시퀄라이즈 통해 익스프레스 앱과 MySQL 연결해야 함.
  app.js에 익스프레스와 시퀄라이즈 연결 코드를 작성.

// app.js
const express = require('express');
const path = require('path');
const morgan = require('morgan');
const nunjucks = require('nunjucks');
// require('./models')는 require('./models/index.js')와 같다.
// 폴더 내의 index.js파일은 require시 이름 생략 가능.
const {sequelize} = require('./models');

const app = express();
app.set('port', process.env.PORT || 3001);
app.set('view engine', 'html');
nunjucks.configure('views', {
    express: app,
    watch: true,
});

// db.sequelize 불러와 sync메서드 사용 해 서버 실행 시 MySQL과 연동되도록 함.
sequelize.sync({force: false})
.then(() => {
    console.log('데이터베이스 연결 성공');
})
.catch((err) => {
    console.error(err);
});

app.use(morgan('dev'));
app.use(express.static(path.join(__dirname, 'public')));
app.use(express.json());
app.use(express.urlencoded({ extended: false }));

app.use((req, res, next) => {
    const error = new Error(`${req.method} ${req.url} 라우터가 없습니다.`);
    error.status = 404;
    next(error);
})

app.use((err, req, res, next) => {
    res.locals.message = err.message;
    res.locals.error = process.env.NODE_ENV !== 'production' ? err : {};
    res.status(err.status || 500);
    res.render('error');
});

app.listen(app.get('port'), () => {
    console.log(app.get('port'), '번 포트에서 대기 중');
});

MySQL과 연동 시 config/config.json 정보가 사용됨.

{
  "development": {
    "username": "root",
    "password": "bluesun",
    "database": "nodejs",
    "host": "127.0.0.1",
    "dialect": "mysql"
  },
  "test": {
    ...
  },
  "production": {
    ...
  }
}
...

password와 database를 현재 MySQL 커넥션과 일치하게 수정.
이 설정은 process.env.NODE_ENV가 development일 때 적용됨.(기본적으로 development)
나중에 배포 시에는 production으로 설정.

npm start로 서버 실행하면 3001포트에서 서버 돌아감.

• 모델 정의하기
  이제 MySQL에서 정의한 테이블을 시퀄라이즈에서도 정의해야 한다.
  MySQL의 테이블은 시퀄라이즈의 모델과 대응됨.
  시퀄라이즈는 모델과 MySQL의 테이블을 연결해주는 역할.
  User와 Comment모델 만들어 user테이블과 comment테이블에 연결해보자.

시퀄라이즈는 기본적으로 모델 이름은 단수형, 테이블 이름은 복수형으로 사용.

• User모델

const Sequelize = require('sequelize');
// models/user.js
// Users모델 만들고 모듈로 exports.
// Users모델은 Sequelize.Model 확장한 클래스로 선언.
// 모델은 크게 static init 메서드와 static associate 메서드로 나뉨.
module.exports = class Users extends Sequelize.Model {
    static init(sequelize) { // 테이블에 대한 설정
        return super.init({ // 첫번째 인수는 테이블 컬럼 관한 설정
            // 두번째 인수는 테이블 자체에 대한 설정
            // 시퀄라이즈는 알아서 id 기본 키로 연결하므로 id 컬럼은 적을 필요 없음
            // 나머지는 MySQL 테이블과 컬럼 내용이 일치해야 정확히 대응됨.
            // 단 서로 자료형 조금씩 다름.
            name: {
                type: Sequelize.STRING(20), // MySQL에서 VARCHAR는 STRING으로
                allowNull: false, // NOT NULL과 같은 의미
                unique: true,
            },
            age: {
                type: Sequelize.INTEGER.UNSIGNED, // INT는 INTEGER로
                allowNull: false,
            },
            married: {
                type: Sequelize.BOOLEAN, // TINYINT는 BOOLEAN으로
                allowNull: false,
            },
            comment: {
                type: Sequelize.TEXT,
                allowNull: true,
            },
            created_at: {
                type: Sequelize.DATE, // DATETIME은 DATE로
                allowNull: false,
                defaultValue: Sequelize.NOW, // DEFAULT now()
            },
        }, { // 두번째 인수는 테이블 옵션
             // static init 메서드의 매개변수와 연결되는 옵션.
             // db.sequelize 객체 넣어야 함. 나중에 model.index.js에서 연결함.
            sequelize,
            // true면 시퀄라이즈는 createdAt과 updatedAt컬럼 추가함.
            // 각 로우 생성시, 수정시 시간 자동으로 입력 됨.
            // 하지만 직접 created_at 컬럼 만들었으므로 필요없음.
            timestamps: false, 
            // 시퀄라이즈는 기본적으로 테이블, 컬럼 명 camel case로 만듬.
            // 이를 snake case(created_at)로 바꾸는 옵션
            underscored: false,
            modelName: 'User', // 모델 이름 설정. 노드 프로젝트에서 사용
            tableName: 'users',
            // true 설정하면 deletedAt 컬럼 생김.
            // 로우 삭제시 완전히 지워지지 않고 deletedAt에 지운 시각 기록 됨.
            // 로우 조회 명령 내릴 시 deletedAt값이 null인 로우(삭제되지 않았다는 뜻) 조회함.
            // 나중에 로우 복원위해 사용
            paranoid: false,
            charset: 'utf8',
            collate: 'utf8_general_ci',
        });
    }
    static associate(db) {} //다른 모델과의 관계
}

• Comment모델

const Sequelize = require('sequelize');
// models/comment.js
module.exports = class Comment extends Sequelize.Model {
    static init(sequelize) {
        return super.init({
            comment: {
                type: Sequelize.STRING(100),
                allowNull: false,
            },
            created_at: {
                type: Sequelize.DATE,
                allowNull: true,
                defaultValue: Sequelize.NOW
            },
        }, {
            sequelize,
            timestamps: false,
            modelName: 'Comment',
            tableName: 'comments',
            paranoid: false,
            charset: 'utf8',
            collate: 'utf8mb4_general_ci',
        });
    }
    static associate(db) {}
}

users테이블과 연결된 commenter컬럼이 없다.
이 부분을 모델 정의할 때 넣어도 되지만 시퀄라이즈 자체에서 관계 따로 정의할 수 있음. 조금 뒤에서 알아보자.

모델 생성했다면 models/index.js와 연결한다.

// models/index.js
// Sequelize는 패키지이자 생성자.
const Sequelize = require('sequelize');

const User = require('./user');
const Comment = require('./comment');

const env = process.env.NODE_ENV || 'development';
const config = require('../config/config')[env];
const db = {};

// Sequelize는 패키지이자 생성자. config/config.json에서 db설정 불러온 후 MySQL 연결 객체 생성
const sequelize = new Sequelize(config.database, config.username, config.password, config);
db.sequelize = sequelize; // 연결 객체 나중에 재사용하기 위해 db.sequelize에 넣음

// db라는 객체에 User, Comment 모델 담아둠.
// 앞으로 db객체 require하여 User, Comment 모델에 접근 가능
db.User = User;
db.Comment = Comment;

// 각각의 모델의 static.init메서드 호출.
// init 실행되어야 테이블이 모델로 연결됨.
User.init(sequelize);
Comment.init(sequelize);

User.associate(db);
Comment.associate(db);

module.exports = db;

-관계 정의하기
이제 users테이블과 comments테이블 간의 관계를 설정해보자.
사용자 한명은 여려개의 댓글 작성할 수 있지만, 댓글 하나에 사용자(작성자)가 여러명일 수는 없음.
이런 관계를 1:N(일대다) 관계라고 한다. (사용자가 1, 댓글이 N)

1:1(일대일) 관계로는 사용자와 사용자에 대한 정보 테이블.

N:M(다대다) 관계로는 게시글 테이블과 해시태그 테이블.
한 게시글에 여려 해시태그 달 수 있고, 한 해시태그로 여러 게시글에 달 수 있음.

MySQL에서는 JOIN 기능으로 여러 테이블 간의 관계 파악해 결과 도출.
시퀄라이즈는 JOIN 기능도 알아서 구현.
단 테이블 간 어떤 관계 있는지 시퀄라이즈에 알려야 함.

• 1:N
  시퀄라이즈에서는 1:N 관계를 hasMany 메서드로 표현.
  users 테이블의 로우 하나 불러올 때 연결된 comments 테이블의 로우들도 같이 불러올 수 있다.
  반대로 belongsTo 메서드는 comments 테이블의 로우 불러올 때 연결된 users 테이블의 로우 가져옴.
  

모델 각각의 static associate 메서드에 넣음.

// models/user.js
...
    static associate(db) { // 다른 모델과의 관계
        db.User.hasMany(db.Comment, {foreignKey: 'commenter', sourceKey: 'id'});
    }
}

// models/comment.js
...
    static associate(db) {
        db.Comment.belongsTo(db.User, {foreignKey: 'commenter', targetKey: 'id'});
    }
}

다른 모델의 정보가 들어가는 테이블(comments)에 belongsTo 사용하면 됨.
예제에서는 commenter 컬럼이 추가되는 Comment 모델이 belongsTo 사용하면 됨.
사용자는 한명이고, 그에 속한 댓글은 여러 개이므로 댓글 로우에 사용자(commenter)가 누구인지 적어야 함.

시퀄라이즈는 정의한대로 모델간 관계 파악해서 Comment 모델에 foreignKey(외래 키)인 commeter 컬럼 추가함.
Commenter 모델의 외래 키 컬럼은 commenter고, User 모델의 id 컬럼을 가리키고 있음.

hasMany 메서드는 sourceKey 속성에 id 넣고, belongsTo 메서드에는 targetKey 속성에 id 넣음.
sourceKey와 targetKey의 id 모두 User 모델의 id.

foreignKey 따로 지정하지 않는다면 이름이 모델명+기본 키인 컬럼이 모델에 생성됨.
만약 commenter를 foriegnKey로 직접 넣어주지 않았다면 user(모델명) + 기본 키(id)가 합쳐진 UserId가 foreignKey로 생성됨.

npm start로 서버 실행하면 다음과 같은 메시지 나옴.
시퀄라이즈가 스스로 실행하는 SQL문.

• 1:1
  1:1관계에서는 hasMany대신 hasOne 메서드 사용.
  사용자 정보 담고있는 가상의 Info 모델 있다고 하면 다음과 같이 표현.

db.User.hasOne(db.Info, {foreignKey:'UserId', sourceKey: 'id'});
db.Info.belongsTo(db.User, {foreignKey: 'UserId', targetKey: 'id'});

1:1관계라 해도 belongsTo와 hasOne이 반대면 안됨.
belongsTo를 사용하는 Info 모델에 UserId 컬럼 추가되기 때문.

• N:M
  belongsToMany 메서드.
  게시글 정보 담고 있는 Post 모델과 해시태그 정보 담고있는 HashTag 모델 있다고 할 때 다음과 같이 표현.

db.Post.belongsToMany(db.Hashtag, {through: 'PostHashtag});
db.Hashtag.belongsToMany(db.Post, {through: 'PostHashtag});

양쪽 모델 모두 belongsToMany 메서드 사용.
N:M 관계 특성상 새로운 모델 생성됨.
through 속성에 그 이름 적으면 됨.

새로 생성된 PostHashtag 모델에는 게시글과 해시태그의 아이디 저장됨.

N:M에서는 데이터 조회시 여러 단계 거쳐야 함.
먼저 #노드 해시태그를 Hashtag 모델에서 조회하고, 가져온 태그의 아이디(1)를 바탕으로 PostHashtag 모델이서 hashtagId가 1인 postId들을 찾아 Post 모델에서 정보를 가져옴.

• 쿼리 알아보기
  모델들을 사용해 CRUD 작업을 진행해보자.
  시퀄라이즈로 CRUD 작업 하려면 먼저 시퀄라이즈 쿼리 알아야 함.
  쿼리는 프로미스 반환하므로 then 붙여 결과값 받을 수 있음.
  async/await 문법과 같이 사용 가능.

• 로우 생성하는 쿼리 알아보자.

// 첫 줄이 SQL문, 그 아래는 시퀄라이즈 쿼리
Insert INTO nodejs.users (name, age, married, commnet) VALUES ('zero', 20, 0, '자기소개1');
const {User} = require('../models'); // models 모듈에서 User 모델 불러와 create 메서드 사용

User.create({
    name: 'zero',
    age: 24,
    married: false,
    comment: '자기소개1',
})

주의할 점은 데이터 넣을 때 MySQL 자료형 아닌 시퀄라이즈 모델에 정의한 자료형대로 넣어야 한다는 것.
시퀄라이즈가 알아서 MySQL 자료형으로 바꿈.
married가 0 아닌 false인 이유.

• 로우 조회하는 쿼리.
  다음은 users 테이블의 모든 데이터 조회하는 SQL문.
  findAll 메서드 사용.

Select * FROM nodejs.users;
User.findAll({});

users 테이블의 데이터 하나만 가져오는 SQL문.
하나만 가져올때는 findOne, 여러개 가져올때는 findAll 메서드 사용.

Select * FROM nodejs.users LIMIT 1;
User.findOne({});

attributes 옵션 사용해 원하는 컬럼만 가져오기.

Select name, married FROM nodejs.users;
User.findAll({
    attributes: ['name', 'married'],
});

where 옵션은 조건 나열.

Select name, age FROM nodejs.users WHERE married = 1 AND age > 30;
const {Op} = require('sequelize');
const {User} = require('../models');
User.findAll({
    attributes: ['name', 'age'],
    where: {
        married: 1,
        age: {[Op.gt]: 30},
    },
});

MySQL에서는 undefined 자료형 지원하지 않으므로 where 옵션에 undefinded 들어가면 안됨.
빈 값 넣으려면 null 사용.

시퀄라이즈는 js 객체를 사용해서 쿼리를 생성해야 하므로 Op.gt(초과) 같은 특수 연산자 사용.

Op.or(또는)를 사용해보자.

Select id, age FROM nodejs.users WHERE married = 1 AND age > 30;
const {Op} = require('sequelize');
const {User} = require('../models');
User.findAll({
    attributes: ['id', 'age'],
    where: {
        [Op.or]: [{married: 0}, {age: {[Op.gt]: 30}}];
    },
});

Op.or 속성에 OR연산 적용할 쿼리들을 배열로 나열하면 됨.

Select id, age FROM nodejs.users ORDER BY age DESC;
User.findAll({
    attributes: ['id', 'age'],
    order: [['age', 'DESC']],
});

시퀄라이즈의 정렬 방식이며, order 옵션으로 가능.
배열 안에 배열 있다는 점 주의.
정렬을 꼭 컬럼 하나로 하는 게 아니라 컬럼 두 개 이상으로도 할 수 있음.

• 로우 수정하는 쿼리.

UPDATE nodejs.users SET comment = '바꿀 내용' WHERE id = 2;
User.update({
    comment: '바꿀 내용',
}, {
    where: {id: 2},
});

update 메서드로 수정.
첫 인수는 수정할 내용, 두번째 인수는 어떤 로우 수정할 지에 대한 조검.

• 로우 삭제하는 쿼리.

DELETE nodejs.users SET WHERE id = 2;
User.destroy({
    where: {id: 2},
});

• 관계 쿼리
  findOne이나 findAll 메서드 호출 시 프로미스의 결과로 모델을 반환.
  https://thebook.io/080229/ch07/06/04/01/

... 뒤에 먼저 하고 추가할것

• 쿼리 수행하기
  배웠던 쿼리들로 CRUD 작업을 해보자.
  모델에서 데이터를 받아 페이지를 렌더링하는 방법과 JSON 형식으로 데이터를 가져오는 방법을 알아보자.

간단하게 사용자 정보를 등록하고, 사용자가 등록한 댓글을 가져오는 서버.
views 폴더 만들고 그 안에 sequelize.html, error.html 파일 만든다.
AJAX 사용해 서버와 통신.