[JAVA] SQLite 무작정 시작하기 (4) - SELECT

이전글

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

 

 

 

서론

  이전 포스트에서 데이터를 테이블에 입력하였는데, 실제 데이터가 들어가 있는지 확인해보진 않았다. 그래서, 이번 포스트에서는 실제 적재되어 있는 데이터를 조회하여 출력하는 방법에 대해서 다루어 보도록 하겠다.

 

 

 

소스코드

1. DQLService.java

package com.dochi.db.ex;
 
import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.ResultSetMetaData;
import java.sql.SQLException;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.HashSet;
import java.util.List;
import java.util.Map;
import java.util.Set;
 
public class DQLService extends SQLiteManager {
    
    // 생성자
    public DQLService() {
        
    }
    public DQLService(String url) {
        super(url);
    }
 
    // 데이터 조회 함수
    public List<Map<String, Object>> selectBlogArticleList(Map<String, Object> dataMap){
        // 상수설정
        //   - SQL
        final String SQL = "SELECT T1.BLOG_ID           "+"\n"
                         + "     , T1.CATE_ID           "+"\n"
                         + "     , T1.ATCL_ID           "+"\n"
                         + "     , T1.TITLE             "+"\n"
                         + "     , T1.URL               "+"\n"
                         + "     , T1.WORK_YN           "+"\n"
                         + "     , T1.REG_DTTM          "+"\n"
                         + "     , T1.UPD_DTTM          "+"\n"
                         + "  FROM CW_BLOG_ATCL_LIST T1 "+"\n"
                         + " WHERE 1=1                  "+"\n"
                         + "   AND T1.BLOG_ID = ?       "+"\n"
                         + "   AND T1.CATE_ID = ?       "+"\n"
                         ;
        
        //   - 조회 결과 변수
        final Set<String> columnNames = new HashSet<String>();        
        final List<Map<String, Object>> selected = new ArrayList<Map<String, Object>>();
 
        // 변수설정
        //   - Database 변수
        Connection conn = ensureConnection();
        PreparedStatement pstmt = null;
        ResultSetMetaData meta = null;
        
        try {
            // PreparedStatement 객체 생성
            pstmt = conn.prepareStatement(SQL);
            
            // 조회 데이터 조건 매핑
            pstmt.setObject(1, dataMap.get("BLOG_ID"));
            pstmt.setObject(2, dataMap.get("CATE_ID"));
            
            // 데이터 조회
            ResultSet rs = pstmt.executeQuery();
            
            // 조회된 데이터의 컬럼명 저장
            meta = pstmt.getMetaData();
            for(int i=1; i<=meta.getColumnCount(); i++) {
                columnNames.add(meta.getColumnName(i));
            }
            
            // ResultSet -> List<Map> 객체
            Map<String, Object> resultMap = null;
            
            while(rs.next()) {
                resultMap = new HashMap<String, Object>();
                
                for(String column : columnNames) {
                    resultMap.put(column, rs.getObject(column));
                }
                
                if( resultMap != null ) {
                    selected.add(resultMap);
                }
            }
            
        } catch (SQLException e) {
            // 오류처리
            System.out.println(e.getMessage());
            
        } finally  {
            try {
                // PreparedStatement 종료
                if( pstmt != null ) {
                    pstmt.close();
                }
                
                // Database 연결 종료
                closeConnection();
                
            } catch ( SQLException e ) {
                e.printStackTrace();
            }
        }
 
        // 결과 반환
        //   - 조회된 데이터 리스트
        return selected;
    }
 
    // 조회 결과 출력 함수
    public void printMapList(List<Map<String, Object>> mapList) {
        if( mapList.size() == 0 ) {
            System.out.println("조회된 데이터가 없습니다.");
            return;
        }
        
        // 상세 데이터 출력
        System.out.println(String.format("데이터 조회 결과: %d건", mapList.size()));
        
        for(int i = 1; i <= mapList.size(); i++) {
            Map<String, Object> map = mapList.get(i-1);
            
            StringBuilder sb = new StringBuilder();
            
            sb.append(i);
            sb.append(": {");
            map.entrySet().forEach(( entry )->{
                sb.append('"')
                    .append(entry.getKey())
                    .append("\": \"")
                    .append(entry.getValue())
                    .append("\", ");
            });
            sb.append("}");
            
            System.out.println(sb.toString());
        }
    }
}
 

 

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 static void main(String[] args) throws SQLException {
        App db = new App();
 
        db.dropTable();     // 테이블 삭제
        db.createTable();   // 테이블 생성
        db.insert();        // 데이터 입력
        db.select();        // 데이터 조회
    }
}
 

 

 

 

실행결과

 

 

 

마치며

  이렇게 데이터를 입력하고 조회까지 만들어보니 어느정도 Database의 구색이 갖춰진것 같다. 하지만, 아직 우리에겐 UPDATE와 DELETE가 남아있다. 다음 포스트에서 하나 하나 다뤄보도록 하겠다.