[JAVA] SQLite 무작정 시작하기 (6) - DELETE

이전글

2020/11/15 - [Back-end/JAVA] - [JAVA] SQLite 무작정 시작하기 (1) - DATABASE 연결/해제

2020/11/15 - [Back-end/JAVA] - [JAVA] SQLite 무작정 시작하기 (2) - TABLE 생성/삭제

2020/11/15 - [Back-end/JAVA] - [JAVA] SQLite 무작정 시작하기 (3) - INSERT

2020/11/15 - [Back-end/JAVA] - [JAVA] SQLite 무작정 시작하기 (4) - SELECT

2020/11/15 - [Back-end/JAVA] - [JAVA] SQLite 무작정 시작하기 (5) - UPDATE

 

 

 

서론

  자 이번에는 CRUD(Create Read Update Delete)의 마지막인 DELETE를 구해보도록 하겠다.

 

 

 

소스코드

1. DMLService.java

package com.dochi.db.ex;
 
import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.SQLException;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Date;
import java.util.List;
import java.util.Map;
 
public class DMLService extends SQLiteManager {
    
    // 상수 설정
    //   - DateFormat 설정
    public static final SimpleDateFormat DATETIME_FMT = new SimpleDateFormat("yyyyMMddHHmmss");
    
    // 생성자
    public DMLService() {
        
    }
    public DMLService(String url) {
        super(url);
    }
    
    // 데이터 삽입 함수
    public int insertBlogArticle(Map<String, Object> dataMap) throws SQLException {
        // 상수 설정
        //   - 데이터 입력 SQL 변수
        final String sql = "INSERT INTO CW_BLOG_ATCL_LIST ("+"\n"
                   + "    BLOG_ID,                         "+"\n"
                   + "    CATE_ID,                         "+"\n"
                   + "    ATCL_ID,                         "+"\n"
                   + "    URL,                             "+"\n"
                   + "    TITLE,                           "+"\n"
                   + "    WORK_YN,                         "+"\n"
                   + "    REG_DTTM                         "+"\n"
                   + ") VALUES (                           "+"\n"
                   + "    ?,                               "+"\n"
                   + "    ?,                               "+"\n"
                   + "    ?,                               "+"\n"
                   + "    ?,                               "+"\n"
                   + "    ?,                               "+"\n"
                   + "    ?,                               "+"\n"
                   + "    ?                                "+"\n"
                   + ")";
 
        // 변수설정
        //   - Database 변수
        Connection conn = ensureConnection();
        PreparedStatement pstmt = null;
 
        //   - 입력 결과 변수
        int inserted = 0;
 
        try {
            // PreparedStatement 생성
            pstmt = conn.prepareStatement(sql);
 
            // 입력 데이터 매핑
            pstmt.setObject(1, dataMap.get("BLOG_ID"));
            pstmt.setObject(2, dataMap.get("CATE_ID"));
            pstmt.setObject(3, dataMap.get("ATCL_ID"));
            pstmt.setObject(4, dataMap.get("URL"));
            pstmt.setObject(5, dataMap.get("TITLE"));
            pstmt.setObject(6, dataMap.get("WORK_YN"));
            pstmt.setObject(7, DATETIME_FMT.format(new Date()));
 
            // SQL 실행
            pstmt.executeUpdate();
 
            // 입력 건수 조회
            inserted = pstmt.getUpdateCount();
 
            // 트랜잭션 COMMIT
            conn.commit();
 
        } catch (SQLException e) {
            // 오류출력
            System.out.println(e.getMessage());
            
            // 오류
            inserted = -1;
            
            // 트랜잭션 ROLLBACK
            if( conn != null ) {
                conn.rollback();
            }
 
        } finally {
            // PreparedStatement 종료
            if( pstmt != null ) {
                try {
                    pstmt.close();
                } catch (SQLException e) {
                    e.printStackTrace();
                }
            }
        }
 
        // 결과 반환
        //   - 입력된 데이터 건수
        return inserted;
    }
 
