JDBC : HDF 파일 Insert

/*****************************************************************************
 * Copyright by The HDF Group.                                               *
 * Copyright by the Board of Trustees of the University of Illinois.         *
 * All rights reserved.                                                      *
 *                                                                           *
 * This file is part of the HDF Java Products distribution.                  *
 * The full copyright notice, including terms governing use, modification,   *
 * and redistribution, is contained in the files COPYING and Copyright.html. *
 * COPYING can be found at the root of the source code distribution tree.    *
 * Or, see http://hdfgroup.org/products/hdf-java/doc/Copyright.html.         *
 * If you do not have access to either file, you may request a copy from     *
 * help@hdfgroup.org.                                                        *
 ****************************************************************************/
 
package com.enjoybt.mdriv;
 
import java.sql.Connection;
import java.sql.Driver;
import java.sql.DriverManager;
import java.sql.DriverPropertyInfo;
import java.sql.PreparedStatement;
import java.sql.SQLException;
import java.sql.SQLFeatureNotSupportedException;
import java.sql.Statement;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Properties;
import java.util.logging.Logger;
 
import org.postgresql.geometric.PGpolygon;
 
import com.graphbuilder.geom.Point2d;
 
import ucar.ma2.Array;
import ucar.ma2.Index;
import ucar.ma2.StructureDataA;
import ucar.nc2.NetcdfFile;
import ucar.nc2.Variable;
 
public class ReadCrossSectionTemp_polygon2 {
    
    private static String fname = "C:\\Users\\82109\\Downloads\\nakdongk2.p02.hdf"; //
    private static String dbUrl = "jdbc:postgresql://192.0.0.5:8080/drrrr"; //사용하려는 데이터베이스 명을 포함한 URL 기술
    private static String userName = "drrrr"; //사용자 계정
    private static String userPassword = "drrrr00"; //사용자 계정의 패스워드
 
