๐ข ๋ค์ด๊ฐ๋ฉฐ
์ต๊ทผ์ node-jdbc๋ฅผ ์ฌ์ฉํ๋ฉด์ ํท๊ฐ๋ ธ๋
JDBC api ์ ์ธํฐํ์ด์ค๋ค์ ๋ค์ ๋ณต์ตํ๊ณ ์ ํฌ์คํ ์ ์์ฑํ๋ค.
์ด๋ฒ ํฌ์คํ ์์ JDBC์ ๋ํด ์์๋ณธ๋ค.
๐ค JDBC๋?
Java Database Connectiviy ์ ์ค์๋ง์ด๋ค.
์ง์ญํ๋ฉด, ์๋ฐ ๋ฐ์ดํฐ๋ฒ ์ด์ค ์ฐ๊ฒฐ์ฑ์ด๋ ๋ป์ด๋ค.
๊ฒฐ๋ก ์ ์ผ๋ก JDBC๋ Java ๋ผ์ด๋ธ๋ฌ๋ฆฌ์ด๋ค.
Javaํ๋ก๊ทธ๋จ๊ณผ์ DB ๊ฐ์ ์ฐ๊ฒฐ์ ์ํ Java API์ ์งํฉ์ด๋ค.
๋ผ์ด๋ธ๋ฌ๋ฆฌ, API ๊ฐ๋ ์ ์ ๋ชจ๋ฅด๊ฒ ๋ค๋ฉด ์๋ ๋ ํฌ์คํ ์ ์ฐธ๊ณ .
- ํ๋ ์์ํฌ(Framework), ๋ผ์ด๋ธ๋ฌ๋ฆฌ(Library), ํ๋ฌ๊ทธ์ธ(Plug-in), ๋ชจ๋(Module)์ ์ฐจ์ด
- SDK, API์ ๊ฐ๋ ๊ณผ ์ฐจ์ด์
JDBC๋ JDK์ ํฌํจ๋์ด ์๊ธฐ ๋๋ฌธ์,
JAVA๋ฅผ ์ฌ์ฉํ๋ค๋ฉด ๋ณ๋์ ๋ค์ด๋ก๋ ๊ณผ์ ์ด ํ์ ์๋ค.
JDBC API ๋ ์๋์ ๊ฐ์ ์ญํ ์ ํ๋ค.
- ์๋ฐ ์ดํ๋ฆฌ์ผ์ด์ ๊ณผ DB ๊ฐ์ ์ฐ๊ฒฐ
- SQL ๋ฌธ ๋ง๋ค๊ธฐ
- ๋ฐ์ดํฐ๋ฒ ์ด์ค์์ SQL ๋ฌธ ์คํ
- SQL ์คํ ๊ฒฐ๊ณผ ๋ณด๊ธฐ
๐ก ์ฐธ๊ณ ) ODBC ์ JDBC ์ ์ฐจ์ด
ODBC๋
Open Database Connectivity ์ ์ฝ์์ด๋ค.
JDBC ์ ๊ฐ์ ๊ธฐ๋ฅ์ ํ๋, ์๋์ ๊ฐ์ ์ฐจ์ด์ ์ด ์๋ค.
JDBC | ODBC | |
---|---|---|
์ธ์ด ์ง์ | ์๋ฐ ์ธ์ด์ ํนํ๋์ด ์๋ค. | C/C++ ๊ธฐ๋ฐ ์ธ์ด๋ฅผ ์ง์ํ๋ค. |
ํ๋ซํผ ๋ ๋ฆฝ์ฑ | Java ์ธ์ด๊ฐ ์คํ๋๋ ๋ชจ๋ ํ๋ซํผ์์ ์ฌ์ฉ๊ฐ๋ฅํ๋ค. | Windows ์ด์์ฒด์ ์์ ์ฃผ๋ก ์ฌ์ฉ๋๋ค. |
๋๋ผ์ด๋ฒ ๊ด๋ฆฌ | JDBC ๋๋ผ์ด๋ฒ๋ฅผ ์ฌ์ฉํ์ฌ ๋ฐ์ดํฐ๋ฒ ์ด์ค์ ์ฐ๊ฒฐํ๋ค. | ODBC ๋๋ผ์ด๋ฒ๋ฅผ ์ฌ์ฉํ์ฌ ๋ฐ์ดํฐ๋ฒ ์ด์ค์ ์ฐ๊ฒฐํ๋ค. |
์ฑ๋ฅ | ODBC ์ ๋นํด ๋น ๋ฅด๋ค. | JDBC์ ๋นํด ๋๋ฆฌ๋ค. |
๋ณด์ | ์๋ฐ ํ๋ซํผ์ ๋ณด์ ๊ธฐ๋ฅ์ ํ์ฉํ์ฌ ๋์ ์์ค์ ๋ณด์ | C/C++ ๊ธฐ๋ฐ์ผ๋ก ๊ตฌํ๋์ด ํ๋ซํผ์ ๋ณด์ ๊ธฐ๋ฅ์ ์์กด |
๐ค JDBC ๊ตฌ์กฐ
JDBC ๋ ํฌ๊ฒ JDBC API ์ JDBC Driver Maner๋ก ๋๋ ์ ์๋ค.
JDBC API๋ JDBC API ์ JDBC DRIVER API ํฌ๊ฒ ๋๊ฐ์ง๋ก ๋๋ ์ ์๋ค.
JDBC API ๋ ์๋ฐ ์์ฉ ํ๋ก๊ทธ๋จ๊ณผ JDBC Manager ๊ฐ ์ฐ๊ฒฐ์ ์ ๊ณตํ๋ ๊ธฐ๋ฅ์ ๋ด๋นํ๊ณ ,
JDBC DRIVER API ๋ JDBC Manager ์ JDBC DRIVER ๊ฐ์ ์ฐ๊ฒฐ์ ์ง์ํ๋ค.
JDBC Driver Manager ๋ JDBC API ๊ฐ ์ฌ์ฉํ๋ ๊ฐ์ฒด์ด๋ค.
๊ฐ DB์ ์์ธ์ค ์ฌ๋ฐ๋ฅธ JDBC Driver ๊ฐ ์ฌ์ฉ๋์๋์ง ํ์ธํ๋ ์ญํ ์ ํ๋ค.
JDBC DRIVER ๋ DB ๊ณต์ ํํ์ด์ง์์ ์ ๊ณตํ๋ jar ํ์ผ์ด๋ค.
์ด ํ์ผ์ ํตํด DB ์์ ์ฐ๊ฒฐ์ด ๊ฐ๋ฅํ๋ค.
๐ค JDBC ๊ตฌ์ฑ ๊ฐ์ฒด
JDBC Driver Manager ์ฒ๋ผ JDBC ๋ผ์ด๋ธ๋ฌ๋ฆฌ์
๊ฐ์ข
Class ๋ Interface ๊ฐ ์กด์ฌํ๋ค.
๋ํ์ ์ธ ๋ช๊ฐ์ง ๊ฐ์ฒด์ ๋ํด ์์๋ณด์.
์๋์์ ์ค๋ช
ํ ๊ฐ์ฒด๋ Java Application ๊ตฌํ ์,
JDBC ๋ฅผ ์ ์ฉํ ๋ ์ง์ ์ฝ๋์ ์จ๋ณด๊ฒ ๋ ํ
๋, ์ ์์๋๋ฉด ์ข๋ค.
๐ค DriverManager
๋ฐ์ดํฐ ๋ฒ ์ด์ค ๋๋ผ์ด๋ฒ(jar ํ์ผ)๋ฅผ ๊ด๋ฆฌํ๋ ํด๋์ค์ด๋ค.
Java ์ดํ๋ฆฌ์ผ์ด์
์ผ๋ก๋ถํฐ ์จ DB ์ฐ๊ฒฐ ์์ฒญ์ ์ ์ ํ ๋ฐ์ดํฐ๋ฒ ์ด์ค์ ์ฐ๊ฒฐ์ํจ๋ค.
๐ค Driver
๋ฐ์ดํฐ๋ฒ ์ด์ค ์๋ฒ์์ ํต์ ์ ์ฒ๋ฆฌํ๋ค.
์ด ๊ฐ์ฒด๋ฅผ ์ง์ ๋ค๋ฃจ๋ ๊ฒฝ์ฐ๋ ๋๋ฌผ๋ค.
๋์ DriverManager ๊ฐ์ฒด๋ฅผ ์ฌ์ฉํ๋ค.
๐ค Connection
๋ฐ์ดํฐ๋ฒ ์ด์ค์ ์ฐ๊ฒฐํ๊ธฐ ์ํ ๋ชจ๋ ๋ฉ์๋๋ฅผ ํฌํจํ๋ ์ธํฐํ์ด์ค์ด๋ค.
๋ฐ์ดํฐ๋ฒ ์ด์ค์์ ๋ชจ๋ ํต์ ์ Connection ๊ฐ์ฒด๋ฅผ ํตํด์๋ง ์ํ๋๋ค.
๐ค Statement
SQL ๋ฌธ์ DB๋ก ๋ณด๋ผ๋(์คํํ ๋) ์ฌ์ฉ๋๋ค.
๐ค ResultSet
Statement ๊ฐ์ฒด๋ฅผ ํตํด SQL ์ฟผ๋ฆฌ๋ฅผ ์คํํ ํ, ๊ทธ ๊ฒฐ๊ณผ๋ฅผ ๋ค๋ฃฐ ๋ ์ฌ์ฉ๋๋ค.
๐ค SQLException
DB์ ๊ด๋ จ๋ ๋ชจ๋ ์ค๋ฅ๋ฅผ ์ฒ๋ฆฌํ๋ค.
์ ๊ฐ์ฒด๋ค์ ์๋์ ๊ฐ์ด ์ฌ์ฉ๋ ์ ์๋ค.
DB ์ฐ๊ฒฐ Java ํ๋ก๊ทธ๋จ์ ๊ตฌํํด ๋ณธ ์ฌ๋์ด๋ผ๋ฉด ๋์ ์ต์ํ ์ง๋.
๐ค ์์
import java.sql.*;
public class FirstExample {
static final String DB_URL = "jdbc:mysql://localhost/TUTORIALSPOINT";
static final String USER = "guest";
static final String PASS = "guest123";
static final String QUERY = "SELECT id, first, last, age FROM Employees";
public static void main(String[] args) {
// Open a connection
try(Connection conn = DriverManager.getConnection(DB_URL, USER, PASS);
Statement stmt = conn.createStatement();
ResultSet rs = stmt.executeQuery(QUERY);) {
// Extract data from result set
while (rs.next()) {
// Retrieve by column name
System.out.print("ID: " + rs.getInt("id"));
System.out.print(", Age: " + rs.getInt("age"));
System.out.print(", First: " + rs.getString("first"));
System.out.println(", Last: " + rs.getString("last"));
}
} catch (SQLException e) {
e.printStackTrace();
}
}
}
๐ค JDBC ๋ฐ์ดํฐ ๋ฒ ์ด์ค ์ฐ๊ฒฐ ๋ฐฉ๋ฒ
JDBC๋ก ๋ฐ์ดํฐ ๋ฒ ์ด์ค๋ฅผ ์ฐ๊ฒฐํ๋ ค๋ฉด ํฌ๊ฒ 6๊ฐ์ง ๊ณผ์ ์ ๊ฑฐ์ณ์ผํ๋ค.
- DB ์ ํํ๊ธฐ (ex. MySQL, PostgreSQL ๋ฑ)
- ์ ํํ DB ๊ณต์ ํํ์ด์ง์์ JDBC ๋๋ผ์ด๋ฒ๋ฅผ ๋ค์ด๋ก๋
- Java ํ๋ก์ ํธ ์ฝ๋ ๋จ์์ JDBC ๋ผ์ด๋ธ๋ฌ๋ฆฌ๋ฅผ import
- ๋ค์ด๋ก๋ํ JDBC ๋๋ผ์ด๋ฒ๋ฅผ ์ฝ๋ ๋จ์์ ๋ฑ๋ก
- ์ฐ๊ฒฐํ DB๋ฅผ ๊ฐ๋ฆฌํค๋ URL์ ๋ฑ๋ก
- DriverManager ๊ฐ์ฒด์ getConnection() ๋ฉ์๋๋ก ํธ์ถ์ ์ฝ๋ฉํ์ฌ ์ค์ ๋ฐ์ดํฐ ๋ฒ ์ด์ค ์ฐ๊ฒฐ์ ์ค์
์ ๊ณผ์ ์ ์ฐจ๊ทผ์ฐจ๊ทผ ์ค๋ช ํด๋ณด๊ฒ ๋ค.
๐ค Import JDBC Package
1, 2๋ฒ ๊ณผ์ ์ ํฌ๊ฒ ๋ ์ค๋ช ํ ๋ถ๋ถ์ด ์์ผ๋ 3๋ฒ์ผ๋ก ๋์ด๊ฐ์.
JDBC ๋ผ์ด๋ธ๋ฌ๋ฆฌ๋ฅผ ํ๋ก์ ํธ์ ์ฃผ์
ํ๋ ๋ถ๋ถ์ด๋ค.import
๋ฌธ์ผ๋ก JDBC ๋ผ์ด๋ธ๋ฌ๋ฆฌ๋ฅผ ์๋์ ๊ฐ์ด JAVA ์์ค ์ฝ๋ ๋จ์์ ์์ฑํด์ฃผ๋ฉด ๋๋ค.
import java.sql.*; // ํ์ค JDBC
import java.math.*; // BigDecimal, BigInteger ์ง์
๐ค JDBC ๋๋ผ์ด๋ฒ ๋ฑ๋ก
DB ํํ์ด์ง์์ ๋ค์ด๋ก๋ ๋ฐ์ JDBC ๋๋ผ์ด๋ฒ๋ฅผ ํ๋ก์ ํธ์ ์ฃผ์
ํ๋ ๊ณผ์ ์ด๋ค.
ํ๋ก์ ํธ์์ ํ๋ฒ๋ง ์ํํ๋ฉด ๋๋ค.
๋ฐฉ๋ฒ์ Class.forName()
, DriverManager.registerDriver()
๋ฅผ ์ฐ๋ ๋ฐฉ๋ฒ ์ด ๋๊ฐ์ง์ด๋ค.
Class.forName()
๋์ ์ผ๋ก JDBC ๋๋ผ์ด๋ฒ ํด๋์ค ํ์ผ์ ๋ฉ๋ชจ๋ฆฌ์ ์๋ ๋ฑ๋ก ๋ฐ ๋ก๋ํ ์ ์๋ค.
์ด ๋ฐฉ๋ฒ์ ์ฌ์ฉํ๋ฉด ๋๋ผ์ด๋ฒ ๊ตฌ์ฑ๊ณผ ์ด๋์ด ํธํด ๋ณดํธ์ ์ผ๋ก ์ฌ์ฉ๋๋ ํธ์ด๋ค.
DriverManager.registerDriver()
Microsoft ์์ ์ ๊ณตํ๋ ๊ฒ๊ณผ ๊ฐ์ ๋น JDK ํธํ JVM์ ์ฌ์ฉํ๋ ๊ฒฝ์ฐ ์ฌ์ฉ๋๋ค.
๐ค DB URL ๋ฑ๋ก
JDBC ๋ก ์ด๋ค DB์ ์ ๊ทผํ ๊ฒ์ธ์ง ์ค์ ํ๋ ๋จ๊ณ์ด๋ค.
JDBC ๋๋ผ์ด๋ฒ๋ฅผ ๋ก๋ํ ํ DriverManager.getConnection()
๋ฉ์๋๋ฅผ ์ฌ์ฉํ์ฌ ์ค์ ํ ์ ์๋ค.DriverManager.getConnection()
๋ฉ์๋ ์ธ์๋ก ๊ฐ DB์ JDBC URL ์ ์
๋ ฅํด์ ๋ฑ๋กํ๋ฉด ๋๋ค.
์๋์ ๊ฐ์ด DB ๋ง๋ค JDBC ์ฉ DB URL ์ด ๋ค๋ฅด๋ค.
RDBMS | JDBC ๋๋ผ์ด๋ฒ | URL ํ์ |
---|---|---|
MySQL | com.mysql.jdbc.Driver | jdbc:mysql:// hostname/databaseName |
ORACLE | oracle.jdbc.driver.OracleDriver | jdbc:oracle:thin:@ hostname:port Number:databaseName |
DB2 | COM.ibm.db2.jdbc.net.DB2Driver | jdbc:db2: hostname:port Number/databaseName |
Sybase | com.sybase.jdbc.SybDriver | jdbc:sybase:Tds: hostname: port Number/databaseName |
์งํ๊ฒ ์น ํด์ง ๊ธ์จ ๋ถ๋ถ์ด ๊ณ ์ ๋ JDBC URL ๊ฐ์ด๊ณ , ๋๋จธ์ง ๋ถ๋ถ๋ง ๊ฐ DB ํ๊ฒฝ์ ๋ง๊ฒ ์์ฑํด์ฃผ๋ฉด ๋๋ค.
DriverManager.getConnection(String url);
๐ค User, Password ๋ฑ๋ก
DriverManager.getConnection()
๋ฉ์๋ ์ธ์๋ก JDBC URL ์ ๋ฃ์ด ์ด๋ค DB์ ์ฐ๊ฒฐํ ๊ฑด์ง ์ค์ ํด์ค ์ ์๋ค๊ณ ์์ ์ค๋ช
ํ๋๋ฐ,
์ฌ์ค ์ด ์ ๋ณด๋ง์ผ๋ก๋ DB์ ์ฐ๊ฒฐํ๊ธฐ ์ด๋ ต๋ค.
DB์ ์ ์ํ๊ธฐ์ํด์ ์ด DB์ ์ ๊ทผ ๊ฐ๋ฅํ ๊ถํ์ด ์์ด์ผํ๋ค.
์ฆ, User์ Password ์ ๋ณด๋ฅผ DriverManager.getConnection()
JDBC URL๊ณผ ํจ๊ป ์ธ์๋ก ๋๊ฒจ์ผํ๋ค.
์๋ ์์์ ๊ฐ์ด ์ฌ๋ฌ ๋ฐฉ๋ฒ์ผ๋ก DriverManager.getConnection()
์ JDBC URL ๊ณผ User, Password๋ฅผ ์ธ์๋ก ๋๊ธธ ์ ์๋ค.
๋ฌธ์์ด ํ๋๋ก ํต์งธ๋ก ๋๊ธฐ๊ธฐ
String URL = "jdbc:oracle:thin:username/password@amrood:1521:EMP";
Connection conn = DriverManager.getConnection(URL);
๊ฐ๊ฐ ์ธ์๋ก ๋๊ธฐ๊ธฐ
String URL = "jdbc:oracle:thin:@amrood:1521:EMP";
String USER = "username";
String PASS = "password"
Connection conn = DriverManager.getConnection(URL, USER, PASS);
Properties ๊ฐ์ฒด ์ฌ์ฉํ๊ธฐ
๐ก Properties
ํค, ๊ฐ์ผ๋ก ์ด๋ค์ง ๊ฐ์ฒด
import java.util.*;
String URL = "jdbc:oracle:thin:@amrood:1521:EMP";
Properties info = new Properties( );
info.put( "user", "username" );
info.put( "password", "password" );
Connection conn = DriverManager.getConnection(URL, info);
๐ค JDBC ๋ฐ์ดํฐ ๋ฒ ์ด์ค ์ฐ๊ฒฐ ๋ซ๊ธฐ
JDBC ํ๋ก๊ทธ๋จ์ด ๋๋๋ฉด DB ์ฐ๊ฒฐ์ ๋ช ์์ ์ผ๋ก
์ด๋ฅผ ๊น๋จน์ ๊ฒฝ์ฐ Java ์ ๊ฐ๋น์ง ์ฝ๋ ํฐ๊ฐ DB ์ฐ๊ฒฐ์ ๋ซ๊ณ ๋น์ด๋ค.
๊ทธ๋ ๋ค๊ณ ๊ฐ๋น์ง ์ฝ๋ ํฐ์ ์์กดํ๋ฉด ์ข๋ค๊ณ ํ ์ ์๋ ํ๋ก๊ทธ๋จ์ด๋ ๋ช ์์ ์ผ๋ก ๊ผญ ์ข ๋ฃ์์ผ์ฃผ์.
๊ฐ๋น์ง ์ฝ๋ ํฐ์ ๊ฐ๋ ์ ์ ๋ชจ๋ฅด๊ฒ ๋ค๋ฉด ์๋ ํฌ์คํ ์ ์ฐธ๊ณ .
DB ์ฐ๊ฒฐ์ ์๋์ ๊ฐ์ด ์์ฑํด ๋ซ์์ค ์ ์๋ค.
conn.close();
์ด๋ ๊ฒ ๋ช ์์ ์ผ๋ก ์ฐ๊ฒฐ์ ๋ซ์ผ๋ฉด DBMS ์์์ ์๋ ์ ์์ด DB ๊ด๋ฆฌํ๊ธฐ ์ฉ์ดํ๋ค.
๐ค Statement
๋ฐ์ดํฐ๋ฒ ์ด์ค๋ฅผ ์ฐ๊ฒฐํ๊ณ ๋๋ ๋ฐฉ๋ฒ์ ๋ฐฐ์ ์ผ๋,
์ฐ๊ฒฐ๋ ๋ฐ์ดํฐ๋ฒ ์ด์ค์ ์ฟผ๋ฆฌ๋ฅผ ๋ณด๋ด๊ณ ๊ฒฐ๊ณผ๋ฅผ ๋ฐ๋ ๊ณผ์ ์ ํ์ํ ๊ฐ์ฒด๋ค์ ์ดํด๋ณด์.
์์ JDBC ๊ตฌ์ฑ ๊ฐ์ฒด์์ ์ค๋ช ํ Statement ์ธํฐํ์ด์ค์ ๋ํด ์ข ๋ ์์ธํ ์์๋ณด์.
Statement ์ธํฐํ์ด์ค๋ SQL ๋ช
๋ น์ DB๋ก ๋ณด๋ด๊ณ ๊ฒฐ๊ณผ๋ฅผ ๋ฐ๋๋ฐ ํ์ํ ๋ฉ์๋๋ ํ๋กํผํฐ๋ค์ ์ ์ํ๊ณ ์๋ค.
๋ํ, Java ์ ์๋ก ๋ค๋ฅธ SQL ๋ฐ์ดํฐ ํ์
์ ์๋ ๋ฉ์๋๋ฅผ ์ ๊ณตํ๋ค.
Statement ๋ ํฌ๊ฒ ์ธ๊ฐ์ง๊ฐ ์กด์ฌํ๋ค.
์ธํฐํ์ด์ค | ์ฌ์ฉ์ฒ |
---|---|
Statement | ๋ฐํ์์ ์ ์ SQL ๋ฌธ์ ์ฌ์ฉํ ๋ ์ ์ฉํ๋ค. SQL ๋ช ๋ น์ ๋ณด๋ผ ๋ ํ๋ผ๋ฏธํฐ๋ฅผ ํจ๊ป ๋ณด๋ด๋ ๊ฑธ ํ์ฉํ์ง ์๋๋ค. |
PreparedStatement | SQL ๋ช ๋ น์ ์ฌ๋ฌ๋ฒ ๋ณด๋ผ ๋ ์ ์ฉํ๋ค. ๋ฐํ์ ๋ ํ๋ผ๋ฏธํฐ๋ฅผ ํจ๊ป ๋ณด๋ด๋ ๊ฑธ ํ์ฉํ๋ค. |
CallableStatement | DB ๋ด ํ๋ก์์ ์ ์ ๊ทผํ ๋ ์ ์ฉํ๋ค. ๋ฐํ์ ๋ ํ๋ผ๋ฏธํฐ๋ฅผ ํจ๊ป ๋ณด๋ด๋ ๊ฑธ ํ์ฉํ๋ค. |
๐ค Statement
Statement ๊ฐ์ฒด ์์ฑ ๋ฐ ์คํ
SQL ๋ฌธ์ ์คํํ๊ธฐ ์ํด Statment ๊ฐ์ฒด๋ฅผ ์ฌ์ฉํ๊ธฐ ์ ์,
๋จผ์ Connection ๊ฐ์ฒด์ createStatment()
๋ฉ์๋๋ก Statement ๊ฐ์ฒด๋ฅผ ์์ฑํด์ผํ๋ค.
Statement stmt = null;
try {
stmt = conn.createStatement( );
. . .
}
catch (SQLException e) {
. . .
}
finally {
. . .
}
Statement ๊ฐ์ฒด๋ฅผ ์์ฑํ๊ณ ๋๋ฉด, ์๋ ์ธ๊ฐ์ง ๋ฉ์๋๋ฅผ ํตํด SQL ๋ฌธ์ ํ ๋ฒ ์คํ ์ํฌ ์ ์๋ค.
- boolean execute(String SQL)
- ๊ฒฐ๊ณผ ๊ฐ์ ๋ฐ์ผ๋ฉด true๋ฅผ ๋ฐํํ๋ ๋ฉ์๋์ด๋ค. ๊ฒฐ๊ณผ๊ฐ ์๋ค๋ฉด false ๋ฅผ ๋ฐํํ๋ค. DDL(create, drop...)์ ์ธ ๋ ์ ์ฉํ๋ค.
- int executeUpdate(String SQL)
- ๊ฒฐ๊ณผ rows์ ๊ฐ์๋ฅผ ๋ฐํํ๋ ๋ฉ์๋์ด๋ค. insert, update, delete ๋ฌธ์ ์ ์ฉํ๋ค.
- ResultSet executeQuery(String SQL)
- ResultSet ๊ฐ์ฒด๋ฅผ ๋ฐํํ๋ ๋ฉ์๋์ด๋ค. select ๋ฌธ์ ์ ์ฉํ๋ค.
Statement ๊ฐ์ฒด ๋ซ๊ธฐ
Connection ๊ฐ์ฒด๋ฅผ ๋ซ๋ฏ์ด, DB ์์์ ๋ญ๋นํ์ง ์๊ธฐ ์ํด์ Statement ๊ฐ์ฒด๋ ๋ซ์์ค์ผํ๋ค.
Statement ๊ฐ์ฒด๋ ํ SQL ๋ฌธ ๋น ํ๋๋ผ๊ณ ์๊ฐํ๋ฉด ๋๋ค.
Statement ๊ฐ์ฒด๋ฅผ ์ฌ๋ฌ๋ฒ ์ฌ์ฉํ๋ คํ์ง ๋ง๊ณ , ํ SQL ๋ฌธ์ ์คํ์์ผฐ๋ค๋ฉด ๋ฐ๋ก ๋ซ์์ฃผ์.
๋จ์ํ close()
๋ฉ์๋๋ง ํธ์ถํด์ฃผ๋ฉด ๋๋ค.
Statement stmt = null;
try {
stmt = conn.createStatement( );
. . .
}
catch (SQLException e) {
. . .
}
finally {
stmt.close();
}
๐ค PreparedStatment
PreparedStatment ๊ฐ์ฒด ์์ฑ ๋ฐ ์คํ
// PreparedStatement ์์ฑ
String sql = "SELECT * FROM your_table WHERE column1 = ? AND column2 = ?";
PreparedStatement preparedStatement = connection.prepareStatement(sql);
// ๋ ๊ฐ์ ๋งค๊ฐ๋ณ์ ์ค์
String parameterValue1 = "value1";
String parameterValue2 = "value2";
preparedStatement.setString(1, parameterValue1);
preparedStatement.setString(2, parameterValue2);
// ์ฟผ๋ฆฌ ์คํ
ResultSet resultSet = preparedStatement.executeQuery();
PreparedStatement ๋ SQL ์ ํ๋ผ๋ฏธํฐ๋ฅผ ํจ๊ป ๋ณด๋ด ์คํ์ํฌ ์ ์๋ค.
JDBC ์ ๋ชจ๋ ํ๋ผ๋ฏธํฐ๋ ํ๋ผ๋ฏธํฐ ๋ง์ปค์ธ ๋ฌผ์ํ๋ก ํํ๋๋ค.
๋ฌผ์ํ(ํ๋ผ๋ฏธํฐ)์ ๊ฐ์ ์คํ ์ ์ ๋ฐ๋์ ์ ๋ฌ๋์ด์ผํ๋ค.
๊ทธ๋ ์ ์๋ค๋ฉด SQLException ์ด ๋ฐ์ํ๋ค.
๋ฌผ์ํ์ ๊ฐ์ ์ฃผ๊ธฐ ์ํด์ setXXX()
๋ฉ์๋๋ฅผ ์ฐ๋ฉด ๋๋ค.
์ฌ๊ธฐ์ XXX๋ ๋งค๊ฐ ๋ณ์์ ๋ฐ์ธ๋ฉํ ๊ฐ์ Java ๋ฐ์ดํฐ ์ ํ์ ๋ํ๋ธ๋ค.
๊ทธ ์๋ก๋, setString()
์ด ์๋ค.
๊ฐ ํ๋ผ๋ฏธํฐ ๋ง์ปค(๋ฌผ์ํ)๋ ์์์ ๋ฐ๋ผ ์ฐธ์กฐ๋๋ค.
์ฒซ๋ฒ์งธ ๋ง์ปค(๋ฌผ์ํ)์ ์์น๋ 1, ๋๋ฒ์งธ ๋ง์ปค(๋ฌผ์ํ)์ ์์น๋ 2.
Statement ๊ฐ์ฒด์์ ์ฌ์ฉ๋ ๋ชจ๋ ๋ฉ์๋๋ฅผ PreparedStatment ์์๋ ์ฌ์ฉํ ์ ์๋ค.
PreparedStatment ๊ฐ์ฒด ๋ซ๊ธฐ
Statement ๊ฐ์ฒด๋ฅผ ๋ซ๋ ๊ฒ๊ณผ ๊ฐ์ ์ด์ ๋ก PreparedStatement ๊ฐ์ฒด๋ ๋ซ์์ค์ผํ๋ค.
์ญ์, ๊ฐ๋จํ close()
๋ฉ์๋๋ง ํธ์ถํด์ฃผ๋ฉด ๋๋ค.
PreparedStatement pstmt = null;
try {
String SQL = "Update Employees SET age = ? WHERE id = ?";
pstmt = conn.prepareStatement(SQL);
. . .
}
catch (SQLException e) {
. . .
}
finally {
pstmt.close();
}
์ฐธ๊ณ ๋ก Statement ๊ฐ์ฒด์ ๋ค๋ฅด๊ฒ PreparedStatment ๊ฐ์ฒด๋ ์ฌ๋ฌ ์ฟผ๋ฆฌ๋ฅผ ์คํ ์์ผ์ค ์ ์๊ธฐ ๋๋ฌธ์, ๋จ์ํ ์ข ๋ฃ ์ํค๋ ๊ฒ ์๋๋ผ ๋ชจ๋ ์ฟผ๋ฆฌ ์ํ์ด ์๋ฃ๋๊ณ ๋ ๋ค์์ผ ๋ซ์์ค์ผํ๋ค.
๋ณดํต close
๋ finally
์ ์ ์ํด์ฃผ๋ฉด ๋๋ค.
// Execute the statement
try (PreparedStatement pstmt = connection.prepareStatement("SELECT 1 FROM DUAL")) {
// Fetch a first ResultSet
try (ResultSet rs1 = pstmt.executeQuery()) { ... }
// Without closing the statement, execute it again to fetch another ResultSet
try (ResultSet rs2 = pstmt.executeQuery()) { ... }
} finally {
pstmt.close();
}
๐ค CallableStatment
CallableStatment ๊ฐ์ฒด๋ ๋ฐ์ดํฐ๋ฒ ์ด์ค์ ์ ์ฅ๋ ํ๋ก์์ ๋ฅผ ๋ถ๋ฌ์ค๊ณ ์คํ์ํฌ ์ ์๊ฒํ๋ค.
ํ๋ก์์ ์์ฑํ๊ธฐ
CallableStatment ๋ PreparedStatment ์ฒ๋ผ ํ๋ผ๋ฏธํฐ๋ฅผ ๋๊ธธ ์ ์๋ค.
ํ๋ก์์ ์ ํ๋ผ๋ฏธํฐ ๋ํ ์ดํดํด์ผํ๊ธฐ ๋๋ฌธ์ ๋จผ์ ํ๋ก์์ ์์ฑ๋ฌธ ๋ถํฐ ์ดํด๋ณด์.
CREATE OR REPLACE PROCEDURE getEmpName
(EMP_ID IN NUMBER, EMP_FIRST OUT VARCHAR) AS
BEGIN
SELECT first INTO EMP_FIRST
FROM Employees
WHERE ID = EMP_ID;
END;
์ ๋ช
๋ น์ ์ค๋ผํด์์ ์์ฑ๋์๊ณ getEmpName
์ด๋ผ๋ ํ๋ก์์ ๋ฅผ ์์ฑํ๊ณ ์๋ค.
์ ํ๋ก์์ ์์ EMP_ID
์ EMP_FIRST
๋ผ๋ ํ๋ผ๋ฏธํฐ๋ฅผ ๋ฐ์ ์ ์๊ฒ ๋์ด ์๋ ๊ฑธ ๋ณผ ์ ์๋ค.
๊ทธ๋ฐ๋ฐ ํ๋ผ๋ฏธํฐ ๋ช
๋ค์ IN
, OUT
์ ๋ฌด์จ ๋ป์ผ๊น?
PreparedStatement๊ฐ IN(๋ฐ๋) ํ๋ผ๋ฏธํฐ๋ง ์ฌ์ฉ๋๋ ๋ฐ๋ฉด,
CallableStatement๋ ํฌ๊ฒ ์ธ๊ฐ์ง ํ๋ผ๋ฏธํฐ๋ฅผ ์ฌ์ฉํ ์ ์๋ค.
ํ๋ผ๋ฏธํฐ | ์ค๋ช |
---|---|
IN | SQL statment๊ฐ ์์ฑ๋ ๋ ๊ฐ์ ์ ์ ์๊ณ , setXXX() ๋ฐ์๋ก ๊ฐ์ ๋ฐ์ธ๋ฉํด์ค์ผ ์ ์ ์๋ ํ๋ผ๋ฏธํฐ |
OUT | SQL statment๊ฐ ๋ฐํ๋ ๋ ์ ๊ณต๋๋ ๊ฐ. getXXX() ๋ฉ์๋๋ก ํด๋น ํ๋ผ๋ฏธํฐ ๊ฐ์ ์ป์ ์ ์๋ค. |
INOUT | input๊ณผ output์ ๋ชจ๋ ์ ๊ณตํ๋ ํ๋ผ๋ฏธํฐ. setXXX()๋ก ๊ฐ์ ๋ฐ์ธ๋ฉํ๊ณ getXXX() ๋ฉ์๋๋ก ๊ฐ์ ๋ฐํ๋ฐ์ ์ ์๋ค. |
CallableStatment ๊ฐ์ฒด ์์ฑ ๋ฐ ์คํ
try {
// ์ ์ฅ ํ๋ก์์ ํธ์ถ์ ์ํ CallableStatement ์์ฑ
CallableStatement cstmt = null;
String SQL = "{call getEmpName (?, ?)}";
cstmt = conn.prepareCall(SQL);
// ์
๋ ฅ ๋งค๊ฐ๋ณ์ ์ค์ (์ฒซ ๋ฒ์งธ ๋งค๊ฐ๋ณ์)
int inputParameter = 123;
callableStatement.setInt(1, inputParameter);
// ์ถ๋ ฅ ๋งค๊ฐ๋ณ์ ๋ฑ๋ก (๋ ๋ฒ์งธ ๋งค๊ฐ๋ณ์)
callableStatement.registerOutParameter(2, Types.VARCHAR);
// ์ ์ฅ ํ๋ก์์ ์คํ
callableStatement.execute();
// ์ถ๋ ฅ ๋งค๊ฐ๋ณ์์ ๊ฐ์ ๊ฐ์ ธ์ค๊ธฐ
int outputParameter = callableStatement.getInt(2);
}
catch (SQLException e) {
. . .
}
finally {
. . .
}
๋ฐ์ดํฐ๋ฒ ์ด์ค์ ์์ ์์ฑํ getEmpName
์ด๋ผ๋ ํ๋ก์์ ๊ฐ ์กด์ฌํ ๋,
์ด ํ๋ก์์ ๋ฅผ ์คํ์ํค ์ํด์ ์์๊ฐ์ด ์ ๋ ฅํด์ค ์ ์๋ค.
CallableStatement ๊ฐ์ฒด๋ฅผ ์์ฑํ๊ณ , ํ๋ก์์ ๋ฅผ call ํ๋ ๋ช ๋ น์ด๋ฅผ
prepareCall
๋ฉ์๋์ ๋ด์๋ณด๋ด๋ฉด ๋๋ค.
PreparedStatment ์ฒ๋ผ ๋ฌผ์ํ ๋ง์ปค๋ฅผ ์ฌ์ฉํด ํ๋ผ๋ฏธํฐ๋ฅผ set ํด์ค ์ ์๋ค.
CallableStatment ๋ง์ ์๋ก์ด ์์์ธ ์ถ๋ ฅ ํ๋ผ๋ฏธํฐ๋ฅผ ์ฌ์ฉํ๊ธฐ ์ํด์ ,
registerOutParameter
๋ฉ์๋๋ฅผ ์ฌ์ฉํด์ผํ๋ค.
์ถ๋ ฅ ํ๋ผ๋ฏธํฐ ์์น(์์)์ ํ์ ์ ๋ฐ์ธ๋ฉํ๋ ์ฉ๋์ด๋ค.
๋ชจ๋ ํ๋ผ๋ฏธํฐ๋ฅผ ๋ฐ์ธ๋ฉ ํด์ค ๋ค execute
๋ฉ์๋๋ก ์คํ์ํฌ ์ ์๊ณ ,
์ถ๋ ฅ ํ๋ผ๋ฏธํฐ๋ ์คํ ์ดํ์ getXXX()๋ก ๊ฐ์ ๋ฐํ๋ฐ์ ์ ์๋ค.
์ฌ๊ธฐ์ XXX์๋ ํ์ ์ ์ ๋ ฅํด์ฃผ๋ฉด ๋๋ค.
CallableStatment ๊ฐ์ฒด ๋ซ๊ธฐ
๋ค๋ฅธ Statment ๊ฐ์ฒด์ ๊ฐ์ ์ด์ ๋ก CallableStatement ๊ฐ์ฒด๋
์ฌ์ฉ ๋ค์ ๊ผญ ๋ซ์์ค์ผํ๋ค.
CallableStatement cstmt = null;
try {
String SQL = "{call getEmpName (?, ?)}";
cstmt = conn.prepareCall (SQL);
. . .
}
catch (SQLException e) {
. . .
}
finally {
cstmt.close();
}
๐ค ResultSet
Statment ๊ฐ์ฒด์ execute ๋ฉ์๋ ๋ฑ์ ์ด์ฉํด SQL ๋ฌธ์ ์คํ์ํค๋ ๋ฐฉ๋ฒ์ ์์๋ค.
์ด์ ์ด SQL์ ์คํ ๊ฒฐ๊ณผ๋ฅผ ์กฐํํ๋ ๋ฐฉ๋ฒ์ ์์๋ณด์.
exeute
๋ฉ์๋ ๋ฑ์ผ๋ก ์กฐํํ ์ฟผ๋ฆฌ ๊ฒฐ๊ณผ๋ ResultSet ์ด๋ผ๋ ์ธํฐํ์ด์ค์ ๋ด๊ฒจ ์จ๋ค.
ResultSet์ ์ปค์๋ก ์ฟผ๋ฆฌ ๊ฒฐ๊ณผ์ ํ ํ์ ๊ฐ๋ฆฌํค๊ณ ์๋ค.
๋๋ฌธ์ ์ถํ์ ์ค๋ช
ํ next()
๋ฐ์์ ๋ฉ์๋๋ก ์ปค์๋ฅผ ์ด๋์ํค๋ฉฐ ๊ฒฐ๊ณผ๊ฐ์ ๊ฐ์ ธ์ฌ ์ ์๋ค.
ResultSet ์ธํฐํ์ด์ค๊ฐ ํ๋ ์ผ์ ํฌ๊ฒ ์ธ๊ฐ์ง๋ก ๋๋ ์ ์๋ค.
- ์ปค์ ์ด๋
- ์ปค์๊ฐ ๊ฐ๋ฆฌํค๊ณ ์๋ ๋ฐ์ดํฐ ๊ฐ์ ธ์ค๊ธฐ
- ์ปค์๊ฐ ๊ฐ๋ฆฌํค๊ณ ์๋ ๋ฐ์ดํฐ ์ ๋ฐ์ดํธ ํ๊ธฐ. ์๋ณธ ๋ฐ์ดํฐ์ ์ ๋ฐ์ดํธ ๊ฐ๋ฅ
์์ ์ค๋ช ํ Statement ๋ฅผ ํตํด ์ฟผ๋ฆฌ๋ฅผ ์คํ์ํค๊ณ , ResultSet์ ์ป์ ์ ์๋๋ฐ,
์ด Statement๋ฅผ ์์ฑํ ๋, ResultSet์ ๋ํ ์ต์ ์ ์ค ์ ์๋ค.
createStatement(int RSType, int RSConcurrency);
prepareStatment(string SQL, int RSType, int RSConcurrency);
prepareCall(String sql, int RSType, int RSConcurrency);
๐ค ResultSetType
์์ ์ฝ๋์์ ํธ์๋ฅผ ์ํด ResultSetType์ ์ค์๋ง๋ก RSType ์ด๋ผ๊ณ ๋ช
์นญํ๋ค.
ResultSetType.
๋ง ๊ทธ๋๋ก ResultSet์ ์ ํ์ ์๋ฏธํ๋ค.
ResultSetType ์ผ๋ก๋ ์๋์ ๊ฐ์ ์ธ๊ฐ์ง ํ์ ์ ์ค ์ ์๋ค.
Type | Description |
---|---|
ResultSet.TYPE_FORWARD_ONLY | ResultSetType ์ ์ฃผ์ง ์๊ณ Statement๋ฅผ ์์ฑํ์ ๋ ์ค์ ๋๋ default ResultSetType์ด๋ค. ์ปค์๋ฅผ ์์ผ๋ก๋ง ์์ง์ผ ์ ์๋ค. |
ResultSet.TYPE_SCROLL_INSENSITIVE | ์ปค์๋ฅผ ์ ๋ค๋ก ์คํฌ๋กค ํ ์ ์์ผ๋ฉฐ, ResultSet์ ResultSet์ด ์์ฑ๋ ํ ๋ฐ์ํ๋ ๋ฐ์ดํฐ๋ฒ ์ด์ค์ ๋ํ ๋ณ๊ฒฝ ์ฌํญ์ด ResultSet์ ์ํฅ์ ๋ฏธ์น์ง ์๋๋ค. |
ResultSet.TYPE_SCROLL_SENSITIVE. | ์ปค์๋ฅผ ์๋ค๋ก ์คํฌ๋กคํ ์ ์์ผ๋ฉฐ, ResultSet์ REsultSet์ด ์์ฑ๋ ํ ๋ฐ์ดํฐ๋ฒ ์ด์ค์ ๋ณ๊ฒฝ ์ฌํญ์ด ์๊ธฐ๋ฉด ResultSet๋ ๋ณ๊ฒฝ๋๋ค. |
๐ค Concurrency of ResultSet
์์ ์ฝ๋์์ ํธ์๋ฅผ ์ํด ResultSet Concurrency์ ์ค์๋ง๋ก RSConcurrency ์ด๋ผ๊ณ ๋ช ์นญํ๋ค.
Concurrency.
๋ฒ์ญํ๋ฉด '๋์์ฑ'์ด๋ ๋ป์ด๋ค.
ResultSet์ ํตํ DB ์
๋ฐ์ดํธ ์ฌ๋ถ๋ฅผ ๊ฒฐ์ ํ ์ ์๋ ์ต์
์ด๋ค.
Concurrency ์ ๊ฐ์ผ๋ก๋ ์๋ ๋๊ฐ์ง๋ฅผ ์ค ์ ์๋ค.
Concurrency | Description |
---|---|
ResultSet.CONCUR_READ_ONLY | ์ฝ๊ธฐ ์ ์ฉ ResultSet์ ๋ง๋ ๋ค. Statment ๋ฅผ ์์ฑํ ๋ Concurrency๋ฅผ ์ฃผ์ง ์์ผ๋ฉด ์๋์ผ๋ก ์ค์ ๋๋ default ๊ฐ์ด๋ค. |
ResultSet.CONCUR_UPDATABLE | ์ ๋ฐ์ดํธ ๊ฐ๋ฅํ ResultSet์ ๋ง๋ ๋ค. |
๐ค ResultSet ์ปค์ ์ด๋
ResultSet์ ์ฟผ๋ฆฌ ์กฐํ ๊ฒฐ๊ณผ์ ํ row๋ฅผ ์ปค์๋ก ๊ฐ๋ฆฌํค๊ณ ์๋ค.
ํด๋น ์ปค์๋ฅผ ์ด๋ํ๊ธฐ ์ํด์ ์๋์ ๊ฐ์ ๋ฉ์๋๋ฅผ ์ฌ์ฉํด ์ค ์ ์๋ค.
- public void beforeFirst() throws SQLExceiption
- ์ฒซ๋ฒ์งธ ํ ๋ฐ๋ก ์์ ์์ปค๋ฅผ ์ด๋์ํจ๋ค.
- public void afterLast() throws SQLException
- ๋ง์ง๋ง ํ ๋ฐ๋ก ๋ค์ ์ปค์๋ฅผ ์ด๋์ํจ๋ค.
- public boolean first() throws SQLException
- ์ปค์๋ฅผ ์ฒซ๋ฒ์งธ ํ์ผ๋ก ์ด๋์ํจ๋ค.
- public void last() throws SQLException
- ์ปค์๋ฅผ ๋ง์ง๋ง ํ์ผ๋ก ์ด๋์ํจ๋ค.
- public boolean absolute(int row) throws SQLException
- ์ปค์๋ฅผ ์ง์ ๋ ํ์ผ๋ก ์ด๋์ํจ๋ค.
- public boolean relative(int row) throws SQLException
- ํ์ฌ ๊ฐ๋ฆฌํค๋ ๊ณณ์์ ์ฃผ์ด์ง ํ ์์ ์ปค์๋ฅผ ์ ๋ค๋ก ์ปค์๋ฅผ ์ด๋์ํจ๋ค.
- public boolean previous() throws SQLException
- ์ปค์๋ฅผ ์ด์ ํ์ผ๋ก ์ด๋์ํจ๋ค. ์ด ๋ฉ์๋๋ ์ด์ ํ์ด ResultSet์์ ๋ฒ์ด๋๋ฉด false ๋ฅผ ๋ฐํํ๋ค.
- public boolean next() throws SQLException
- ์ปค์๋ฅผ ๋ค์ ํ์ผ๋ก ์ด๋์ํจ๋ค. ์ด ๋ฉ์๋๋ ๋ค์ ํ์ด ResultSet์์ ๋ฒ์ด๋๋ฉด false ๋ฅผ ๋ฐํํ๋ค.
- public int getRow() throws SQLException
- ์ปค์๊ฐ ๊ฐ๋ฆฌํค๋ ํ ๋ฒํธ๋ฅผ ๋ฐํํ๋ค.
- public void moveToInsertRow() throws SQLException
- ์ปค์๋ฅผ ๋ฐ์ดํฐ๋ฒ ์ด์ค์ ์ ํ์ ์ฝ์ ํ๋ ๋ฐ ์ฌ์ฉํ ์ ์๋ ResultSet์ ํน์ ํ์ผ๋ก ์ด๋์ํจ๋ค. ํ์ฌ ์ปค์ ์์น๊ฐ ๊ธฐ์ต๋๋ค.
- public void moveToCurrentRow() throws SQLException
- ์ปค์๊ฐ ํ์ฌ ์ฝ์ ํ์ ์๋ ๊ฒฝ์ฐ ์ปค์๋ฅผ ๋ค์ ํ์ฌ ํ์ผ๋ก ์ด๋์ํจ๋ค.
๐ค ResultSet ๋ฐ์ดํฐ ์กฐํ
์ปค์๊ฐ ๊ฐ๋ฆฌํค๊ณ ์๋ ํ์ฌ ํ์ ๋ํ ๋ฐ์ดํฐ๋ฅผ ์กฐํํ๊ธฐ ์ํด์ getXXX
ํํ์ ๋ฉ์๋๋ฅผ ์ฌ์ฉํด์ฃผ๋ฉด๋๋ค.XXX
๋ ๊ฐ ๋ฐ์ดํฐ์ ํ์
์ ์๋ฏธํ๋ค.
๋ฉ์๋์ ํจ๊ป ์ปฌ๋ผ์ ์ด๋ฆ ๋๋ ์ธ๋ฑ์ค๋ฅผ ์ธ์๋ก ๋๊ฒจ์ฃผ๋ฉด
ํ์ฌ ์ปค์๊ฐ ๊ฐ๋ฆฌํค๊ณ ์๋ ํ์ ํน์ ๋ฐ์ดํฐ๋ฅผ ์กฐํํ ์ ์๋ค.
์ปฌ๋ผ ์ธ๋ฑ์ค๋ 1๋ถํฐ ์์ํ๋ค.
Name | Age | Salary |
---|---|---|
Alice | 28 | 50000 |
Bob | 35 | 60000 |
Carol | 24 | 45000 |
์๋ฅผ ๋ค์ด,
ResultSet์ ๊ฒฐ๊ณผ๊ฐ ์์ ๊ฐ๊ณ ํ์ฌ ์ปค์๊ฐ ์ฒซ๋ฒ์งธ row ๋ฅผ ๊ฐ๋ฆฌํค๊ณ ์์ ๋,resultSet.getInt(2)
๋ฅผ ํ๋ฉด 28์ ๋ฐํํ๋ค.resultSet.getInt('Salary')
์ ํ๋ฉด 50000๋ฅผ ๋ฐํํ๋ค.
๐ค ResultSet ์ ๋ฐ์ดํธ
์กฐํ์ ๊ฑฐ์ ์ ์ฌํ ๋ฐฉ๋ฒ์ผ๋ก ResultSet์ ์
๋ฐ์ดํธ ํ ์ ์๋ค.updateXXX
๋ก ResultSet์ ๋ฐ์ดํฐ๋ฅผ ์
๋ฐ์ดํธํ ์ ์์ผ๋ฉฐ,XXX
๋ ํ์
์ด๋ค.
updateXXX
๋ฉ์๋์ ์ปฌ๋ผ ์ด๋ฆ ๋๋ ์ธ๋ฑ์ค์ ํจ๊ป ์
๋ฐ์ดํธํ ๋ฐ์ดํฐ๋ฅผ ๋๊ธฐ๋ฉด
ResultSet์ ์
๋ฐ์ดํธํ ์ ์๋ค.
ex) resultSet.updateString(1, 'test');
๋จ, updateXXX
๋ ์ผ์์ ์ผ๋ก ์ ์ฉ๋๋ ๊ฒ์ด๊ธฐ ๋๋ฌธ์,
๋ณ๊ฒฝ ์ฌํญ์ ์ ์ฉํด์ฃผ๊ธฐ ์ํด์๋ ์ ์ฅ ๊ฐ๋
์ผ๋ก updateRow()
๋ฅผ ํธ์ถํด์ค์ผํ๋ค.
resultSet.updateInt("Age", 29); // 'Age' ์ด์ ๊ฐ์ 29๋ก ์
๋ฐ์ดํธ
resultSet.updateRow(); // ๋ณ๊ฒฝ ์ฌํญ์ ๋ฐ์ดํฐ๋ฒ ์ด์ค์ ๋ฐ์
์ด ์ธ์๋ ResultSet์ ๋ณ๊ฒฝํด์ฃผ๊ธฐ ์ํด์ ์๋์ ๊ฐ์ ๋ฉ์๋๋ฅผ ํ์ฉํ ์ ์๋ค.
- public void deleteRow()
- ํ์ฌ ๊ฐ๋ฆฌํค๊ณ ์๋ row๋ฅผ DB๋ก๋ถํฐ ์ญ์ ์ํจ๋ค.
- public void refreshRow()
- DB ์ ๋ณ๊ฒฝ ์ฌํญ์ ๋ฐ์ํ๋ฉฐ ํ์ฌ ๊ฐ๋ฆฌํค๊ณ ์๋ row๋ฅผ ์๋ก๊ณ ์นจํ๋ค.
- public void cancelRowUpdates()
- ํ์ฌ ๊ฐ๋ฆฌํค๊ณ ์๋ row ์ ๋ํ ์ ๋ฐ์ดํธ๋ฅผ ์ทจ์ํ๋ค.
- public void insertRow()
- ์ปค์๊ฐ insert row๋ฅผ ๊ฐ๋ฆฌํค๊ณ ์์ ๋ DB์ row๋ฅผ ์ถ๊ฐํ ์ ์๋ค.
์ด๋ฒ ํฌ์คํ ์์ JDBC์ ๋ํด ์์๋ณด์๋ค.
๋๊ธ, ํํธ, ํผ๋๋ฐฑ์ ์ธ์ ๋ ํ์์ ๋๋ค ๐
'JAVA' ์นดํ ๊ณ ๋ฆฌ์ ๋ค๋ฅธ ๊ธ
[JAVA] ์ธํฐํ์ด์ค๋? (๋คํ์ฑ, ์ถ์ํด๋์ค, implements) (0) | 2022.02.15 |
---|