    // 데이터 수정 함수
    public int updateBlogArticle(Map<String, Object> dataMap, Map<String, Object> updateMap) throws SQLException {
        // 상수 설정
        //   - 수정할 컬럼을 동적으로 작성하기 위한 SQL 변수
        final StringBuilder sqlBuilder = new StringBuilder();
        //   - PreparedStatement 객체에 데이터를 매핑할 순서를 저장할 변수
        final List<String> updateSeq = new ArrayList<String>();
 
        // 수정일자 추가
        updateMap.put("UPD_DTTM", DATETIME_FMT.format(new Date()));
        
        // 동적 SQL 작성
        sqlBuilder.append("UPDATE CW_BLOG_ATCL_LIST \n");
        sqlBuilder.append("SET ");
        sqlBuilder.append(
            // 수정할 Data를 조회하여 동적 SQL 작성
            updateMap.keySet().stream().reduce("", (prev, current)->{
                // 데이터를 매핑할 순서를 저장
                updateSeq.add(current);
                
                current = current + " = ? ";
                if( !"".equals(prev) ) {
                    prev = prev+", ";
                }
                
                return prev+current+"\n";
            })
        );
        sqlBuilder.append("WHERE 1=1 \n");
        sqlBuilder.append("  AND BLOG_ID = ? \n");
        sqlBuilder.append("  AND CATE_ID = ? \n");
        sqlBuilder.append("  AND ATCL_ID = ? \n");
 
        //   - 최종 SQL
        final String SQL = sqlBuilder.toString();
 
        // 변수설정
        //   - Database 변수
        Connection conn = ensureConnection();
        PreparedStatement pstmt = null;
 
        //   - 수정 결과 변수
        int updated = 0;
 
        try {
            // PreparedStatement 객체 생성
            pstmt = conn.prepareStatement(SQL);
 
            // 수정할 데이터 매핑
            int updateSize = updateSeq.size();
            for(int i=1; i<=updateSize; i++ ) {
                pstmt.setObject(i, updateMap.get(updateSeq.get(i-1)));
            }
 
            // 수정할 데이터 조건 매핑
            pstmt.setObject(updateSize+1, dataMap.get("BLOG_ID"));
            pstmt.setObject(updateSize+2, dataMap.get("CATE_ID"));
            pstmt.setObject(updateSize+3, dataMap.get("ATCL_ID"));
 
            // SQL 실행
            pstmt.executeUpdate();
    
            // 수정 건수 조회
            updated = pstmt.getUpdateCount();
 
            // 트랜잭션 COMMIT
            conn.commit();
 
        } catch (SQLException e) {
            // 오류처리
            System.out.println(e.getMessage());
            
            // 오류
            updated = -1;
            
            // 트랜잭션 ROLLBACK
            conn.rollback();
 
        } finally  {
            // PreparedStatement 종료
            if( pstmt != null ) {
                try {
                    pstmt.close();
                } catch ( SQLException e ) {
                    e.printStackTrace();
                }
            }
        }
 
        // 결과 반환
        //   - 수정된 데이터 건수
        return updated;
    }
 