    public static void main(String args[]) throws Exception {
        
        //JAVA DB Connetion 
        Connection conn = null; //null로 초기화 한다.
        PreparedStatement psmt = null;
        
        //open(String location)
        //Open an existing netcdf file (read only). //기존 netcdf 파일을 염
        NetcdfFile dataFile = null;
 
        try {
            
            //DriverManager 객체로부터 Connection 객체를 얻어온다.
            conn = DriverManager.getConnection(dbUrl, userName, userPassword);   
            
            dataFile = NetcdfFile.open(fname); // 파일 경로 연결
 
            //Variable : 변하기 쉬운
            //findVariable(String fullNameEscaped)
            //지정된 (이스케이프 된 전체) 이름을 가진 변수를 찾으십시오. 
            //여러 그룹 및 / 또는 구조에 중첩 될 수 있습니다. 포함 된 "." structure.member로 해석됩니다. 포함 된 "/"는 그룹 / 변수로 해석됩니다. 
            //이름에 실제로 "."가 있으면 이스케이프해야합니다 (NetcdfFile.escapeName (varname) 호출) 
            //테스트하기 전에 제거 된 다른 문자도 이스케이프 될 수 있습니다.
            //변수 또는 찾지 못한 경우 null입니다. 
            //return Variable
            Variable crossSections = dataFile.findVariable("Geometry/Cross_Sections/Attributes"); // 311
            Variable crossPolyline_info = dataFile.findVariable("Geometry/Cross_Sections/Polyline_Info"); // 311, 4
            Variable crossPolyline_Points = dataFile.findVariable("Geometry/Cross_Sections/Polyline_Points"); // 1545, 2
 
            System.out.println(crossSections);
            
            //Variable => read(); : 
            //이 변수에 대한 모든 데이터를 읽고 메모리 상주 배열을 리턴하십시오. 배열은 변수와 요소 유형 및 모양이 동일합니다.
            //변수가 구조체 배열의 멤버 인 경우 첫 번째 구조체에서 변수의 데이터 만 반환하므로 배열 모양이 변수와 동일합니다. 
            //모든 구조의 데이터를 읽으려면 ncfile.readSection ()을 사용하십시오.
            //return : Array
            Array crossAttributesArr = crossSections.read();
            Array crossPolylineInfoArr = crossPolyline_info.read();
            Array crossPolylinePointsArr = crossPolyline_Points.read();
 
            //Variable => getShape();
            //각 차원에서 모양 : 가변 길이를 가져옵니다. 스칼라 (랭크 0)의 모양은 int [0]입니다.
            //길이가 이 변수의 순위 이며 값이 해당 Dimension(치수)의 길이와 동일한 int 배열
            //return : int []
            int[] crossAttributesShapes = crossSections.getShape();
 
            System.out.println(crossAttributesShapes[0]);
 
            int[] polylineInfoShape = crossPolylineInfoArr.getShape();
 
            //Array => getIndex();
            //이 Array의 인덱스 액세스에 사용되는 Index 객체를 가져옵니다.
            Index polylineInfoIdx = crossPolylineInfoArr.getIndex();
            Index polylinePointsIdx = crossPolylinePointsArr.getIndex();
 
            Map<String, List<Point>> result = new HashMap<String, List<Point>>();
 
            for (int i = 0; i < crossAttributesShapes[0]; i++) {
 
                //Array => getObject(index);
                //인덱스의 배열 요소를 Object로 가져옵니다. 반환 된 값은 객체에 래핑됩니다 
                
                //StructureDataA : StructureData 구현은 모든 것을 포함하는 ArrayStructure에 위임
                StructureDataA crossAttributesAttr = (StructureDataA) crossAttributesArr.getObject(i);
                
                //getJavaArrayString ( StructureMembers.Member  m) 
                // : char 또는 String 유형의 멤버에 대한 JAVA 문자열 배열을 가져옴 
                //return : char 또는 String 유형
                String riverName = crossAttributesAttr.getJavaArrayString("River")[0];
                String reachName = crossAttributesAttr.getJavaArrayString("Reach")[0];
 
                
                //Index => set(i, j);
                //차원 0,1에서 현재 요소를 v0, v1로 설정
                //매개 변수 :
                //    v0 -차원 0 인덱스를이 값으로 설정
                //    v1 -차원 1 색인을이 값으로 설정
                int pointStartIdx = crossPolylineInfoArr.getInt(polylineInfoIdx.set(i, 0)); // 0,5 10 ,15
                int pointCount = crossPolylineInfoArr.getInt(polylineInfoIdx.set(i, 1)); // 5
 
                //crossSection(LineString)의 첫 점의 XY 좌표와 끝점의 XY 좌표를 가져옴.   
                Double point1X = crossPolylinePointsArr.getDouble(polylinePointsIdx.set(pointStartIdx + 0, 0));
                Double point1Y = crossPolylinePointsArr.getDouble(polylinePointsIdx.set(pointStartIdx + 0, 1));
                Double point2X = crossPolylinePointsArr.getDouble(polylinePointsIdx.set(pointStartIdx + pointCount - 1, 0));
                Double point2Y = crossPolylinePointsArr.getDouble(polylinePointsIdx.set(pointStartIdx + pointCount - 1, 1));
                
                //Map의 Key로 넣을 변수 생성 
                String key = riverName + "_" + reachName; 
    
                //Map에 key가 존재하면 ~  
                if (result.containsKey(key)) {
                    result.get(key).add(new Point(i+1, point1X, point1Y, point2X, point2Y));
                } else { 
                    List<Point> aaa = new ArrayList<Point>(); 
                    aaa.add(new Point(i+1, point1X, point1Y, point2X, point2Y)); 
                    result.put(key, aaa); 
                }
            }
 
            //System.out.println("----aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa----");
            Iterator<String> keyIter = result.keySet().iterator();
 
            Map<String, List<Point>> resultPolygon = new HashMap<String, List<Point>>();
 
            while (keyIter.hasNext()) {
                
                String keyName = keyIter.next();
 
                List<Point> pointList = (List<Point>) result.get(keyName);
 
                for (int i = 0; i < pointList.size(); i++) {
 
                    if (i == pointList.size() - 1) {
                        continue;
                    } else {
 
                        Point point1 = pointList.get(i);
                        Point point2 = pointList.get(i + 1);
                        
                        if (resultPolygon.containsKey(keyName)) {
                            resultPolygon.get(keyName).add(new Point(point1.getIdx(), point1.getX1(), point1.getY1(), 
                                    point1.getX2(), point1.getY2(), point2.getX1(), point2.getY1(), point2.getX2(), point2.getY2()));
                        } else {
                            List<Point> polygon = new ArrayList<Point>();
                            polygon.add(new Point(point1.getIdx(), point1.getX1(), point1.getY1(), 
                                    point1.getX2(), point1.getY2(), point2.getX1(), point2.getY1(), point2.getX2(), point2.getY2()));
                            resultPolygon.put(keyName, polygon);
                        }
                    }
                }
            }
 
            System.out.println("----bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb----");
 
            Map<String, List<StringBuffer>> resultPgGeom = new HashMap<String, List<StringBuffer>>();
            
            Iterator<String> keyPolyIter = resultPolygon.keySet().iterator();
            
            String sql = "INSERT INTO TEMP.TMP_CROSS_SECTIONS_AREA VALUES(?, ST_GEOMFROMTEXT(?, 4326))";  //SQL 쿼리
 
            psmt = conn.prepareStatement(sql); //prepareStatement에서 해당 sql을 미리 컴파일 한다.
 
            while (keyPolyIter.hasNext()) {
 
                String keyName = keyPolyIter.next();
 
                List<Point> polygon = (List<Point>) resultPolygon.get(keyName);
 
                for(int i =0; i < polygon.size(); i++) {
                    
                    String polygonGeom = null;
                
                    Point pt = polygon.get(i);
                    //POLYGON((-71.1776585052917 42.3902909739571,-71.1776820268866 42.3903701743239,
                    //-71.1776063012595 42.3903825660754,-71.1775826583081 42.3903033653531,-71.1776585052917 42.3902909739571))    
                    polygonGeom = "POLYGON((";                
                    polygonGeom += pt.getX1_1() + " " + pt.getY1_1() + "," + pt.getX2_1() + " " + pt.getY2_1() + ",";
                    polygonGeom += pt.getX2_2() + " " + pt.getY2_2() + "," + pt.getX1_2() + " " + pt.getY1_2() + ",";
                    polygonGeom += pt.getX1_1() + " " + pt.getY1_1()+ "))";
 
                    //Statement smtm = null;
                    //smtm = conn.createStatement();
                    //smtm.executeUpdate(sql);
                    System.out.println("idx : " +  pt.getIdx());
                    System.out.println("polygonGeom : " + polygonGeom);
                    
                    //여러번 반복해서 쿼리를 실행하기 위해서 위처럼 사용하면 안된다. 
                    //보기에는 문제가 없고 일반적인 객체의 경우는 저렇게 재할당해서 사용해도 되기는 하지만 PrepareStatement는 다르다.
                    //저렇게한 다음에 psmt.close();를 실행하면 아래쪽 맨 마지막 psmt만 닫히고 앞의 psmt들은 닫히지 않는다.
                    //정확히 말하면 앞에서 할당한 psmt는 결코 닫을 수 없는 형태가 되어버린다. 
                    
                    //아래와 같이 PreparedStatement의 객체를 새로 할당하는게 아니라 파라미터를 할당하고 
                    //실행한 다음에 psmt.clearParameters();로 파라미터를 클리어 해버린다. 
                    //루프돌면서 다시 할당하고 이렇게 돌리면 PreparedStatement 객체를 여러번 사용할 수 있다.
                    psmt.clearParameters();
                    
                    psmt.setInt(1, pt.getIdx()); //첫번째 ?에 들어갈 값 넣기
                    psmt.setString(2, polygonGeom); //두번째 ?에 들어갈 값 넣기
                    
                    //예제)
                    //JDBC의 배치기능을 사용한 것. PreparedStatement의 배치기능은 다수의 쿼리를 한꺼번에 실행하기 위한 기능이다. 
                    //여러번에 나누어서 실행하지 않고 배치기능을 이용해서 한번에 송신해서 실행함으로써 퍼포먼스를 높일 수 있다. 
                    //addBatch()는 쿼리와 파라미터 셋을 배치에 추가하고 이렇게 추가도니 배치를 
                    //executeBatch()를 통해서 한꺼번에 실행한다. 
                    //너무 많은 배치를 추가할 경우에는 'out of memory'가 발생할 수 있기 때문에 많은 addBatch()를 실행해야 할 경우에는 
                    //중간중간 executeBathch()를 실행해 주어야 한다. 
                    
                    //StringBuffer sql = new StringBuffer(" INSERT INTO poll (col1, col2 ) VALUES (?, ?) ");
                    //psmt = conn.prepareStatement(sql.toString());
 
                    //for(int i = 0; i<5; i++) {
                    //    psmt.setString(1, "test");
                    //    psmt.setString(2, "test");
                    //    psmt.addBatch();
                    //   psmt.clearParameters();
                    //}
                    //psmt.executeBatch();
 
                    psmt.executeUpdate(); //쿼리 실행
                }    
            }            
        } catch (SQLException e) {
            e.printStackTrace();
        }finally{ // 쿼리가 성공 또는 실패에 상관없이 사용한 자원을 해제 한다. (순서중요)
            if(psmt != null) try{psmt.close();}catch(SQLException sqle){}            // PreparedStatement 객체 해제    
            if(conn != null) try{conn.close();}catch(SQLException sqle){}            // Connection 해제
        
        }
    }
}