H2 데이터베이스-퀵 가이드
H2는 오픈 소스 경량 Java 데이터베이스입니다. Java 애플리케이션에 임베드되거나 클라이언트-서버 모드에서 실행될 수 있습니다. 주로 H2 데이터베이스는 메모리 내 데이터베이스로 실행되도록 구성 할 수 있으며 이는 데이터가 디스크에 유지되지 않음을 의미합니다. 임베디드 데이터베이스로 인해 프로덕션 개발에는 사용되지 않지만 대부분 개발 및 테스트에 사용됩니다.
이 데이터베이스는 임베디드 모드 또는 서버 모드에서 사용할 수 있습니다. 다음은 H2 데이터베이스의 주요 기능입니다-
- 매우 빠른 오픈 소스 JDBC API
- 임베디드 및 서버 모드에서 사용할 수 있습니다. 인 메모리 데이터베이스
- 브라우저 기반 콘솔 애플리케이션
- 작은 풋 프린트-약 1.5MB jar 파일 크기
H2 데이터베이스의 특징
H2 데이터베이스의 주요 기능은 다음과 같습니다-
매우 빠른 데이터베이스 엔진입니다.
H2는 오픈 소스이며 Java로 작성되었습니다.
표준 SQL 및 JDBC API를 지원합니다. PostgreSQL ODBC 드라이버도 사용할 수 있습니다.
임베디드 및 서버 모드가 있습니다.
H2 지원 clustering 과 multi-version concurrency.
강력한 보안 기능이 있습니다.
추가 기능
다음은 H2 데이터베이스의 몇 가지 추가 기능입니다-
H2는 디스크 기반 또는 메모리 내 데이터베이스 및 테이블, 읽기 전용 데이터베이스 지원, 임시 테이블입니다.
H2는 트랜잭션 지원 (읽기 커밋), 2 단계 커밋 다중 연결, 테이블 수준 잠금을 제공합니다.
H2는 복잡한 쿼리를위한 유전 알고리즘을 사용하는 비용 기반 최적화 프로그램입니다.
H2에는 스크롤 및 업데이트 가능한 결과 집합 지원, 큰 결과 집합, 외부 결과 정렬이 포함되어 있으며 함수는 결과 집합을 반환 할 수 있습니다.
H2는 암호화 된 데이터베이스 (AES), SHA-256 암호 암호화, 암호화 기능 및 SSL을 지원합니다.
H2 데이터베이스의 구성 요소
H2 Database를 사용하려면 다음 구성 요소가 필요합니다.
- 웹 브라우저
- H2 콘솔 서버
이것은 클라이언트 / 서버 응용 프로그램이므로 실행하려면 서버와 클라이언트 (브라우저)가 모두 필요합니다.
H2는 Java로 작성된 데이터베이스입니다. JDBC를 사용하여이 데이터베이스를 애플리케이션에 쉽게 임베드 할 수 있습니다. 다양한 플랫폼 또는 Java Runtime Environment의 모든 버전에서 실행할 수 있습니다. 그러나 데이터베이스를 설치하기 전에 시스템에 Java가 설치되어 있어야합니다.
Java 설치 확인
JDK가 시스템에 설치된 경우 다음 명령을 사용하여 Java 버전을 확인하십시오.
java –versionJDk가 시스템에 성공적으로 설치되면 다음 출력이 표시됩니다.
java version "1.8.0_91"
Java(TM) SE Runtime Environment (build 1.8.0_91-b14)
Java HotSpot(TM) 64-Bit Server VM (build 25.91-b14, mixed mode)시스템에 JDK가 설치되어 있지 않은 경우 다음 링크를 방문하여 JDK 를 설치하십시오 .
H2 데이터베이스 설치
이 데이터베이스를 다양한 플랫폼에서 실행할 수 있습니다. 이 장에서는 Windows에 H2 데이터베이스 설치에 대해 알아 봅니다.
다음은 Windows 운영 체제에 H2 데이터베이스를 설치하는 단계입니다.
1 단계 : H2 설정 파일 다운로드
주어진 링크에서 최신 버전의 H2 데이터베이스 를 다운로드하십시오 . 이 링크에서는 두 가지 유형의 최신 버전의 H2 데이터베이스를 얻을 수 있습니다. 하나는 Windows Installer 유형 (즉 .exe 파일)이고 두 번째는 다른 운영 체제 용 플랫폼 독립적 zip 파일입니다.
.exe 파일을 다운로드 한 후 Windows 지원 가능 H2 데이터베이스를 다운로드하려면 Windows 설치 프로그램을 클릭합니다. 이 경우 1.4.192 버전의 H2 데이터베이스를 사용하고 있습니다.
2 단계 : H2 데이터베이스 설치
다운로드 후 다운로드 디렉토리에 H2 Windows 설치 프로그램 파일 (예 : h2-setup-yyyy-mm-dd.exe)을 가져옵니다. H2 데이터베이스의 설치 프로세스를 시작하려면 설치 프로그램 파일을 두 번 클릭하십시오.
다음 화면은 설치 프로세스의 첫 번째 단계입니다. 다음 스크린 샷과 같이 H2 데이터베이스 서버를 설치할 경로를 제공합니다.
위의 스크린 샷에서 볼 수 있듯이 기본적으로 C:\ProgramFiles (x86)\H2대상 폴더로. 다음 단계로 진행하려면 다음을 클릭하십시오. 다음 화면이 나타납니다.
위 스크린 샷에서 설치 버튼을 클릭하여 설치 프로세스를 시작합니다. 설치 후 다음 스크린 샷이 표시됩니다.
마침을 클릭하여 설치 프로세스를 완료합니다.
3 단계 : H2 데이터베이스 설치 확인
설치 후 시스템에서 데이터베이스 설치를 확인하겠습니다. Windows를 클릭하고 → H2 콘솔을 입력하고 → H2 콘솔 아이콘을 클릭합니다. URL에 연결http://localhost:8082. 연결시 H2 데이터베이스는 다음 스크린 샷과 같이 데이터베이스 등록을 요청합니다.
저장된 설정, 설정 이름, 드라이버 클래스, JDBC URL, 사용자 이름 및 암호와 같은 위의 대화 상자에서 모든 세부 정보를 입력합니다. JDBC URL에서 데이터베이스 위치와 데이터베이스 이름을 지정합니다. 사용자 이름 및 암호는 데이터베이스의 사용자 이름 및 암호에 대한 필드입니다. 연결을 클릭하십시오.
다음 스크린 샷과 같이 데이터베이스 시작 페이지가 나타납니다.
Select 명령은 테이블 또는 여러 테이블에서 레코드 데이터를 가져 오는 데 사용됩니다. 선택 쿼리를 디자인하면 다음과 같은 결과 테이블 형식으로 데이터를 반환합니다.result sets.
통사론
SELECT 문의 기본 구문은 다음과 같습니다.
SELECT [ TOP term ] [ DISTINCT | ALL ] selectExpression [,...]
FROM tableExpression [,...] [ WHERE expression ]
[ GROUP BY expression [,...] ] [ HAVING expression ]
[ { UNION [ ALL ] | MINUS | EXCEPT | INTERSECT } select ] [ ORDER BY order [,...] ]
[ [ LIMIT expression ] [ OFFSET expression ] [ SAMPLE_SIZE rowCountInt ] ]
[ FOR UPDATE ]사용 가능한 모든 필드를 가져 오려면 다음 구문을 사용하십시오.
SELECT * FROM table_name;예
다음 레코드가있는 CUSTOMER 테이블을 고려하십시오.
+----+----------+-----+-----------+----------+
| ID | NAME | AGE | ADDRESS | SALARY |
+----+----------+-----+-----------+----------+
| 1 | Ramesh | 32 | Ahmedabad | 2000.00 |
| 2 | Khilan | 25 | Delhi | 1500.00 |
| 3 | kaushik | 23 | Kota | 2000.00 |
| 4 | Chaitali | 25 | Mumbai | 6500.00 |
| 5 | Hardik | 27 | Bhopal | 8500.00 |
| 6 | Komal | 22 | MP | 4500.00 |
| 7 | Muffy | 24 | Indore | 10000.00 |
+----+----------+-----+-----------+----------+주어진 데이터와 함께 고객 테이블을 얻으려면 다음 쿼리를 실행하십시오.
CREATE TABLE CUSTOMER (id number, name varchar(20), age number, address varchar(20),
salary number);
INSERT into CUSTOMER values (1, 'Ramesh', 32, 'Ahmedabad', 2000);
INSERT into CUSTOMER values (2, 'Khilan', 25, 'Delhi', 1500);
INSERT into CUSTOMER values (3, 'kaushik', 23, 'Kota', 2000);
INSERT into CUSTOMER values (4, 'Chaitali', 25, 'Mumbai', 6500);
INSERT into CUSTOMER values (5, 'Hardik', 27, 'Bhopal', 8500);
INSERT into CUSTOMER values (6, 'Komal', 22, 'MP', 4500);
INSERT into CUSTOMER values (7, 'Muffy', 24, 'Indore', 10000);다음 명령은 CUSTOMER 테이블에서 사용 가능한 고객의 ID, Name 및 Salary 필드를 가져 오는 예제입니다.
SELECT ID, NAME, SALARY FROM CUSTOMERS;위의 명령은 다음과 같은 결과를 생성합니다.
+----+----------+----------+
| ID | NAME | SALARY |
+----+----------+----------+
| 1 | Ramesh | 2000.00 |
| 2 | Khilan | 1500.00 |
| 3 | kaushik | 2000.00 |
| 4 | Chaitali | 6500.00 |
| 5 | Hardik | 8500.00 |
| 6 | Komal | 4500.00 |
| 7 | Muffy | 10000.00 |
+----+----------+----------+다음 쿼리를 사용하여 CUSTOMERS 테이블의 모든 필드를 가져옵니다.
SQL> SELECT * FROM CUSTOMERS;위의 쿼리는 다음 결과를 생성합니다-
+----+----------+-----+-----------+----------+
| ID | NAME | AGE | ADDRESS | SALARY |
+----+----------+-----+-----------+----------+
| 1 | Ramesh | 32 | Ahmedabad | 2000.00 |
| 2 | Khilan | 25 | Delhi | 1500.00 |
| 3 | kaushik | 23 | Kota | 2000.00 |
| 4 | Chaitali | 25 | Mumbai | 6500.00 |
| 5 | Hardik | 27 | Bhopal | 8500.00 |
| 6 | Komal | 22 | MP | 4500.00 |
| 7 | Muffy | 24 | Indore | 10000.00 |
+----+----------+-----+-----------+----------+SQL INSERT 문은 데이터베이스의 테이블에 새 데이터 행을 추가하는 데 사용됩니다.
통사론
다음은 INSERT INTO 문의 기본 구문입니다.
INSERT INTO tableName
{ [ ( columnName [,...] ) ]
{ VALUES
{ ( { DEFAULT | expression } [,...] ) } [,...] | [ DIRECT ] [ SORTED ] select } } |
{ SET { columnName = { DEFAULT | expression } } [,...] }이 INSERT 문을 사용하여 새 레코드 또는 새 행을 테이블에 삽입 할 수 있습니다. DIRECT 절을 사용하면 중간 단계없이 결과가 대상 테이블에 직접 영향을줍니다. 그러나 테이블의 모든 열에 대한 값을 추가하는 동안 값의 순서가 테이블의 열과 동일한 순서인지 확인하십시오.
예
예를 들어 다음과 같은 주어진 레코드를 Customer 테이블에 삽입 해 보겠습니다.
| 신분증 | 이름 | 나이 | 주소 | 봉급 |
|---|---|---|---|---|
| 1 | 라 메쉬 | 32 | 아마다 바드 | 2000 년 |
| 2 | 킬란 | 25 | 델리 | 1500 년 |
| 삼 | Kaushik | 23 | 코타 | 2000 년 |
| 4 | Chaitail | 25 | 뭄바이 | 6500 |
| 5 | 하딕 | 27 | 보팔 | 8500 |
| 6 | 코말 | 22 | MP | 4500 |
| 7 | 머피 | 24 | 인도 르 | 10000 |
다음 명령을 실행하여 주어진 모든 레코드를 고객 테이블로 가져올 수 있습니다.
INSERT INTO CUSTOMER VALUES (1, 'Ramesh', 32, 'Ahmedabad', 2000);
INSERT INTO CUSTOMER VALUES (2, 'Khilan', 25, 'Delhi', 1500);
INSERT INTO CUSTOMER VALUES (3, 'kaushik', 23, 'Kota', 2000);
INSERT INTO CUSTOMER VALUES (4, 'Chaitali', 25, 'Mumbai', 6500);
INSERT INTO CUSTOMER VALUES (5, 'Hardik', 27, 'Bhopal', 8500);
INSERT INTO CUSTOMER VALUES (6, 'Komal', 22, 'MP', 4500);
INSERT INTO CUSTOMER VALUES (7, 'Muffy', 24, 'Indore', 10000);UPDATE 쿼리는 테이블의 기존 레코드를 업데이트하거나 수정하는 데 사용됩니다. UPDATE 쿼리와 함께 WHERE 절을 사용하여 선택한 행을 업데이트 할 수 있습니다. 그렇지 않으면 모든 행이 영향을받습니다.
통사론
다음은 UPDATE 쿼리의 기본 구문입니다.
UPDATE tableName [ [ AS ] newTableAlias ] SET
{ { columnName = { DEFAULT | expression } } [,...] } |
{ ( columnName [,...] ) = ( select ) }
[ WHERE expression ] [ ORDER BY order [,...] ] [ LIMIT expression ]이 UPDATE 구문에서 AND 또는 OR 절을 사용하여 둘 이상의 조건을 결합 할 수 있습니다.
예
다음 레코드가있는 CUSTOMER 테이블을 고려하십시오.
+----+----------+-----+-----------+----------+
| ID | NAME | AGE | ADDRESS | SALARY |
+----+----------+-----+-----------+----------+
| 1 | Ramesh | 32 | Ahmedabad | 2000.00 |
| 2 | Khilan | 25 | Delhi | 1500.00 |
| 3 | kaushik | 23 | Kota | 2000.00 |
| 4 | Chaitali | 25 | Mumbai | 6500.00 |
| 5 | Hardik | 27 | Bhopal | 8500.00 |
| 6 | Komal | 22 | MP | 4500.00 |
| 7 | Muffy | 24 | Indore | 10000.00 |
+----+----------+-----+-----------+----------+주어진 데이터와 함께 고객 테이블을 얻으려면 다음 쿼리를 실행하십시오.
CREATE TABLE CUSTOMER (id number, name varchar(20), age number, address varchar(20),
salary number);
INSERT into CUSTOMER values (1, 'Ramesh', 32, 'Ahmedabad', 2000);
INSERT into CUSTOMER values (2, 'Khilan', 25, 'Delhi', 1500);
INSERT into CUSTOMER values (3, 'kaushik', 23, 'Kota', 2000);
INSERT into CUSTOMER values (4, 'Chaitali', 25, 'Mumbai', 6500);
INSERT into CUSTOMER values (5, 'Hardik', 27, 'Bhopal', 8500);
INSERT into CUSTOMER values (6, 'Komal', 22, 'MP', 4500);
INSERT into CUSTOMER values (7, 'Muffy', 24, 'Indore', 10000);다음 명령은 ID가 6 인 고객의 ADDRESS를 업데이트하는 예제입니다.
UPDATE CUSTOMERS SET ADDRESS = 'Pune' WHERE ID = 6;이제 CUSTOMERS 테이블에는 다음과 같은 레코드가 있습니다. 다음 쿼리를 실행하여 고객 테이블 레코드를 확인할 수 있습니다.
SELECT * FROM CUSTOMERS;위의 쿼리는 다음 결과를 생성합니다.
+----+----------+-----+-----------+----------+
| ID | NAME | AGE | ADDRESS | SALARY |
+----+----------+-----+-----------+----------+
| 1 | Ramesh | 32 | Ahmedabad | 2000.00 |
| 2 | Khilan | 25 | Delhi | 1500.00 |
| 3 | kaushik | 23 | Kota | 2000.00 |
| 4 | Chaitali | 25 | Mumbai | 6500.00 |
| 5 | Hardik | 27 | Bhopal | 8500.00 |
| 6 | Komal | 22 | Pune | 4500.00 |
| 7 | Muffy | 24 | Indore | 10000.00 |
+----+----------+-----+-----------+----------+CUSTOMERS 테이블의 모든 ADDRESS 및 SALARY 열 값을 수정하려면 WHERE 절을 사용할 필요가 없습니다. UPDATE 쿼리는 다음과 같습니다.
UPDATE CUSTOMERS SET ADDRESS = 'Pune', SALARY = 1000.00;이제 CUSTOMERS 테이블에는 다음과 같은 레코드가 있습니다. 다음 쿼리를 실행하여 고객 테이블 레코드를 확인할 수 있습니다.
SELECT * FROM CUSTOMERS;위의 쿼리는 다음 결과를 생성합니다-
+----+----------+-----+---------+---------+
| ID | NAME | AGE | ADDRESS | SALARY |
+----+----------+-----+---------+---------+
| 1 | Ramesh | 32 | Pune | 1000.00 |
| 2 | Khilan | 25 | Pune | 1000.00 |
| 3 | kaushik | 23 | Pune | 1000.00 |
| 4 | Chaitali | 25 | Pune | 1000.00 |
| 5 | Hardik | 27 | Pune | 1000.00 |
| 6 | Komal | 22 | Pune | 1000.00 |
| 7 | Muffy | 24 | Pune | 1000.00 |
+----+----------+-----+---------+---------+SQL DELETE 쿼리는 테이블에서 기존 레코드를 삭제하는 데 사용됩니다. DELETE 쿼리와 함께 WHERE 절을 사용하여 선택한 레코드를 삭제할 수 있습니다. 그렇지 않으면 모든 레코드가 삭제됩니다.
통사론
다음은 delete 명령의 일반 쿼리 구문입니다.
DELETE [ TOP term ] FROM tableName [ WHERE expression ] [ LIMIT term ]위의 구문은 테이블에서 행을 삭제합니다. TOP 또는 LIMIT가 지정되면 최대 지정된 수의 행이 삭제됩니다 (null이거나 0보다 작은 경우 제한 없음).
예
다음 레코드가있는 CUSTOMER 테이블을 고려하십시오.
+----+----------+-----+-----------+----------+
| ID | NAME | AGE | ADDRESS | SALARY |
+----+----------+-----+-----------+----------+
| 1 | Ramesh | 32 | Ahmedabad | 2000.00 |
| 2 | Khilan | 25 | Delhi | 1500.00 |
| 3 | kaushik | 23 | Kota | 2000.00 |
| 4 | Chaitali | 25 | Mumbai | 6500.00 |
| 5 | Hardik | 27 | Bhopal | 8500.00 |
| 6 | Komal | 22 | MP | 4500.00 |
| 7 | Muffy | 24 | Indore | 10000.00 |
+----+----------+-----+-----------+----------+다음 명령은 ID가 6 인 고객의 세부 정보를 삭제합니다.
DELETE FROM CUSTOMERS WHERE ID = 6;위 명령을 실행 한 후 다음 명령을 실행하여 Customer 테이블을 확인합니다.
SELECT * FROM CUSTOMERS;위의 명령은 다음 출력을 생성합니다.
+----+----------+-----+-----------+----------+
| ID | NAME | AGE | ADDRESS | SALARY |
+----+----------+-----+-----------+----------+
| 1 | Ramesh | 32 | Ahmedabad | 2000.00 |
| 2 | Khilan | 25 | Delhi | 1500.00 |
| 3 | kaushik | 23 | Kota | 2000.00 |
| 4 | Chaitali | 25 | Mumbai | 6500.00 |
| 5 | Hardik | 27 | Bhopal | 8500.00 |
| 7 | Muffy | 24 | Indore | 10000.00 |
+----+----------+-----+-----------+----------+CUSTOMERS 테이블의 모든 레코드를 삭제하려면 WHERE 절을 사용하지 않습니다. DELETE 쿼리는 다음과 같습니다.
DELETE FROM CUSTOMER;위의 명령을 실행 한 후에는 Customer 테이블에서 사용할 수있는 레코드가 없습니다.
BACKUP은 데이터베이스 백업을 별도의 .zip 파일로 가져 오는 데 사용되는 명령입니다. 개체는 잠기지 않으며 백업 할 때 트랜잭션 로그도 복사됩니다. 이 명령을 실행하려면 관리자 권한이 필요합니다.
통사론
다음은 Backup 명령의 일반 구문입니다.
BACKUP TO fileNameString;예
이 예에서는 현재 데이터베이스의 백업을 backup.zip파일. 동일하게 다음 명령을 사용하십시오.
BACKUP TO 'backup.zip';위의 명령을 실행하면 로컬 파일 시스템에 backup.zip 파일이 생성됩니다.
CALL은 H2 데이터베이스 서버에 속하는 SQL 명령입니다. 이 명령은 간단한 표현식을 계산하는 데 사용됩니다. 단일 열 필드에 주어진 표현식의 결과를 반환합니다. 결과 배열을 반환하면 배열의 각 요소가 열 값으로 표시됩니다.
통사론
다음은 CALL 명령의 일반 구문입니다.
CALL expression;이 구문에서 산술 표현식을 사용할 수 있습니다.
예
예를 들어 call 명령을 사용하여 산술 식 (15 * 25)을 실행 해 보겠습니다.
CALL 15*25;위의 명령은 다음 출력을 생성합니다.
| 375 |
|---|
| 375 |
EXPLAIN 명령은 명령문에 대한 실행 계획을 표시합니다. EXPLAIN ANALYZE 명령을 사용하여 명령문을 실행할 때 쿼리 계획에는 각 테이블에 대한 실제 행 스캔 수가 포함됩니다.
통사론
다음은 EXPLAIN 명령의 일반 구문입니다.
EXPLAIN { [ PLAN FOR ] | ANALYZE } { select | insert | update | delete | merge}이 구문과 함께 선택, 삽입, 삭제 및 병합을 사용할 수 있습니다.
예
이 예에서는 ID가 1 인 고객의 쿼리 계획 세부 정보를 설명합니다.
EXPLAIN SELECT * FROM CUSTOMER WHERE ID = 1;위의 명령은 다음 출력을 생성합니다.
MERGE 명령은 기존 행을 업데이트하고 새 행을 테이블에 삽입하는 데 사용됩니다. 이 명령을 사용하는 동안 기본 키 열은 중요한 역할을합니다. 행을 찾는 데 사용됩니다.
통사론
다음은 MERGE 명령의 일반 구문입니다.
MERGE INTO tableName [ ( columnName [,...] ) ]
[ KEY ( columnName [,...] ) ]
{ VALUES { ( { DEFAULT | expression } [,...] ) } [,...] | select }위의 구문에서 KEY 절은 기본 키 열 이름을 지정하는 데 사용됩니다. VALUES 절과 함께 기본 값을 사용하여 삽입하거나 select 명령을 사용하여이 테이블에 다른 테이블 값을 검색하고 저장할 수 있습니다.
예
이 예에서는 Customers 테이블에 새 레코드를 추가해 보겠습니다. 다음은 표의 새 레코드에 대한 세부 정보입니다.
| 열 이름 | 값 |
|---|---|
| 신분증 | 8 |
| 이름 | 로케시 |
| 나이 | 32 |
| 주소 | 하이데라바드 |
| 봉급 | 2500 |
다음 쿼리를 사용하여 주어진 레코드를 H2 데이터베이스 쿼리에 삽입하겠습니다.
MERGE INTO CUSTOMER KEY (ID) VALUES (8, 'Lokesh', 32, 'Hyderabad', 2500);위의 쿼리는 다음 출력을 생성합니다.
Update count: 1다음 쿼리를 실행하여 Customer 테이블의 레코드를 확인하겠습니다.
SELECT * FROM CUSTOMER;위의 쿼리는 다음 출력을 생성합니다.
| 신분증 | 이름 | 나이 | 주소 | 봉급 |
|---|---|---|---|---|
| 1 | 라 메쉬 | 32 | 아마다 바드 | 2000 년 |
| 2 | 킬란 | 25 | 델리 | 1500 년 |
| 삼 | Kaushik | 23 | 코타 | 2000 년 |
| 4 | 차이 탈리 | 25 | 뭄바이 | 6500 |
| 5 | 하딕 | 27 | 보팔 | 8500 |
| 6 | 코말 | 22 | MP | 4500 |
| 7 | 머피 | 24 | 인도 르 | 10000 |
| 8 | 로케시 | 32 | 하이데라바드 | 2500 |
이제 다음을 사용하여 레코드를 업데이트 해 보겠습니다. Merge명령. 다음은 업데이트 할 레코드의 세부 정보입니다.
| 열 이름 | 값 |
|---|---|
| 신분증 | 8 |
| 이름 | 로키 |
| 나이 | 32 |
| 주소 | 하이데라바드 |
| 봉급 | 3000 |
다음 쿼리를 사용하여 주어진 레코드를 H2 데이터베이스 쿼리에 삽입합니다.
MERGE INTO CUSTOMER KEY (ID) VALUES (8, 'Loki', 32, 'Hyderabad', 3000);위의 쿼리는 다음 출력을 생성합니다.
Update count: 1다음 쿼리를 실행하여 Customer 테이블의 레코드를 확인하겠습니다.
SELECT * FROM CUSTOMER;위의 쿼리는 다음 출력을 생성합니다.
| 신분증 | 이름 | 나이 | 주소 | 봉급 |
|---|---|---|---|---|
| 1 | 라 메쉬 | 32 | 아마다 바드 | 2000 년 |
| 2 | 킬란 | 25 | 델리 | 1500 년 |
| 삼 | Kaushik | 23 | 코타 | 2000 년 |
| 4 | 차이 탈리 | 25 | 뭄바이 | 6500 |
| 5 | 하딕 | 27 | 보팔 | 8500 |
| 6 | 코말 | 22 | MP | 4500 |
| 7 | 머피 | 24 | 인도 르 | 10000 |
| 8 | 로키 | 32 | 하이데라바드 | 3000 |
SHOW는 테이블의 스키마, 테이블 또는 열 목록을 표시하는 데 사용되는 명령입니다.
통사론
다음은 SHOW 명령의 일반 구문입니다.
SHOW { SCHEMAS | TABLES [ FROM schemaName ] |
COLUMNS FROM tableName [ FROM schemaName ] }예
다음 명령을 사용하여 현재 데이터베이스의 테이블 목록을 가져올 수 있습니다.
SHOW TABLES;위의 명령은 다음 출력을 생성합니다.
| TABLE_NAME | TABLE_SCHEMA |
|---|---|
| 고객 | 공공의 |
| EMP | 공공의 |
CREATE는 H2 데이터베이스 서버에서 테이블, 스키마, 시퀀스, 뷰 및 사용자를 생성하는 데 사용되는 일반 SQL 명령입니다.
테이블 생성
테이블 만들기는 현재 데이터베이스에서 사용자 정의 테이블을 만드는 데 사용되는 명령입니다.
통사론
다음은 테이블 만들기 명령의 일반 구문입니다.
CREATE [ CACHED | MEMORY ] [ TEMP | [ GLOBAL | LOCAL ] TEMPORARY ]
TABLE [ IF NOT EXISTS ] name
[ ( { columnDefinition | constraint } [,...] ) ]
[ ENGINE tableEngineName [ WITH tableEngineParamName [,...] ] ]
[ NOT PERSISTENT ] [ TRANSACTIONAL ]
[ AS select ]테이블 생성 명령의 일반 구문을 사용하여 캐시 된 테이블, 메모리 테이블 및 임시 테이블과 같은 다양한 유형의 테이블을 생성 할 수 있습니다. 다음은 주어진 구문에서 다른 절을 설명하는 목록입니다.
CACHED− 캐시 된 테이블은 일반 테이블의 기본 유형입니다. 이는 행 수가 주 메모리에 의해 제한되지 않음을 의미합니다.
MEMORY− 메모리 테이블은 임시 테이블의 기본 유형입니다. 이는 메모리 테이블이 너무 커지지 않아야하고 인덱스 데이터가 주 메모리에 보관되어 있어야 함을 의미합니다.
TEMPORARY− 데이터베이스를 닫거나 여는 동안 임시 테이블이 삭제됩니다. 기본적으로 임시 테이블은 두 가지 유형이 있습니다.
GLOBAL 유형-모든 연결에서 액세스 할 수 있습니다.
LOCAL 유형-현재 연결로 액세스 할 수 있습니다.
임시 테이블의 기본 유형은 전역 유형입니다. CREATE CACHED TABLE을 사용하여 임시 테이블을 생성하지 않는 한 임시 테이블의 인덱스는 주 메모리에 보관됩니다.
ENGINE − ENGINE 옵션은 사용자 정의 테이블 구현이 사용되는 경우에만 필요합니다.
NOT PERSISTENT − 전체 테이블 데이터를 메모리에 유지하는 수정 자이며 데이터베이스가 닫히면 모든 행이 손실됩니다.
TRANSACTIONAL − 오픈 트랜잭션을 커밋하는 키워드로 임시 테이블 만 지원합니다.
예
이 예에서는 다음 데이터를 사용하여 tutorials_tbl이라는 테이블을 생성 해 보겠습니다.
| Sr. 아니요 | 열 이름 | 데이터 형식 |
|---|---|---|
| 1 | 신분증 | Int |
| 2 | 표제 | 바르샤 르 (50) |
| 삼 | 저자 | 바르샤 르 (20) |
| 4 | 제출 날짜 | 데이트 |
다음 쿼리는 테이블을 만드는 데 사용됩니다. tutorials_tbl 주어진 열 데이터와 함께.
CREATE TABLE tutorials_tbl (
id INT NOT NULL,
title VARCHAR(50) NOT NULL,
author VARCHAR(20) NOT NULL,
submission_date DATE
);위의 쿼리는 다음 출력을 생성합니다.
(0) rows effected스키마 생성
스키마 생성은 특정 권한 (현재 등록 된 사용자 아래)에 따라 사용자 종속 스키마를 생성하는 데 사용되는 명령입니다.
통사론
다음은 Create Schema 명령의 일반 구문입니다.
CREATE SCHEMA [ IF NOT EXISTS ] name [ AUTHORIZATION ownerUserName ]위의 일반 구문에서 AUTHORIZATION은 각 사용자 이름을 제공하는 데 사용되는 키워드입니다. 이 명령은 선택 사항입니다. 즉, 사용자 이름을 제공하지 않으면 현재 사용자를 고려합니다. 명령을 실행하는 사용자는 소유자와 관리자 권한이 있어야합니다.
이 명령은이 연결에서 열린 트랜잭션을 커밋합니다.
예
이 예에서는 다음과 같은 스키마를 생성하겠습니다. test_schema SA 사용자에서 다음 명령을 사용합니다.
CREATE SCHEMA test_schema AUTHORIZATION sa;위의 명령은 다음 출력을 생성합니다.
(0) rows effected시퀀스 생성
시퀀스는 id 또는 임의의 열 값에 대한 시퀀스를 따라 숫자를 생성하는 데 사용되는 개념입니다.
통사론
다음은 create sequence 명령의 일반 구문입니다.
CREATE SEQUENCE [ IF NOT EXISTS ] newSequenceName [ START WITH long ]
[ INCREMENT BY long ]
[ MINVALUE long | NOMINVALUE | NO MINVALUE ]
[ MAXVALUE long | NOMAXVALUE | NO MAXVALUE ]
[ CYCLE long | NOCYCLE | NO CYCLE ]
[ CACHE long | NOCACHE | NO CACHE ]이 일반 구문은 시퀀스를 만드는 데 사용됩니다. 시퀀스의 데이터 유형은 다음과 같습니다.BIGINT. 이 시퀀스에서는 트랜잭션이 롤백 된 경우에도 값이 재사용되지 않습니다.
예
이 예에서는 다음과 같은 시퀀스를 생성하겠습니다. SEQ_ID, 다음 쿼리를 사용합니다.
CREATE SEQUENCE SEQ_ID;위의 쿼리는 다음 출력을 생성합니다.
(0) rows effectedALTER는 다른 절을 추가하여 테이블 구조를 변경하는 데 사용되는 명령입니다. alter명령. 시나리오에 따라 alter 명령에 각 절을 추가해야합니다. 이 장에서는 alter 명령의 다양한 시나리오에 대해 설명합니다.
테이블 추가 변경
Alter Table Add는 각 데이터 유형과 함께 테이블에 새 열을 추가하는 데 사용되는 명령입니다. 이 명령은이 연결에서 트랜잭션을 커밋합니다.
통사론
다음은 Alter Table Add 명령의 일반 구문입니다.
ALTER TABLE [ IF EXISTS ] tableName ADD [ COLUMN ]
{ [ IF NOT EXISTS ] columnDefinition [ { BEFORE | AFTER } columnName ]
| ( { columnDefinition } [,...] ) }예
이 예에서는 새 열을 추가합니다. start_date 테이블에 tutorials_tbl. start_date의 데이터 유형은 Date입니다. 다음은 새 열을 추가하는 쿼리입니다.
ALTER TABLE tutorials_tbl ADD start_date DATE;위의 쿼리는 다음 출력을 생성합니다.
(6) rows effected테이블 추가 제약 조건 변경
Alter table add constraint는 기본 키, 외래 키, null이 아닌 등의 다른 제약 조건을 테이블에 추가하는 데 사용되는 명령입니다.
필요한 인덱스가 아직 없으면 자동으로 생성됩니다. 고유 제약 조건 검사를 비활성화 할 수 없습니다. 이 명령은이 연결에서 열린 트랜잭션을 커밋합니다.
통사론
다음은 Alter table add constraint 명령의 일반 구문입니다.
ALTER TABLE [ IF EXISTS ] tableName ADD constraint [ CHECK | NOCHECK ]예
이 예에서는 기본 키 제약 조건을 추가하겠습니다. (tutorials_tbl_pk) 테이블의 컬럼 ID에 tutorials_tbl, 다음 쿼리를 사용합니다.
ALTER TABLE tutorials_tbl ADD CONSTRAINT tutorials_tbl_pk PRIMARYKEY(id);위의 쿼리는 다음 출력을 생성합니다.
(6) row (s) effected테이블 이름 바꾸기 제약 조건 변경
이 명령은 특정 관계 테이블의 제약 이름을 바꾸는 데 사용됩니다. 이 명령은이 연결에서 열린 트랜잭션을 커밋합니다.
통사론
다음은 Alter Table Rename Constraint 명령의 일반 구문입니다.
ALTER TABLE [ IF EXISTS ] tableName RENAME oldConstraintName TO newConstraintName이 구문을 사용하는 동안 각 열에 이전 제약 조건 이름이 있어야합니다.
예
이 예에서는 테이블의 기본 키 제약 조건 이름을 변경합니다. tutorials_tbl ...에서 tutorials_tbl_pk ...에 tutorials_tbl_pk_constraint. 다음은이를 수행하는 쿼리입니다.
ALTER TABLE tutorials_tbl RENAME CONSTRAINT
tutorials_tbl_pk TO tutorials_tbl_pk_constraint;위의 쿼리는 다음 출력을 생성합니다.
(1) row (s) effected테이블 변경 열 변경
이 명령은 특정 테이블 열의 구조와 속성을 변경하는 데 사용됩니다. 속성 변경은 열의 데이터 유형 변경, 열 이름 변경, ID 값 변경 또는 선택도 변경을 의미합니다.
통사론
다음은 Alter Table Alter Column 명령의 일반 구문입니다.
ALTER TABLE [ IF EXISTS ] tableName ALTER COLUMN columnName
{ { dataType [ DEFAULT expression ] [ [ NOT ] NULL ] [ AUTO_INCREMENT | IDENTITY ] }
| { RENAME TO name }
| { RESTART WITH long }
| { SELECTIVITY int }
| { SET DEFAULT expression }
| { SET NULL }
| { SET NOT NULL } }위의 구문에서-
RESTART − 명령은 자동 증가 열의 다음 값을 변경합니다.
SELECTIVITY− 명령은 열에 대한 선택도 (1-100)를 설정합니다. 선택성 값을 기반으로 열의 값을 이미지화 할 수 있습니다.
SET DEFAULT − 열의 기본값을 변경합니다.
SET NULL − NULL을 허용하도록 열을 설정합니다.
SET NOT NULL − NOT NULL을 허용하도록 열을 설정합니다.
예
이 예에서는 테이블의 열 이름을 변경합니다. tutorials_tbl ...에서 Title ...에 Tutorial_Title 다음 쿼리를 사용합니다.
ALTER TABLE tutorials_tbl ALTER COLUMN title RENAME TO tutorial_title;위의 쿼리는 다음 출력을 생성합니다.
(0) row(s) effected비슷한 방식으로 ALTER 명령으로 다른 시나리오를 수행 할 수 있습니다.
DROP은 일반 SQL 문법에서 가져온 명령입니다. 이 명령은 메모리에서 데이터베이스 구성 요소 및 해당 구조를 삭제하는 데 사용됩니다. 이 장에서 논의 할 Drop 명령에는 다양한 시나리오가 있습니다.
드롭 테이블
Drop Table은 해당 테이블과 그 구조를 삭제하는 명령입니다.
통사론
다음은 테이블 삭제 명령의 일반 구문입니다.
DROP TABLE [ IF EXISTS ] tableName [,...] [ RESTRICT | CASCADE ]RESTRICT를 사용 중이고 종속 뷰가있는 테이블이 있으면 명령이 실패합니다. CASCADE 키워드를 사용하면 모든 종속 뷰가 삭제됩니다.
예
이 예에서는 다음 쿼리를 사용하여 test라는 테이블을 삭제합니다.
DROP TABLE test;위의 쿼리는 다음 출력을 생성합니다.
(6) row (s) effected스키마 삭제
Drop Schema는 데이터베이스 서버에서 각 스키마를 삭제하는 명령입니다. 현재 스키마에서는 작동하지 않습니다.
통사론
DROP SCHEMA [ IF EXISTS ] schemaName예
이 예에서는 다음과 같은 스키마를 삭제합니다. test_schema 다음 쿼리를 사용합니다.
DROP SCHEMA TEST_SCHEMA;위의 쿼리는 다음 출력을 생성합니다.
(0) row(s) effected드롭 시퀀스
순서 삭제는 테이블 구조에서 순서를 삭제하는 데 사용되는 명령입니다.
통사론
다음은 Drop Sequence 명령의 일반적인 구문입니다.
DROP SEQUENCE [ IF EXISTS ] sequenceName이 명령은이 연결에서 열린 트랜잭션을 커밋합니다.
예
이 예에서는 이름이 지정된 시퀀스를 삭제합니다. sequence_id. 다음은 명령입니다.
DROP SEQUENCE sequence_id;위의 명령은 다음 출력을 생성합니다.
(0) row (s) effected드롭 뷰
드롭 뷰는 기존 뷰를 드롭하는 데 사용되는 명령입니다. CASCADE 절이 사용되면 모든 종속 뷰도 삭제됩니다.
통사론
다음은 Drop View 명령의 일반 구문입니다.
DROP VIEW [ IF EXISTS ] viewName [ RESTRICT | CASCADE ]예
이 예에서 우리는 sample_view 다음 쿼리를 사용합니다.
DROP VIEW sample_view;위의 쿼리는 다음 출력을 생성합니다.
(0) row (s) effectedTRUNCATE는 테이블에서 데이터를 삭제하는 데 사용되는 명령입니다. WHERE 절이없는 DELETE FROM과 달리이 명령은 롤백 할 수 없습니다. 이 명령은이 연결에서 열린 트랜잭션을 커밋합니다.
통사론
다음은 truncate 명령의 일반 구문입니다.
TRUNCATE TABLE tableName예
이 예에서는 다음과 같은 테이블을 자릅니다. test 다음 쿼리를 사용합니다.
TRUNCATE TABLE test;위의 쿼리는 다음 출력을 생성합니다.
(6) row (s) effectedCOMMIT는 트랜잭션을 커밋하는 데 사용되는 SQL 문법의 명령입니다. 특정 트랜잭션을 커밋하거나 현재 실행중인 트랜잭션을 커밋 할 수 있습니다.
통사론
COMMIT 명령에는 두 가지 구문이 있습니다.
다음은 현재 트랜잭션을 커밋하기위한 commit 명령의 일반 구문입니다.
COMMIT [ WORK ]다음은 특정 트랜잭션을 커밋하기위한 commit 명령의 일반 구문입니다.
COMMIT TRANSACTION transactionName예 1
이 예에서는 다음 명령을 사용하여 현재 트랜잭션을 커밋합니다.
COMMIT위의 명령은 다음 출력을 생성합니다.
Committed successfully예 2
이 예에서는 다음과 같은 트랜잭션을 커밋합니다. tx_test 다음 명령을 사용하십시오.
COMMIT TRANSACTION tx_test;위의 명령은 다음 출력을 생성합니다.
Committed successfullyGrant는 테이블, 사용자 또는 역할에 대한 권한을 부여하는 데 사용되는 SQL 문법에서 오는 명령입니다. 이 명령을 실행하려면 관리자 권한이 필요합니다. 이 명령은이 연결에서 열린 트랜잭션을 커밋합니다.
이 장에서는 Grant 명령의 다양한 시나리오에 대해 설명합니다.
권한 부여
권한 부여는 테이블, 사용자 또는 역할에 관리자 권한을 제공하는 명령입니다.
통사론
다음은 Grant 명령의 일반 구문입니다.
GRANT { SELECT | INSERT | UPDATE | DELETE | ALL } [,...] ON
{ { SCHEMA schemaName } | { tableName [,...] } }
TO { PUBLIC | userName | roleName }예
이 예에서는 다음 명령을 사용하여 테스트 테이블을 읽기 전용으로 부여합니다.
GRANT SELECT ON TEST TO READONLY위의 명령은 다음 출력을 생성합니다.
Grant successfully모든 스키마 변경 허용
Grant Alter Any Schema는 각 사용자에게 스키마 변경 권한을 부여하는 명령입니다.
통사론
다음은 Grant Alter Any Schema 명령의 일반 구문입니다.
GRANT ALTER ANY SCHEMA TO userName예
이 예에서는 스키마의 변경 권한을 다음과 같은 사용자에게 부여합니다. test_user. test_user가 있는지 확인하십시오. 다음은 변경 권한을 부여하는 쿼리입니다.
GRANT ALTER ANY SCHEMA TO test_user;위의 쿼리는 다음 출력을 생성합니다.
Granted successfully to test_userSAVEPOINT는 트랜잭션을 일시적으로 저장하는 데 사용되는 명령입니다. 필요할 때마다 트랜잭션을 각 저장 점으로 롤백하는 것이 도움이되므로 트랜잭션에서 저장 점을 유지하는 것이 좋습니다.
통사론
다음은 Savepoint 명령의 일반 구문입니다.
SAVEPOINT savepointName예
이 예에서는 다음 명령을 사용하여 Half_Done이라는 세이브 포인트를 생성합니다.
SAVEPOINT Half_Done;위의 명령은 다음 출력을 생성합니다.
Savepoint createdROLLBACK은 트랜잭션을 저장 점 또는 이전 트랜잭션으로 롤백하는 데 사용되는 SQL 문법의 명령입니다. 이 명령을 사용하여 특정 Savepoint로 롤백하거나 이전에 실행 된 트랜잭션으로 롤백 할 수 있습니다.
통사론
ROLLABCK 명령에는 두 가지 구문이 있습니다.
다음은 롤백 명령의 일반 구문입니다.
ROLLBACK [ TO SAVEPOINT savepointName ]다음은 특정 트랜잭션에 대한 롤백 명령의 일반 구문입니다.
ROLLBACK TRANSACTION transactionName예 1
이 예에서는 현재 트랜잭션을 이름이 지정된 저장 점으로 롤백합니다. sp1_test 다음 명령을 사용하십시오.
ROLLBACK sp1_test;위의 명령은 다음 출력을 생성합니다.
Rollback successfully예 2
다음 예에서는 이름이 지정된 전체 트랜잭션을 롤백합니다. tx_test 주어진 명령을 사용합니다.
ROLLBACK TRANSACTION tx_test;위의 명령은 다음 출력을 생성합니다.
Rollback successfullyH2는 JAVA 데이터베이스입니다. JDBC를 사용하여이 데이터베이스와 상호 작용할 수 있습니다. 이 장에서는 H2 데이터베이스와의 JDBC 연결 및 H2 데이터베이스와의 CRUD 작업을 만드는 방법을 살펴 봅니다.
일반적으로 JDBC 연결을 만드는 데는 5 단계가 있습니다.
Step 1 − JDBC 데이터베이스 드라이버 등록.
Class.forName ("org.h2.Driver");Step 2 − 연결 열기.
Connection conn = DriverManager.getConnection ("jdbc:h2:~/test", "sa","");Step 3 − 성명서 작성.
Statement st = conn.createStatement();Step 4 − 명세서 실행 및 Resultset 수신.
Stmt.executeUpdate("sql statement");Step 5 − 연결 종료.
conn.close();전체 프로그램을 만들기 전에 다음을 추가해야합니다. h2-1.4.192.jar fileCLASSPATH에. 우리는 이것을 얻을 수 있습니다jar 폴더에서 C:\Program Files (x86)\H2\bin.
테이블 생성
이 예에서는 테이블 생성을위한 프로그램을 작성합니다. 다음과 같은 테이블을 고려하십시오.Registration 다음 필드가 있습니다.
| S. 아니 | 열 이름 | 데이터 형식 | NULL 아님 | 기본 키 |
|---|---|---|---|---|
| 1 | 신분증 | 번호 | 예 | 예 |
| 2 | 먼저 | Varchar (255) | 아니 | 아니 |
| 삼 | 마지막 | Varchar (255) | 아니 | 아니 |
| 4 | 나이 | 번호 | 아니 | 아니 |
다음은 이름이 지정된 예제 프로그램입니다. H2jdbcCreateDemo.
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.SQLException;
import java.sql.Statement;
public class H2jdbcCreateDemo {
// JDBC driver name and database URL
static final String JDBC_DRIVER = "org.h2.Driver";
static final String DB_URL = "jdbc:h2:~/test";
// Database credentials
static final String USER = "sa";
static final String PASS = "";
public static void main(String[] args) {
Connection conn = null;
Statement stmt = null;
try {
// STEP 1: Register JDBC driver
Class.forName(JDBC_DRIVER);
//STEP 2: Open a connection
System.out.println("Connecting to database...");
conn = DriverManager.getConnection(DB_URL,USER,PASS);
//STEP 3: Execute a query
System.out.println("Creating table in given database...");
stmt = conn.createStatement();
String sql = "CREATE TABLE REGISTRATION " +
"(id INTEGER not NULL, " +
" first VARCHAR(255), " +
" last VARCHAR(255), " +
" age INTEGER, " +
" PRIMARY KEY ( id ))";
stmt.executeUpdate(sql);
System.out.println("Created table in given database...");
// STEP 4: Clean-up environment
stmt.close();
conn.close();
} catch(SQLException se) {
//Handle errors for JDBC
se.printStackTrace();
} catch(Exception e) {
//Handle errors for Class.forName
e.printStackTrace();
} finally {
//finally block used to close resources
try{
if(stmt!=null) stmt.close();
} catch(SQLException se2) {
} // nothing we can do
try {
if(conn!=null) conn.close();
} catch(SQLException se){
se.printStackTrace();
} //end finally try
} //end try
System.out.println("Goodbye!");
}
}위 프로그램을 H2jdbcCreateDemo.java에 저장합니다. 명령 프롬프트에서 다음 명령을 실행하여 위 프로그램을 컴파일하고 실행합니다.
\>javac H2jdbcCreateDemo.java
\>java H2jdbcCreateDemo위의 명령은 다음 출력을 생성합니다.
Connecting to database...
Creating table in given database...
Created table in given database...
Goodbye!이 실행 후 H2 SQL 인터페이스를 사용하여 생성 된 테이블을 확인할 수 있습니다.
기록 삽입
이 예에서는 레코드를 삽입하는 프로그램을 작성합니다. 등록 테이블에 다음 레코드를 삽입하겠습니다.
| 신분증 | 먼저 | 마지막 | 나이 |
|---|---|---|---|
| 100 | 자라 | 알리 | 18 |
| 101 | Mahnaz | Fatma | 25 |
| 102 | 자이드 | 칸 | 30 |
| 103 | Sumit | 미탈 | 28 |
다음은 이름이 지정된 예제 프로그램입니다. H2jdbcInsertDemo.
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.SQLException;
import java.sql.Statement;
public class H2jdbcInsertDemo {
// JDBC driver name and database URL
static final String JDBC_DRIVER = "org.h2.Driver";
static final String DB_URL = "jdbc:h2:~/test";
// Database credentials
static final String USER = "sa";
static final String PASS = "";
public static void main(String[] args) {
Connection conn = null;
Statement stmt = null;
try{
// STEP 1: Register JDBC driver
Class.forName(JDBC_DRIVER);
// STEP 2: Open a connection
System.out.println("Connecting to a selected database...");
conn = DriverManager.getConnection(DB_URL,USER,PASS);
System.out.println("Connected database successfully...");
// STEP 3: Execute a query
stmt = conn.createStatement();
String sql = "INSERT INTO Registration " + "VALUES (100, 'Zara', 'Ali', 18)";
stmt.executeUpdate(sql);
sql = "INSERT INTO Registration " + "VALUES (101, 'Mahnaz', 'Fatma', 25)";
stmt.executeUpdate(sql);
sql = "INSERT INTO Registration " + "VALUES (102, 'Zaid', 'Khan', 30)";
stmt.executeUpdate(sql);
sql = "INSERT INTO Registration " + "VALUES(103, 'Sumit', 'Mittal', 28)";
stmt.executeUpdate(sql);
System.out.println("Inserted records into the table...");
// STEP 4: Clean-up environment
stmt.close();
conn.close();
} catch(SQLException se) {
// Handle errors for JDBC
se.printStackTrace();
} catch(Exception e) {
// Handle errors for Class.forName
e.printStackTrace();
} finally {
// finally block used to close resources
try {
if(stmt!=null) stmt.close();
} catch(SQLException se2) {
} // nothing we can do
try {
if(conn!=null) conn.close();
} catch(SQLException se) {
se.printStackTrace();
} // end finally try
} // end try
System.out.println("Goodbye!");
}
}위 프로그램을 H2jdbcInsertDemo.java에 저장합니다. 명령 프롬프트에서 다음 명령을 실행하여 위 프로그램을 컴파일하고 실행합니다.
\>javac H2jdbcInsertDemo.java
\>java H2jdbcInsertDemo위의 명령은 다음 출력을 생성합니다.
Connecting to a selected database...
Connected database successfully...
Inserted records into the table...
Goodbye!기록 읽기
이 예에서는 레코드를 읽는 프로그램을 작성합니다. 테이블에서 모든 레코드를 읽어 보겠습니다.Registration.
다음은 이름이 지정된 예제 프로그램입니다. H2jdbcRecordDemo.
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;
public class H2jdbcReadDemo {
// JDBC driver name and database URL
static final String JDBC_DRIVER = "org.h2.Driver";
static final String DB_URL = "jdbc:h2:~/test";
// Database credentials
static final String USER = "sa";
static final String PASS = "";
public static void main(String[] args) {
Connection conn = null;
Statement stmt = null;
try {
// STEP 1: Register JDBC driver
Class.forName(JDBC_DRIVER);
// STEP 2: Open a connection
System.out.println("Connecting to database...");
conn = DriverManager.getConnection(DB_URL,USER,PASS);
// STEP 3: Execute a query
System.out.println("Connected database successfully...");
stmt = conn.createStatement();
String sql = "SELECT id, first, last, age FROM Registration";
ResultSet rs = stmt.executeQuery(sql);
// STEP 4: Extract data from result set
while(rs.next()) {
// Retrieve by column name
int id = rs.getInt("id");
int age = rs.getInt("age");
String first = rs.getString("first");
String last = rs.getString("last");
// Display values
System.out.print("ID: " + id);
System.out.print(", Age: " + age);
System.out.print(", First: " + first);
System.out.println(", Last: " + last);
}
// STEP 5: Clean-up environment
rs.close();
} catch(SQLException se) {
// Handle errors for JDBC
se.printStackTrace();
} catch(Exception e) {
// Handle errors for Class.forName
e.printStackTrace();
} finally {
// finally block used to close resources
try {
if(stmt!=null) stmt.close();
} catch(SQLException se2) {
} // nothing we can do
try {
if(conn!=null) conn.close();
} catch(SQLException se) {
se.printStackTrace();
} // end finally try
} // end try
System.out.println("Goodbye!");
}
}위 프로그램을 H2jdbcReadDemo.java에 저장합니다. 명령 프롬프트에서 다음 명령을 실행하여 위 프로그램을 컴파일하고 실행합니다.
\>javac H2jdbcReadDemo.java
\>java H2jdbcReadDemo위의 명령은 다음 출력을 생성합니다.
Connecting to a selected database...
Connected database successfully...
ID: 100, Age: 18, First: Zara, Last: Ali
ID: 101, Age: 25, First: Mahnaz, Last: Fatma
ID: 102, Age: 30, First: Zaid, Last: Khan
ID: 103, Age: 28, First: Sumit, Last: Mittal
Goodbye!기록 업데이트
이 예에서는 레코드를 업데이트하는 프로그램을 작성합니다. 테이블에서 모든 레코드를 읽어 보겠습니다.Registration.
다음은 이름이 지정된 예제 프로그램입니다. H2jdbcUpdateDemo.
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;
public class H2jdbcUpdateDemo {
// JDBC driver name and database URL
static final String JDBC_DRIVER = "org.h2.Driver";
static final String DB_URL = "jdbc:h2:~/test";
// Database credentials
static final String USER = "sa";
static final String PASS = "";
public static void main(String[] args) {
Connection conn = null;
Statement stmt = null;
try {
// STEP 1: Register JDBC driver
Class.forName(JDBC_DRIVER);
// STEP 2: Open a connection
System.out.println("Connecting to a database...");
conn = DriverManager.getConnection(DB_URL,USER,PASS);
// STEP 3: Execute a query
System.out.println("Connected database successfully...");
stmt = conn.createStatement();
String sql = "UPDATE Registration " + "SET age = 30 WHERE id in (100, 101)";
stmt.executeUpdate(sql);
// Now you can extract all the records
// to see the updated records
sql = "SELECT id, first, last, age FROM Registration";
ResultSet rs = stmt.executeQuery(sql);
while(rs.next()){
// Retrieve by column name
int id = rs.getInt("id");
int age = rs.getInt("age");
String first = rs.getString("first");
String last = rs.getString("last");
// Display values
System.out.print("ID: " + id);
System.out.print(", Age: " + age);
System.out.print(", First: " + first);
System.out.println(", Last: " + last);
}
rs.close();
} catch(SQLException se) {
// Handle errors for JDBC
se.printStackTrace();
} catch(Exception e) {
// Handle errors for Class.forName
e.printStackTrace();
} finally {
// finally block used to close resources
try {
if(stmt!=null) stmt.close();
} catch(SQLException se2) {
} // nothing we can do
try {
if(conn!=null) conn.close();
} catch(SQLException se) {
se.printStackTrace();
} // end finally try
} // end try
System.out.println("Goodbye!");
}
}위 프로그램을 H2jdbcUpdateDemo.java에 저장합니다. 명령 프롬프트에서 다음 명령을 실행하여 위 프로그램을 컴파일하고 실행합니다.
\>javac H2jdbcUpdateDemo.java
\>java H2jdbcUpdateDemo위의 명령은 다음 출력을 생성합니다.
Connecting to a selected database...
Connected database successfully...
ID: 100, Age: 30, First: Zara, Last: Ali
ID: 101, Age: 30, First: Mahnaz, Last: Fatma
ID: 102, Age: 30, First: Zaid, Last: Khan
ID: 103, Age: 28, First: Sumit, Last: Mittal
Goodbye!기록 삭제
이 예에서는 레코드를 삭제하는 프로그램을 작성합니다. 테이블에서 모든 레코드를 읽어 보겠습니다.Registration.
다음은 이름이 지정된 예제 프로그램입니다. H2jdbcDeleteDemo.
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;
public class H2jdbcDeleteDemo {
// JDBC driver name and database URL
static final String JDBC_DRIVER = "org.h2.Driver";
static final String DB_URL = "jdbc:h2:~/test";
// Database credentials
static final String USER = "sa";
static final String PASS = "";
public static void main(String[] args) {
Connection conn = null;
Statement stmt = null;
try {
// STEP 1: Register JDBC driver
Class.forName(JDBC_DRIVER);
// STEP 2: Open a connection
System.out.println("Connecting to database...");
conn = DriverManager.getConnection(DB_URL,USER,PASS);
// STEP 3: Execute a query
System.out.println("Creating table in given database...");
stmt = conn.createStatement();
String sql = "DELETE FROM Registration " + "WHERE id = 101";
stmt.executeUpdate(sql);
// Now you can extract all the records
// to see the remaining records
sql = "SELECT id, first, last, age FROM Registration";
ResultSet rs = stmt.executeQuery(sql);
while(rs.next()){
// Retrieve by column name
int id = rs.getInt("id");
int age = rs.getInt("age");
String first = rs.getString("first");
String last = rs.getString("last");
// Display values
System.out.print("ID: " + id);
System.out.print(", Age: " + age);
System.out.print(", First: " + first);
System.out.println(", Last: " + last);
}
rs.close();
} catch(SQLException se) {
// Handle errors for JDBC
se.printStackTrace();
} catch(Exception e) {
// Handle errors for Class.forName
e.printStackTrace();
} finally {
// finally block used to close resources
try {
if(stmt!=null) stmt.close();
} catch(SQLException se2) {
} // nothing we can do
try {
if(conn!=null) conn.close();
} catch(SQLException se) {
se.printStackTrace();
} // end finally try
} // end try
System.out.println("Goodbye!");
}
}위 프로그램을 H2jdbcDeleteDemo.java에 저장합니다. 명령 프롬프트에서 다음 명령을 실행하여 위 프로그램을 컴파일하고 실행합니다.
\>javac H2jdbcDeleteDemo.java
\>java H2jdbcDeleteDemo위의 명령은 다음 출력을 생성합니다.
Connecting to a selected database...
Connected database successfully...
ID: 100, Age: 30, First: Zara, Last: Ali
ID: 102, Age: 30, First: Zaid, Last: Khan
ID: 103, Age: 28, First: Sumit, Last: Mittal
Goodbye!