    // 데이터 삭제 함수
    public int deleteBlogArticle(Map<String, Object> dataMap) throws SQLException {
        final String sql = "DELETE FROM CW_BLOG_ATCL_LIST  "+"\n"
                         + " WHERE 1=1                     "+"\n"
                         + "   AND BLOG_ID = ?             "+"\n"
                         + "   AND CATE_ID = ?             "+"\n"
                         + "   AND ATCL_ID = ?             "+"\n"
                         ;
 
        // 변수설정
        //   - Database 변수
        Connection conn = ensureConnection();
        PreparedStatement pstmt = null;
 
        //   - 삭제 결과 변수
        int deleted = 0;
 
        try {
            // PreparedStatement 객체 생성
            pstmt = conn.prepareStatement(sql);
 
            // 조회 데이터 조건 매핑
            pstmt.setObject(1, dataMap.get("BLOG_ID"));
            pstmt.setObject(2, dataMap.get("CATE_ID"));
            pstmt.setObject(3, dataMap.get("ATCL_ID"));
 
            // SQL 실행
            pstmt.executeUpdate();
            
            // 데이터 삭제 건수
            deleted = pstmt.getUpdateCount();
 
            // 트랜잭션 COMMIT
            conn.commit();
 
        } catch (SQLException e) {
            // 오류처리
            System.out.println(e.getMessage());
            
            // 오류
            deleted = -1;
 
            // 트랜잭션 ROLLBACK
            conn.commit();
 
        } finally  {
            // PreparedStatement 종료
            if( pstmt != null ) {
                try {
                    pstmt.close();
                } catch ( SQLException e ) {
                    e.printStackTrace();
                }
            }
        }
 
        // 결과 반환
        //   - 삭제된 데이터 건수
        return deleted;
    }
}
 

 

2. App.java

package com.dochi.db.ex;
 
import java.sql.SQLException;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
 
import com.dochi.db.ex.DDLService.ResultType;
 
public class App {
 
    // 변수 생성
    //   - DDL 객체 변수 ( dochi.db 파일 생성 )
    private DDLService DDL = new DDLService("jdbc:sqlite:dochi.db");
 
    //   - DML 객체 변수 ( dochi.db 파일 수정 )
    private DMLService DML = new DMLService("jdbc:sqlite:dochi.db");
    
    //   - DQL 객체 변수 ( dochi.db 파일 조회 )
    private DQLService DQL = new DQLService("jdbc:sqlite:dochi.db");
 
    // 테이블 생성 함수
    public void createTable() throws SQLException {
        final String SQL = "CREATE TABLE IF NOT EXISTS CW_BLOG_ATCL_LIST (   "+"\n"
                         + "  BLOG_ID     TEXT           NOT NULL,           "+"\n"
                         + "  CATE_ID     TEXT           NOT NULL,           "+"\n"
                         + "  ATCL_ID     TEXT           NOT NULL,           "+"\n"
                         + "  URL         TEXT           NOT NULL,           "+"\n"
                         + "  TITLE       TEXT,                              "+"\n"
                         + "  WORK_YN     INTEGER        DEFAULT 0,          "+"\n"
                         + "  REG_DTTM    TEXT,                              "+"\n"
                         + "  UPD_DTTM    TEXT,                              "+"\n"
                         + "  PRIMARY KEY(BLOG_ID, CATE_ID, ATCL_ID)        )";
 
        // 테이블 생성
        ResultType result = DDL.createTable("CW_BLOG_ATCL_LIST", SQL);
 
        // 테이블 생성 결과 출력
        switch( result ) {
            case SUCCESS:
                System.out.println("테이블 생성 완료.");
                break;
            case WARNING:
                System.out.println("테이블이 이미 존재합니다.");
                break;
            case FAILURE:
                System.out.println("테이블 생성 실패.");
                break;
        }
 
        // DB 연결 종료
        DDL.closeConnection();
    }
 
    // 테이블 삭제 함수
    public void dropTable() throws SQLException {
 
        // 테이블 삭제
        ResultType result = DDL.dropTable("CW_BLOG_ATCL_LIST");
 
        // 테이블 삭제 결과 출력
        switch( result ) {
            case SUCCESS:
                System.out.println("테이블 삭제 완료.");
                break;
            case WARNING:
                System.out.println("테이블이 존재하지 않습니다.");
                break;
            case FAILURE:
                System.out.println("테이블 삭제 실패.");
                break;
        }
 
        // DB 연결 종료
        DDL.closeConnection();
    }
    
    // 데이터 입력 함수
    public void insert() throws SQLException {
        // 상수 설정
        //   - Data를 저장할 객체 생성
        //     * 입력/수정/삭제/조회 에서 공통으로 사용
        final Map<String, Object> dataMap = new HashMap<String, Object>();
        dataMap.put("BLOG_ID"   , "heodolf.tistory.com");
        dataMap.put("CATE_ID"   , "/");
        dataMap.put("ATCL_ID"   , "0");
        dataMap.put("URL"       , "https://heodolf.tistory.com/134");
        dataMap.put("TITLE"     , "[JAVA] Quartz 스케줄러 만들기 (1) - 실행");
        dataMap.put("WORK_YN"   , 0);
 
        // 데이터 입력
        int inserted = DML.insertBlogArticle(dataMap);
        if( inserted >= 0 ) {
            System.out.println(String.format("데이터 입력 성공: %d건", inserted));
        } else {
            System.out.println("데이터 입력 실패");
        }
    }
    
    // 데이터 조회 함수
    public void select() {
        // 상수 설정
        //   - 조회할 데이터
        final Map<String, Object> dataMap = new HashMap<String, Object>();
        dataMap.put("BLOG_ID"   , "heodolf.tistory.com");
        dataMap.put("CATE_ID"   , "/");
        
        // 데이터 조회
        //   - 수집한 블로그 목록 조
        List<Map<String, Object>> result = DQL.selectBlogArticleList(dataMap);
 
        // 조회 결과 출력
        DQL.printMapList(result);
    }
    
    // 데이터 수정 함수
    public void update() throws SQLException {
        // 상수 설정
        //   - 조회할 데이터
        final Map<String, Object> dataMap = new HashMap<String, Object>();
        dataMap.put("BLOG_ID"   , "heodolf.tistory.com");
        dataMap.put("CATE_ID"   , "/");
        dataMap.put("ATCL_ID"   , "0");
 
        //   - 수정할 데이터
        final Map<String, Object> updateMap = new HashMap<String, Object>();
        updateMap.put("WORK_YN"    , 1);
        updateMap.put("TITLE"    , "원하는 컬럼을 마음대로 수정!");
 
        // 수정 결과 출력
        int updated = DML.updateBlogArticle(dataMap, updateMap);
        if( updated >= 0 ) {
            System.out.println(String.format("데이터 수정 성공: %d건", updated));
        } else {
            System.out.println("데이터 수정 실패");
        }
    }
 
    // 데이터 삭제 함수
    public void delete() throws SQLException {
        // 상수 설정
        //   - 조회할 데이터
        final Map<String, Object> dataMap = new HashMap<String, Object>();
        dataMap.put("BLOG_ID"   , "heodolf.tistory.com");
        dataMap.put("CATE_ID"   , "/");
        dataMap.put("ATCL_ID"   , "0");
 
        // 데이터 삭제
        int deleted = DML.deleteBlogArticle(dataMap);
        if( deleted >= 0 ) {
            System.out.println(String.format("데이터 삭제 성공: %d건", deleted));
        } else {
            System.out.println("데이터 삭제 실패");
        }
    }

    public static void main(String[] args) throws SQLException {
        App db = new App();
 
        db.dropTable();       // 테이블 삭제
        db.createTable();   // 테이블 생성
        
        db.insert();        // 데이터 입력
        db.select();        // 데이터 조회
        
        db.update();        // 데이터 수정
        db.select();        // 데이터 조회
        
        db.delete();        // 데이터 삭제
        db.select();        // 데이터 조회
    }
}
 

 

 

 

실행결과

[ 데이터 삭제 실행 결과 ]

 

 

 

마치며

  이번 포스트를 마지막으로 SQLite로 데이터베이스와 테이블을 생성하고, CRUD를 구현해보았다. 소스가 점점 길어져서 추가한 부분만 따로 작성할까 했는데, 역시 소스가 통째로 있어야 실제로 필요할 때 바로 적용해 볼 수 있고 전체 흐름을 파악하는데 더 좋을것 같아서 이전 소스들과 함께 작성하였다.

  다음 포스트에서는 SQLite의 마지막 포스트로써 데이터를 삽입할 때, 여러개를 한번에 입력하는 방법에 대해서 다루어 보도록 하겠다.