Apache Derby-빠른 가이드

Apache Derby는 R기분 좋은 Database Management SJava 프로그래밍 언어를 완전히 기반으로 (작성 / 구현 된) ystem. Apache Software Foundation에서 개발 한 오픈 소스 데이터베이스입니다.

Oracle은 JavaDB라는 이름으로 Apache Derby에 해당하는 것을 출시했습니다.

Apache Derby의 기능

다음은 Derby 데이터베이스의 주목할만한 기능입니다.

Platform independent − Derby는 데이터베이스가 데이터베이스와 동일한 이름을 가진 디렉토리 내의 디스크에있는 파일에 저장되는 온 디스크 데이터베이스 형식을 사용합니다.
No modifying data − 따라서 데이터를 수정하지 않고도 derby 데이터베이스를 다른 컴퓨터로 이동할 수 있습니다.
Transactional support − Derby는 데이터 무결성을 보장하는 트랜잭션을 완벽하게 지원합니다.
Including databases − 기존 / 기존 데이터베이스를 현재 더비 애플리케이션에 포함 할 수 있습니다.
Less space − Derby 데이터베이스는 설치 공간이 작습니다. 즉, 공간을 덜 차지하고 사용 및 배포가 쉽습니다.
Embed with Java Application− Derby는 Java 애플리케이션에 포함 할 수있는 임베디드 데이터베이스 엔진을 제공하며 애플리케이션과 동일한 JVM에서 실행됩니다. 드라이버를로드하기 만하면 데이터베이스가 시작되고 응용 프로그램과 함께 중지됩니다.

Apache Derby의 한계

다음은 Apache Derby의 한계입니다.

Derby는 BLOB 및 LONGVARCHAR와 같은 데이터 유형에 대한 인덱스를 지원하지 않습니다.
Derby에 디스크 공간이 충분하지 않으면 즉시 종료됩니다.

데이터 저장고

데이터를 저장하는 동안 Apache Derby는 다음과 같은 개념을 따릅니다. conglomerate. 여기에서 테이블의 데이터는 별도의 파일에 저장됩니다. 같은 방식으로 테이블의 각 인덱스도 별도의 파일에 저장됩니다. 따라서 데이터베이스의 모든 테이블 또는 인덱스에 대해 별도의 파일이 있습니다.

Apache Derby 라이브러리 / 구성 요소

Apache Derby 배포는 다양한 구성 요소를 제공합니다. 다운로드 한 아파치 배포판의 lib 폴더에서 다양한 구성 요소를 나타내는 jar 파일을 볼 수 있습니다.

Jar 파일	구성 요소	기술
derby.jar	데이터베이스 엔진 및 JDBC 드라이버	Apache Derby의 데이터베이스 엔진은 JDBC 및 SQL API를 지원하는 임베디드 관계형 데이터베이스 엔진입니다. 이는 또한 Java 애플리케이션을 사용하여 Derby와 통신 할 수있는 임베디드 드라이버로 작동합니다.
derbynet.jar derbyrun.jar	네트워크 서버	Apache Derby의 네트워크 서버는 클라이언트가 네트워크를 통해 Derby 서버에 연결할 수있는 클라이언트 서버 기능을 제공합니다.
derbyclient.jar	네트워크 클라이언트 JDBC 드라이버
derbytools.jar	명령 줄 도구	이 jar 파일에는 다음과 같은 도구가 들어 있습니다. sysinfo, ij, 및 dblook.
derbyoptionaltools.jar	선택적 명령 줄 유틸리티 (도구)	이 jar 파일은 선택적 도구를 제공합니다 : databaseMetaData 선택적 도구, foreignViews 선택적 도구, luceneSupport 선택적 도구, rawDBReader 선택적 도구, simpleJson 선택적 도구 등
derbyLocale_XX.jar	메시지를 현지화하는 Jar 파일	위에서 언급 한 jar 파일 외에도 여러 derbyLocale_XX.jar (es, fr, hu, it, ja 등)을 볼 수 있습니다. 이를 사용하여 Apache Derby의 메시지를 현지화 할 수 있습니다.

두 가지 모드, 즉 임베디드 모드와 서버 모드로 Apache 더비를 배포 할 수 있습니다.

임베디드 모드

Java 애플리케이션 (임베디드 드라이버 사용)을 사용하여 임베디드 모드에서 derby를 실행할 수 있습니다. 임베디드 모드에서 Derby를 배치하는 경우 데이터베이스 엔진은 Java 애플리케이션과 동일한 JVM에서 실행됩니다. 응용 프로그램과 함께 시작 및 중지됩니다. 이 응용 프로그램으로 만 데이터베이스에 액세스 할 수 있습니다.

서버 모드

서버 모드에서 derby는 서버에 액세스 요청을 보낼 수있는 애플리케이션 서버의 JVM에서 실행됩니다. 임베디드 모드와 달리 여러 애플리케이션 (java)은 서버에 요청을 보내고 데이터베이스에 액세스 할 수 있습니다.

다음 장에서는 Apache Derby를 다운로드하고 설치하는 방법에 대해 설명합니다.

Apache Derby 다운로드

Apache Derby 홈 페이지의 홈 페이지를 방문하십시오. https://db.apache.org/derby/. 다운로드 탭을 클릭하십시오.

최신 버전의 Apache Derby 링크를 선택하고 클릭합니다.

선택한 링크를 클릭하면 다음으로 리디렉션됩니다. Distributions아파치 더비 페이지. 여기서 관찰하면 derby는 배포판 즉 db-derby-bin, db-derbylib.zip, db-derby-lib-debug.zip 및 db-derby-src.zip을 제공합니다.

다운로드 db-derby-bin폴더. Apache Derby를 설치하려는 별도의 폴더에 해당 컨텐츠를 복사하십시오. (예 :C:\Derby)

이제 Derby와 함께 작업하려면

이미 설정했는지 확인하십시오. JAVA_HOME Java 설치 폴더의 bin 폴더 위치를 전달하여 변수를 지정하고 JAVA_HOME/bin PATH 변수에서.
새 환경 변수를 만듭니다. DERBY_HOME C : \ Derby 값으로.
db-derby-bin 배포판의 bin 폴더 (C : \ Derby \ bin으로 변경)에는 필요한 모든 jar 파일이 포함되어 있습니다.

논의한 바와 같이 Apache Derby는 다음 두 가지 방법으로 설치 / 배포 할 수 있습니다.

Embedded mode− 여기에서 Embedded Derby JDBC 드라이버를 사용하여 데이터베이스에 액세스해야합니다. Java 애플리케이션을 통해 더비를 시작하고 중지 할 수 있습니다. 데이터베이스 엔진과 애플리케이션은 모두 동일한 JVM에서 실행됩니다.
Network Server mode−이 모드에서는 Derby가 서버 시스템에 내장 된 일반적인 클라이언트 서버 방식으로 Derby에 액세스 할 수 있습니다. 그런 다음 다른 JVM (서버)에서 실행중인 클라이언트 시스템이 서버에 요청을 보내고 서버는 해당 요청에 응답합니다.

클라이언트는 서버의 동일한 시스템 시스템에있는 다른 JVM이거나 원격 시스템의 Java 응용 프로그램 일 수 있습니다.

임베디드 모드에서 Derby 설치

임베디드 모드에서 Apache Derby를 설치하려면 jar 파일을 포함하십시오. derby.jar CLASSPATH에서.

또는 다음을 실행하여 필수 jar 파일의 클래스 경로를 설정할 수 있습니다. setEmbeddedCP명령. 찾아보기bin Apache Derby의 디렉토리를 찾아 아래에 표시된대로이 파일을 실행하십시오.

C:\Users\MYUSER>cd %DERBY_HOME%/bin
C:\Derby\bin>setEmbeddedCP.bat
C:\Derby\bin>SET DERBY_HOME=C:\Derby
C:\Derby\bin>set
CLASSPATH=C:\Derby\lib\derby.jar;C:\Derby\lib\derbytools.jar;C:\Derby/lib/derby
optionaltools.jar;C:\Users\Tutorialspoint\Google
Drive\Office\Derby\derby_zip\New folder\db-derby-10.12.1.1-
bin\lib;C:\EXAMPLES_\Task\jars\*;C:\EXAMPLES\jars\mysql-connector-java-5.1.40-
bin.jar;C:\Users\Tutorialspoint\Google Drive\Office\37.Junit
Update\jars;C:\Program Files\Apache Software Foundation\Tomcat
8.5\lib\*;C:\Derby\lib\*;

Apache Derby를 설정 한 후 액세스하려면 임베디드 드라이버를 사용하여 Java 프로그램을 실행하십시오.

확인

다음을 사용하여 설정을 확인할 수 있습니다. ij 아래 표시된 도구-

C:\Derby\bin>ij
ij version 10.14
ij> connect 'jdbc:derby:SampleDB;create=true';
ij>

네트워크 서버 모드에서 Derby 설치

네트워크 서버 모드에서 Apache Derby를 설치하려면 다음을 포함해야합니다. derbynet.jar 과 derbytools.jar 파일을 CLASSPATH에 추가합니다.

또는 다음을 실행하여 필수 jar 파일의 클래스 경로를 설정할 수 있습니다. setNetworkServerCP명령. 찾아보기bin Apache Derby의 디렉토리를 찾아 아래에 표시된대로이 파일을 실행하십시오.

C:\Users\MYUSER>cd %DERBY_HOME%/bin
C:\Derby\bin>setNetworkServerCP.bat
C:\Derby\bin>SET DERBY_INSTALL=C:\Derby
C:\Derby\bin>set
CLASSPATH=C:\Derby\lib\derbynet.jar;C:\Derby\lib\derbytools.jar;C:\Derby/lib/de
rbyoptionaltools.jar;C:\Users\Tutorialspoint\Google
Drive\Office\Derby\derby_zip\New folder\db-derby-10.12.1.1-
bin\lib;C:\EXAMPLES_\Task\jars\*;C:\EXAMPLES\jars\mysql-connector-java-5.1.40-
bin.jar;C:\Users\Tutorialspoint\Google Drive\Office\37.Junit
Update\jars;C:\Program Files\Apache Software Foundation\Tomcat
8.5\lib\*;C:\Derby\lib\*;

서버 모드에서 Derby 시작

다음 명령을 실행하여 네트워크 서버를 시작할 수 있습니다. startNetworkServer. 찾아보기bin Apache Derby의 디렉토리를 찾아 아래에 표시된대로이 명령을 실행하십시오.

C:\Derby\bin>startNetworkServer
Fri Jan 04 11:20:30 IST 2019 : Security manager installed using the Basic
server security policy.
Fri Jan 04 11:20:30 IST 2019 : Apache Derby Network Server - 10.14.2.0 -
(1828579) started and ready to accept connections on port 1527

또는 다음을 사용하여 서버를 시작할 수 있습니다. derbyrun.jar 아래와 같이-

C:\Users\MYUSER>cd %DERBY_HOME%/lib
C:\Derby\lib>java -jar derbyrun.jar server start
Fri Jan 04 11:27:20 IST 2019: Security manager installed using the Basic server
security policy.
Fri Jan 04 11:27:21 IST 2019: Apache Derby Network Server - 10.14.2.0 -
(1828579) started and ready to accept connections on port 1527

네트워크 클라이언트

클라이언트에서 jar 파일을 추가하십시오. derbyclient.jar 과 derbytools.jarCLASSPATH에. 또는setNetworkClientCP 아래와 같이 명령-

C:\Users\MYUSER>cd %DERBY_HOME%/bin
C:\Derby\bin>setNetworkClientCP
C:\Derby\bin>SET DERBY_HOME=C:\Derby
C:\Derby\bin>set
CLASSPATH=C:\Derby\lib\derbyclient.jar;C:\Derby\lib\derbytools.jar;C:\Derby/lib
/derbyoptionaltools.jar;C:\Derby\lib\derby.jar;C:\Derby\lib\derbytools.jar;C:\D
erby/lib/derbyoptionaltools.jar;C:\Users\Tutorialspoint\Google
Drive\Office\Derby\derby_zip\New folder\db-derby-10.12.1.1-
bin\lib;C:\EXAMPLES_\Task\jars\*;C:\EXAMPLES\jars\mysql-connector-java-5.1.40-
bin.jar;C:\Users\Tutorialspoint\Google Drive\Office\37.Junit
Update\jars;C:\Program Files\Apache Software Foundation\Tomcat
8.5\lib\*;C:\Derby\lib\*;

그런 다음이 클라이언트에서 서버로 요청을 보낼 수 있습니다.

확인

다음을 사용하여 설정을 확인할 수 있습니다. ij 아래 표시된 도구-

C:\Derby\bin>ij
ij version 10.14
ij> connect 'jdbc:derby://localhost:1527/SampleDB;create=true';
ij>

Apache Derby Eclipse 환경

Eclipse로 작업하는 동안 필요한 모든 jar 파일의 빌드 경로를 설정해야합니다.

1 단계 : 프로젝트 생성 및 빌드 경로 설정

Eclipse를 열고 샘플 프로젝트를 만듭니다. 프로젝트를 마우스 오른쪽 버튼으로 클릭하고 옵션을 선택하십시오.Build Path -> Configure Build 아래 표시된 경로-

에서 Java Build Path 프레임 Libraries 탭에서 Add External JARs.

그리고 필요한 것을 선택하십시오 jar Derby 설치 폴더의 lib 폴더에있는 파일을 클릭하고 Apply and Close.

Apache Derby는 다음과 같은 도구를 제공합니다. sysinfo, ij 과, dblook.

sysinfo 도구

이 도구를 사용하여 Java 및 Derby 환경에 대한 정보를 얻을 수 있습니다.

Derby 설치 디렉토리의 bin 폴더를 탐색하고 아래와 같이 sysinfo 명령을 실행하십시오.

C:\Users\MY_USER>cd %DERBY_HOME%/bin
C:\Derby\bin>sysinfo

실행시 아래와 같이 Java 및 derby에 대한 시스템 정보를 제공합니다.

------------------ Java Information ------------------
Java Version: 1.8.0_101
Java Vendor: Oracle Corporation
Java home: C:\Program Files\Java\jdk1.8.0_101\jre
Java classpath: C:\Users\Tutorialspoint\Google
Drive\Office\Derby\derby_zip\New folder\db-derby-10.12.1.1-
bin\lib;C:\EXAMPLES_\Task\jars\*;C:\EXAMPLES\jars\mysql-connector-java-5.1.40-
bin.jar;C:\Users\Tutorialspoint\Google Drive\Office\37.Junit
Update\jars;C:\Program Files\Apache Software Foundation\Tomcat
8.5\lib\*;C:\Derby\lib\derby.jar;C:\Derby\lib\derbyclient.jar;C:\Derby\lib\derb
yLocale_cs.jar;C:\Derby\lib\derbyLocale_de_DE.jar;C:\Derby\lib\derbyLocale_es.j
ar;C:\Derby\lib\derbyLocale_fr.jar;C:\Derby\lib\derbyLocale_hu.jar;C:\Derby\lib
\derbyLocale_it.jar;C:\Derby\lib\derbyLocale_ja_JP.jar;C:\Derby\lib\derbyLocale
_ko_KR.jar;C:\Derby\lib\derbyLocale_pl.jar;C:\Derby\lib\derbyLocale_pt_BR.jar;C
:\Derby\lib\derbyLocale_ru.jar;C:\Derby\lib\derbyLocale_zh_CN.jar;C:\Derby\lib\
derbyLocale_zh_TW.jar;C:\Derby\lib\derbynet.jar;C:\Derby\lib\derbyoptionaltools
.jar;C:\Derby\lib\derbyrun.jar;C:\Derby\lib\derbytools.jar;;C:\Derby/lib/derby.
jar;C:\Derby/lib/derbynet.jar;C:\Derby/lib/derbyclient.jar;C:\Derby/lib/derbyto
ols.jar;C:\Derby/lib/derbyoptionaltools.jar
OS name: Windows 10
OS architecture: amd64
OS version: 10.0
Java user name: Tutorialspoint
Java user home: C:\Users\Tutorialspoint
Java user dir: C:\Derby\bin
java.specification.name: Java Platform API Specification
java.specification.version: 1.8
java.runtime.version: 1.8.0_101-b13
--------- Derby Information --------
[C:\Derby\lib\derby.jar] 10.14.2.0 - (1828579)
[C:\Derby\lib\derbytools.jar] 10.14.2.0 - (1828579)
[C:\Derby\lib\derbynet.jar] 10.14.2.0 - (1828579)
[C:\Derby\lib\derbyclient.jar] 10.14.2.0 - (1828579)
[C:\Derby\lib\derbyoptionaltools.jar] 10.14.2.0 - (1828579)
------------------------------------------------------
----------------- Locale Information -----------------
Current Locale : [English/United States [en_US]]
Found support for locale: [cs]
 version: 10.14.2.0 - (1828579)
Found support for locale: [de_DE]
 version: 10.14.2.0 - (1828579)
Found support for locale: [es]
 version: 10.14.2.0 - (1828579)
Found support for locale: [fr]
 version: 10.14.2.0 - (1828579)
Found support for locale: [hu]
 version: 10.14.2.0 - (1828579)
Found support for locale: [it]
 version: 10.14.2.0 - (1828579)
Found support for locale: [ja_JP]
 version: 10.14.2.0 - (1828579)
Found support for locale: [ko_KR]
 version: 10.14.2.0 - (1828579)
Found support for locale: [pl]
 version: 10.14.2.0 - (1828579)
Found support for locale: [pt_BR]
 version: 10.14.2.0 - (1828579)
Found support for locale: [ru]
 version: 10.14.2.0 - (1828579)
Found support for locale: [zh_CN]
 version: 10.14.2.0 - (1828579)
Found support for locale: [zh_TW]
 version: 10.14.2.0 - (1828579)
------------------------------------------------------
------------------------------------------------------

ijtool

이 도구를 사용하여 apache Derby의 스크립트 및 쿼리를 실행할 수 있습니다.

Derby 설치 디렉토리의 bin 폴더를 탐색하고 아래와 같이 ij 명령을 실행합니다.

C:\Users\MY_USER>cd %DERBY_HOME%/bin
C:\Derby\bin>ij

이것은 당신에게 줄 것입니다 ij shell 아래와 같이 derby 명령과 스크립트를 실행할 수 있습니다.

ij version 10.14
ij>

사용 help 명령을 사용하면이 쉘에서 지원하는 명령 목록을 얻을 수 있습니다.

C:\Derby\bin>cd %DERBY_HOME%/bin
C:\Derby\bin>ij
ij version 10.14
ij> help;
Supported commands include:
 PROTOCOL 'JDBC protocol' [ AS ident ];
 -- sets a default or named protocol
 DRIVER 'class for driver'; -- loads the named class
 CONNECT 'url for database' [ PROTOCOL namedProtocol ] [ AS connectionName ];
 -- connects to database URL
 -- and may assign identifier
 SET CONNECTION connectionName; -- switches to the specified connection
 SHOW CONNECTIONS; -- lists all connections
 AUTOCOMMIT [ ON | OFF ]; -- sets autocommit mode for the connection
 DISCONNECT [ CURRENT | connectionName | ALL ];
 -- drop current, named, or all connections;
-- the default is CURRENT
 SHOW SCHEMAS; -- lists all schemas in the current database
 SHOW [ TABLES | VIEWS | PROCEDURES | FUNCTIONS | SYNONYMS ] { IN schema };
 -- lists tables, views, procedures, functions or
synonyms
 SHOW INDEXES { IN schema | FROM table };
 -- lists indexes in a schema, or for a table
 SHOW ROLES; -- lists all defined roles in the database,
sorted
 SHOW ENABLED_ROLES; -- lists the enabled roles for the current
 -- connection (to see current role use
 -- VALUES CURRENT_ROLE), sorted
 SHOW SETTABLE_ROLES; -- lists the roles which can be set for the
 -- current connection, sorted
 DESCRIBE name; -- lists columns in the named table
 COMMIT; -- commits the current transaction
 ROLLBACK; -- rolls back the current transaction
 PREPARE name AS 'SQL-J text'; -- prepares the SQL-J text
 EXECUTE { name | 'SQL-J text' } [ USING { name | 'SQL-J text' } ] ;
 -- executes the statement with parameter
-- values from the USING result set row
 REMOVE name; -- removes the named previously prepared
statement
 RUN 'filename'; -- run commands from the named file
 ELAPSEDTIME [ ON | OFF ]; -- sets elapsed time mode for ij
 MAXIMUMDISPLAYWIDTH integerValue;
 -- sets the maximum display width for
-- each column to integerValue
 ASYNC name 'SQL-J text'; -- run the command in another thread
 WAIT FOR name; -- wait for result of ASYNC'd command
 HOLDFORCONNECTION; -- sets holdability for a connection to HOLD
 -- (i.e. ResultSet.HOLD_CURSORS_OVER_COMMIT)
 NOHOLDFORCONNECTION; -- sets holdability for a connection to NO HOLD
 -- (i.e. ResultSet.CLOSE_CURSORS_AT_COMMIT)
 GET [SCROLL INSENSITIVE] [WITH { HOLD | NOHOLD }] CURSOR name AS 'SQL-J
query';
 -- gets a cursor (JDBC result set) on the query
-- the default is a forward-only cursor with
holdability
 NEXT name; -- gets the next row from the named cursor
 FIRST name; -- gets the first row from the named scroll
cursor
 LAST name; -- gets the last row from the named scroll
cursor
 PREVIOUS name; -- gets the previous row from the named scroll
cursor
 ABSOLUTE integer name; -- positions the named scroll cursor at the
absolute row number
 -- (A negative number denotes position from the
last row.)
 RELATIVE integer name; -- positions the named scroll cursor relative to
the current row
 -- (integer is number of rows)
 AFTER LAST name; -- positions the named scroll cursor after the
last row
 BEFORE FIRST name; -- positions the named scroll cursor before the
first row
 GETCURRENTROWNUMBER name; -- returns the row number for the current
position of the named scroll cursor
 -- (0 is returned when the cursor is not
positioned on a row.)
 CLOSE name; -- closes the named cursor
 LOCALIZEDDISPLAY [ ON | OFF ];
 -- controls locale sensitive data representation
 EXIT; -- exits ij
 HELP; -- shows this message
Any unrecognized commands are treated as potential SQL-J commands and executed
directly.

dblooktool

이 도구는 데이터 정의 언어를 생성하는 데 사용됩니다.

Derby 설치 디렉토리의 bin 폴더를 탐색하고 dblook 아래와 같이 명령-

C:\Users\MY_USER>cd %DERBY_HOME%/bin
C:\Derby\bin>dblook -d myURL

어디, myURL DDL을 생성해야하는 데이터베이스의 연결 URL입니다.

이 장에서는 모든 Apache Derby SQL 문의 구문을 제공합니다.

모든 문은 SELECT, INSERT, UPDATE, DELETE, ALTER, DROP, CREATE, USE, SHOW와 같은 키워드로 시작하고 모든 문은 세미콜론 (;)으로 끝납니다.

Apache Derby의 SQL 문은 테이블 이름을 포함하여 대소 문자를 구분합니다.

CREATE 문

CREATE TABLE table_name (
   column_name1 column_data_type1 constraint (optional),
   column_name2 column_data_type2 constraint (optional),
   column_name3 column_data_type3 constraint (optional)
);

드롭 테이블

DROP TABLE table_name;

INSERT 문

INSERT INTO table_name VALUES (column_name1, column_name2, ...);

SELECT 문

SELECT column_name, column_name, ... FROM table_name;

UPDATE 문

UPDATE table_name
   SET column_name = value, column_name = value, ...
   WHERE conditions;

DELETE 문

DELETE FROM table_name WHERE condition;

DESCRIBE 성명

Describe table_name

SQL TRUNCATE TABLE 문

TRUNCATE TABLE table_name;

ALTER 문 – 열 추가

ALTER TABLE table_name ADD COLUMN column_name column_type;

ALTER 문 – 제약 추가

ALTER TABLE table_name ADD CONSTRAINT constraint_name constraint (column_name);

ALTER 문 – 열 삭제

ALTER TABLE table_name DROP COLUMN column_name;

ALTER 문 – 제약 조건 삭제

ALTER TABLE table_name DROP CONSTRAINT constraint_name;

WHERE 절

SELECT * from table_name WHERE condition;
or,
DELETE from table_name WHERE condition;
or,
UPDATE table_name SET column_name = value WHERE condition;

GROUP BY 절

SELECT column1, column2, . . . table_name GROUP BY column1, column2, . . .;

ORDER BY 절

SELECT * FROM table_name ORDER BY column_name ASC|DESC.

조항 있음

SELECT column1, column2 . . . from table_name GROUP BY column having
condition;

색인 생성

CTREATE INDEX index_name on table_name (column_name);

고유 색인 생성

CREATE UNIQUE INDEX index_name on table_name (column_name);

COMPOSITE 인덱스 생성

CREATE INDEX index_name on table_name (column_name1, column_name2);

인덱스 표시

SHOW INDEXES FROM table_name;

인덱스 삭제

DROP INDEX index_name;

데이터 유형은 모든 개체의 데이터 유형을 지정하는 속성입니다. 각 열, 변수 및 표현식에는 관련 데이터 유형이 있습니다. 테이블을 생성하는 동안 이러한 데이터 유형을 사용할 수 있습니다. 요구 사항에 따라 테이블 열의 데이터 유형을 선택할 수 있습니다.

Derby Server는 아래에 나열된대로 사용할 수있는 여러 데이터 유형 범주를 제공합니다.

정수 숫자 데이터 유형

다음은 정수 숫자 데이터 유형의 목록입니다-

데이터 형식	크기	에서	에
SMALLINT	2 바이트	-32768	32767
정수	4 바이트	-2,147,483,648	2,147,483,647
BIGINT	8 바이트	-9223372036854775808	9223372036854775808

대략적인 숫자 데이터 유형

다음은 대략적인 숫자 데이터 유형의 목록입니다-

데이터 형식	크기	에서	에
레알	4 바이트	-3.40E + 38	3.40E + 38
이중 정밀도	8 바이트	-1.79E + 308	1.79E + 308
흙손		-1.79E + 308	1.79E + 308

정확한 숫자 데이터 유형

다음은 정확한 숫자 데이터 유형의 목록입니다-

데이터 형식	에서	에
소수	-10 ^ 38 +1	10 ^ 38 -1
숫자	-10 ^ 38 +1	10 ^ 38 -1

CREATE TABLE 문은 Derby 데이터베이스에서 새 테이블을 만드는 데 사용됩니다.

통사론

다음은 CREATE 문의 구문입니다.

CREATE TABLE table_name (
   column_name1 column_data_type1 constraint (optional),
   column_name2 column_data_type2 constraint (optional),
   column_name3 column_data_type3 constraint (optional)
);

Apache Derby에서 테이블을 만드는 또 다른 방법은 쿼리를 사용하여 열 이름과 데이터 유형을 지정할 수 있다는 것입니다. 이에 대한 구문은 다음과 같습니다.

CREATE TABLE table_name AS SELECT * FROM desired_table WITH NO DATA;

예

다음 SQL 문은 Student 4 개의 열이 있으며 여기서 id는 기본 키이며 자동 생성됩니다.

ij> CREATE TABLE Student (
   Id INT NOT NULL GENERATED ALWAYS AS IDENTITY,
   Age INT NOT NULL,
   First_Name VARCHAR(255),
   last_name VARCHAR(255),
   PRIMARY KEY (Id)
);
> > > > > > > 0 rows inserted/updated/deleted

DESCRIBE 명령은 테이블이있는 경우 열과 세부 사항을 나열하여 지정된 테이블을 설명합니다. 이 명령을 사용하여 테이블이 생성되었는지 확인할 수 있습니다.

ij> DESCRIBE Student;
COLUMN_NAME |TYPE_NAME |DEC&|NUM&|COLUM&|COLUMN_DEF|CHAR_OCTE&|IS_NULL&
------------------------------------------------------------------------------
ID |INTEGER |0 |10 |10 |AUTOINCRE&|NULL |NO
AGE |INTEGER |0 |10 |10 |NULL |NULL |NO
FIRST_NAME |VARCHAR |NULL|NULL|255 |NULL |510 |YES
LAST_NAME |VARCHAR |NULL|NULL|255 |NULL |510 |YES
4 rows selected

JDBC 프로그램을 사용하여 테이블 생성

이 섹션에서는 JDBC 애플리케이션을 사용하여 Apache Derby 데이터베이스에서 테이블을 만드는 방법을 설명합니다.

네트워크 클라이언트를 사용하여 Derby 네트워크 서버를 요청하려면 서버가 실행 중인지 확인하십시오. 네트워크 클라이언트 드라이버의 클래스 이름은 다음과 같습니다.org.apache.derby.jdbc.ClientDriver URL은 jdbc : derby : // localhost : 1527 / DATABASE_NAME; create = true; user = USER_NAME; passw ord = PASSWORD "입니다.

Apache Derby에서 테이블을 생성하려면 아래 단계를 따르십시오.

1 단계 : 드라이버 등록

데이터베이스와 통신하려면 먼저 드라이버를 등록해야합니다. 그만큼forName() 수업 방법, Class클래스 이름을 나타내는 String 값을 받아 메모리에로드하면 자동으로 등록됩니다. 이 방법을 사용하여 드라이버를 등록하십시오.

2 단계 : 연결하기

일반적으로 데이터베이스와 통신하기 위해 수행하는 첫 번째 단계는 데이터베이스에 연결하는 것입니다. 그만큼Connection클래스는 데이터베이스 서버와의 물리적 연결을 나타냅니다. 다음을 호출하여 연결 개체를 만들 수 있습니다.getConnection() 의 방법 DriverManager수업. 이 방법을 사용하여 연결을 만듭니다.

3 단계 : 문 개체 만들기

당신은 Statement 또는 PreparedStatement or, CallableStatement데이터베이스에 SQL 문을 보내는 개체. 방법을 사용하여 만들 수 있습니다.createStatement(), prepareStatement() and, prepareCall()각기. 적절한 방법을 사용하여 이러한 개체 중 하나를 만듭니다.

4 단계 : 쿼리 실행

문을 만든 후에는 실행해야합니다. 그만큼Statement 클래스는 다음과 같은 쿼리를 실행하는 다양한 방법을 제공합니다. execute()둘 이상의 결과 집합을 반환하는 문을 실행하는 메서드입니다. 그만큼executeUpdate()메소드는 INSERT, UPDATE, DELETE와 같은 쿼리를 실행합니다. 그만큼executeQuery() 메소드를 데이터 등을 반환하는 결과로 가져옵니다.이 메소드 중 하나를 사용하고 이전에 만든 명령문을 실행합니다.

예

다음 JDBC 예제는 JDBC 프로그램을 사용하여 Apache Derby에서 테이블을 작성하는 방법을 보여줍니다. 여기서는 임베디드 드라이버를 사용하여 sampleDB (존재하지 않는 경우 생성)라는 데이터베이스에 연결합니다.

import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.SQLException;
import java.sql.Statement;
public class CreateTable {
   public static void main(String args[]) throws Exception {
      //Registering the driver
      Class.forName("org.apache.derby.jdbc.EmbeddedDriver");
      //Getting the Connection object
      String URL = "jdbc:derby:sampleDB;create=true";
      Connection conn = DriverManager.getConnection(URL);

      //Creating the Statement object
      Statement stmt = conn.createStatement();
 
      //Executing the query
      String query = "CREATE TABLE Employees( "
         + "Id INT NOT NULL GENERATED ALWAYS AS IDENTITY, "
         + "Name VARCHAR(255), "
         + "Salary INT NOT NULL, "
         + "Location VARCHAR(255), "
         + "PRIMARY KEY (Id))";
         stmt.execute(query);
         System.out.println("Table created");
   }
}

산출

위의 프로그램을 실행하면 다음과 같은 출력이 표시됩니다.

Table created

DROP TABLE 문은 모든 트리거, 제약 조건, 권한을 포함하여 기존 테이블을 제거하는 데 사용됩니다.

통사론

다음은 DROP TABLE 문의 구문입니다.

ij> DROP TABLE table_name;

예

데이터베이스에 Student라는 테이블이 있다고 가정합니다. 다음 SQL 문은 Student라는 테이블을 삭제합니다.

ij> DROP TABLE Student;
0 rows inserted/updated/deleted

설명하려고하면 테이블을 제거 했으므로 다음과 같은 오류가 발생합니다.

ij> DESCRIBE Student;
IJ ERROR: No table exists with the name STUDENT

JDBC 프로그램을 사용하여 테이블 삭제

이 섹션에서는 JDBC 애플리케이션을 사용하여 Apache Derby 데이터베이스에서 테이블을 삭제하는 방법을 설명합니다.

네트워크 클라이언트를 사용하여 Derby 네트워크 서버를 요청하려면 서버가 실행 중인지 확인하십시오. 네트워크 클라이언트 드라이버의 클래스 이름은 org.apache.derby.jdbc.ClientDriver이고 URL은 jdbc : derby : // localhost : 1527입니다./DATABASE_NAME;create = true; user =USER_NAME; passw ord =PASSWORD"

Apache Derby에서 테이블을 삭제하려면 아래 단계를 따르십시오.

1 단계 : 드라이버 등록

데이터베이스와 통신하려면 먼저 드라이버를 등록해야합니다. 그만큼forName() 수업 방법 Class클래스 이름을 나타내는 String 값을 받아 메모리에로드하면 자동으로 등록됩니다. 이 방법을 사용하여 드라이버를 등록하십시오.

2 단계 : 연결하기

3 단계 : 문 개체 만들기

당신은 Statement 또는 PreparedStatement 또는, CallableStatement데이터베이스에 SQL 문을 보내는 개체. 방법을 사용하여 만들 수 있습니다.createStatement(), prepareStatement() and, prepareCall()각기. 적절한 방법을 사용하여 이러한 개체 중 하나를 만듭니다.

4 단계 : 쿼리 실행

예

다음 JDBC 예제는 JDBC 프로그램을 사용하여 Apache Derby에서 테이블을 삭제하는 방법을 보여줍니다. 여기서는 임베디드 드라이버를 사용하여 sampleDB (존재하지 않는 경우 생성)라는 데이터베이스에 연결합니다.

import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.Statement;
public class DropTable {
   public static void main(String args[]) throws Exception {
      //Registering the driver
      Class.forName("org.apache.derby.jdbc.EmbeddedDriver");

      //Getting the Connection object
      String URL = "jdbc:derby:sampleDB;create=true";
      Connection conn = DriverManager.getConnection(URL);

      //Creating the Statement object
      Statement stmt = conn.createStatement();

      //Executing the query
      String query = "DROP TABLE Employees";
      stmt.execute(query);
      System.out.println("Table dropped");
   }
}

산출

위의 프로그램을 실행하면 다음과 같은 출력이 나타납니다.

Table dropped

Apache Derby-데이터 삽입

삽입 쿼리는 데이터를 삽입합니다. new records, 테이블에.

통사론

다음은 INSERT 문의 기본 구문입니다-

ij>INSERT INTO table_name VALUES (column_name1, column_name2, ...);

여기서 column1, column2는 삽입 할 행의 열 값입니다.

예

다음 SQL INSERT 문은 Student 테이블에 새 행을 삽입하여 열에 값을 삽입합니다. id, age, first name 과, last name.

SQL> INSERT INTO Student VALUES (101, 20, 'Zara', 'Ali');

구문 2

또는 아래와 같이 열 이름을 언급하여 두 개의 특정 열을 삽입 할 수 있습니다.

ij>INSERT INTO table_name VALUES (column_name1, column_name2, ...) VALUES
(value1, value2, ...);

Note− Apache Derby는 생성 된 열의 값을 자동으로 계산합니다. 예를 들어이 자습서의 앞부분에서 만든 student 테이블의 id 열에 대한 값을 전달할 필요가 없습니다. 테이블에 생성 된 열이있는 경우syntax2.

예

ij> INSERT INTO Student(Age, First_Name, Last_Name) VALUES (21, 'Sucharitha' , 'Tyagi');
1 row inserted/updated/deleted

그리고 다음과 같이 하나의 문을 사용하여 두 행을 삽입 할 수도 있습니다.

ij>INSERT INTO Student(Age, First_Name, Last_Name) VALUES (20, 'Amit',
'Bhattacharya'), (22, 'Rahul', 'Desai');
2 rows inserted/updated/deleted

SELECT 명령을 사용하여 테이블의 내용을 확인할 수 있습니다 (이 명령은이 자습서의 뒷부분에서 설명합니다).

구문 3

다음과 같이 삽입 문에서 다른 쿼리를 사용할 수 있습니다.

INSERT INTO table_Name Query

예

다음과 같은 테이블이 있다고 가정합니다. First_Year Student 테이블에서와 유사한 열과 함께 아래 표시된 데이터베이스에서-

ID |AGE |FIRST_NAME |LAST_NAME
-----------------------------------------------------------------
1 |20 |Raju |Pendyala
2 |21 |Bhargav |Prayaga
3 |22 |Deepthi |Yerramilli

위의 구문을 사용하여이 테이블의 값을 student 테이블에 삽입 할 수 있습니다.

ij> INSERT INTO Student (Age, First_Name, Last_Name)
 SELECT Age, First_Name, Last_Name FROM First_Year;
> 3 rows inserted/updated/deleted

위의 모든 삽입 문을 실행하면 Student 테이블은 다음과 같습니다.

ID |AGE |FIRST_NAME |LAST_NAME
-------------------------------------------------------------
1 |21 |Sucharitha |Tyagi
2 |20 |Amit |Bhattacharya
3 |22 |Rahul |Desai
4 |20 |Raju |Pendyala
5 |21 |Bhargav |Prayaga
6 |22 |Deepthi |Yerramilli

JDBC 프로그램을 사용하여 데이터 삽입

이 섹션에서는 JDBC 애플리케이션을 사용하여 Apache Derby 데이터베이스의 테이블에 데이터를 삽입하는 방법을 설명합니다.

네트워크 클라이언트를 사용하여 Derby 네트워크 서버를 요청하려면 서버가 실행 중인지 확인하십시오. 네트워크 클라이언트 드라이버의 클래스 이름은 org.apache.derby.jdbc.ClientDriver이고 URL은 jdbc : derby : // localhost : 1527 /입니다.DATABASE_NAME;create = true; user =USER_NAME;passw ord =PASSWORD"

Apache Derby의 테이블에 데이터를 삽입하려면 아래 단계를 따르십시오.

1 단계 : 드라이버 등록

2 단계 : 연결하기

3 단계 : 문 개체 만들기

당신은 Statement 또는 PreparedStatement or, CallableStatement데이터베이스에 SQL 문을 보내는 개체. 방법을 사용하여 만들 수 있습니다.createStatement(), prepareStatement() 과, prepareCall()각기. 적절한 방법을 사용하여 이러한 개체를 만듭니다.

4 단계 : 쿼리 실행

문을 만든 후에는 실행해야합니다. 그만큼Statement 클래스는 다음과 같은 쿼리를 실행하는 다양한 방법을 제공합니다. execute() 둘 이상의 결과 집합을 반환하는 문을 실행하는 메서드입니다.

그만큼 executeUpdate()메소드는 INSERT, UPDATE, DELETE와 같은 쿼리를 실행합니다. 그만큼executeQuery() 메소드를 데이터 등을 반환하는 결과로 가져옵니다.이 메소드 중 하나를 사용하고 이전에 만든 명령문을 실행합니다.

예

다음 JDBC 예제는 JDBC 프로그램을 사용하여 Apache Derby의 테이블에 데이터를 삽입하는 방법을 보여줍니다. 여기서는 임베디드 드라이버를 사용하여 sampleDB (존재하지 않는 경우 생성)라는 데이터베이스에 연결합니다.

import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.SQLException;
import java.sql.Statement;
public class InsertData {
   public static void main(String args[]) throws Exception {
      //Registering the driver
      Class.forName("org.apache.derby.jdbc.EmbeddedDriver");
      //Getting the Connection object
      String URL = "jdbc:derby:SampleDB;create=true";
      Connection conn = DriverManager.getConnection(URL);

      //Creating the Statement object
      Statement stmt = conn.createStatement();

      //Creating a table and populating
      String query = "CREATE TABLE Employees("
         + "Id INT NOT NULL GENERATED ALWAYS AS IDENTITY, "
         + "Name VARCHAR(255), Salary INT NOT NULL, "
         + "Location VARCHAR(255), "
         + "PRIMARY KEY (Id))";
      //Executing the query
      String query = "INSERT INTO Employees("
         + "Name, Salary, Location) VALUES "
         + "('Amit', 30000, 'Hyderabad'), "
         + "('Kalyan', 40000, 'Vishakhapatnam'), "
         + "('Renuka', 50000, 'Delhi'), "
         + "('Archana', 15000, 'Mumbai'), "
         + "('Trupthi', 45000, 'Kochin'), "
         + "('Suchatra', 33000, 'Pune'), "
         + "('Rahul', 39000, 'Lucknow'), "
         + "('Trupti', 45000, 'Kochin')";
      stmt.execute(query);
      System.out.println("Values inserted");
   }
}

산출

위의 프로그램을 실행하면 다음과 같은 출력이 나타납니다.

Values inserted

Apache Derby-데이터 검색

SELECT 문은 테이블에서 데이터를 검색하는 데 사용됩니다. 결과 집합이라는 테이블 형식으로 데이터를 반환합니다.

통사론

다음은 SELECT 문의 구문입니다-

ij> SELECT column_name, column_name, ... FROM table_name;
Or,
Ij>SELECT * from table_name

예

아래와 같이 데이터베이스에 Employees라는 테이블이 있다고 가정 해 보겠습니다.

ij> CREATE TABLE Employees (
   Id INT NOT NULL GENERATED ALWAYS AS IDENTITY,
   Name VARCHAR(255),
   Salary INT NOT NULL,
   Location VARCHAR(255),
   PRIMARY KEY (Id)
);
> > > > > > > 0 rows inserted/updated/deleted

그리고 아래와 같이 4 개의 레코드를 삽입했습니다.

ij> INSERT INTO Employees (Name, Salary, Location) VALUES
 ('Amit', 30000, 'Hyderabad'),
 ('Kalyan', 40000, 'Vishakhapatnam'),
 ('Renuka', 50000, 'Delhi'),
 ('Archana', 15000, 'Mumbai');
> > > > 4 rows inserted/updated/deleted

다음 SQL 문은 테이블에있는 모든 직원의 이름, 나이 및 급여 세부 정보를 검색합니다.

ij> SELECT Id, Name, Salary FROM Employees;

이 쿼리의 출력은 다음과 같습니다.

ID |NAME |SALARY
------------------------------------------------------------------------
1 |Amit |30000
2 |Kalyan |40000
3 |Renuka |50000
4 |Archana |15000
4 rows selected

이 테이블의 모든 레코드를 한 번에 가져 오려면 열 이름 대신 *를 사용하십시오.

ij> select * from Employees;

이것은 다음 결과를 생성합니다-

ID |NAME |SALARY |LOCATION
------------------------------------------------------------------
1 |Amit |30000 |Hyderabad
2 |Kalyan |40000 |Vishakhapatnam
3 |Renuka |50000 |Delhi
4 |Archana |15000 |Mumbai
4 rows selected

JDBC 프로그램을 사용하여 데이터 검색

이 섹션에서는 JDBC 애플리케이션을 사용하여 Apache Derby 데이터베이스의 테이블에서 데이터를 검색하는 방법을 설명합니다.

네트워크 클라이언트를 사용하여 Derby 네트워크 서버를 요청하려면 서버가 실행 중인지 확인하십시오. 네트워크 클라이언트 드라이버의 클래스 이름은 org.apache.derby.jdbc.ClientDriver이고 URL은 jdbc : derby : // localhost : 1527 /입니다.DATABASE_NAME; create = true; user =USER_NAME; passw ord =PASSWORD"

Apache Derby의 테이블에서 데이터를 검색하려면 아래 단계를 따르십시오.

1 단계 : 드라이버 등록

2 단계 : 연결하기

3 단계 : 문 개체 만들기

당신은 Statement 또는 PreparedStatement 또는, CallableStatement데이터베이스에 SQL 문을 보내는 개체. 방법을 사용하여 만들 수 있습니다.createStatement(), prepareStatement() 과, prepareCall()각기. 적절한 방법을 사용하여 이러한 개체 중 하나를 만듭니다.

4 단계 : 쿼리 실행

예

다음 JDBC 예제는 JDBC 프로그램을 사용하여 Apache Derby의 테이블에서 데이터를 검색하는 방법을 보여줍니다. 여기서는 임베디드 드라이버를 사용하여 sampleDB (존재하지 않는 경우 생성)라는 데이터베이스에 연결합니다.

그만큼 executeQuery() 메소드는 ResultSet명령문의 결과를 보유하는 객체입니다. 처음에는 결과 세트 포인터가 첫 번째 레코드에 있으며, 다음을 사용하여 ResultSet 오브젝트의 컨텐츠를 인쇄 할 수 있습니다.next() 과 getXXX() 행동 양식.

import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;
public class RetrieveData {
   public static void main(String args[]) throws SQLException,
      ClassNotFoundException {
      //Registering the driver
      Class.forName("org.apache.derby.jdbc.EmbeddedDriver");
      //Getting the Connection object
      String URL = "jdbc:derby:sampleDB;create=true";
      Connection conn = DriverManager.getConnection(URL);

      //Creating the Statement object
      4Statement stmt = conn.createStatement();

      //Creating a table and populating it
      String query = "CREATE TABLE Employees("
         + "Id INT NOT NULL GENERATED ALWAYS AS IDENTITY, "
         + "Name VARCHAR(255), Salary INT NOT NULL, "
         + "Location VARCHAR(255), "
         + "PRIMARY KEY (Id))";
      String query = "INSERT INTO Employees("
         + "Name, Salary, Location) VALUES "
         + "('Amit', 30000, 'Hyderabad'), "
         + "('Kalyan', 40000, 'Vishakhapatnam'), "
         + "('Renuka', 50000, 'Delhi'), "
         + "('Archana', 15000, 'Mumbai'), "
         + "('Trupthi', 45000, 'Kochin'), "
         + "('Suchatra', 33000, 'Pune'), "
         + "('Rahul', 39000, 'Lucknow'), "
         + "('Trupti', 45000, 'Kochin')";
      //Executing the query
      String query = "SELECT Id, Name, Salary FROM Employees";
      ResultSet rs = stmt.executeQuery(query);
      while(rs.next()) {
         System.out.println("Id: "+rs.getString("Id"));
         System.out.println("Name: "+rs.getString("Name"));
         System.out.println("Salary: "+rs.getString("Salary"));
         System.out.println(" ");
      }
   }
}

산출

위의 프로그램을 실행하면 다음과 같은 출력이 표시됩니다.

Id: 1
Name: Amit
Salary: 30000

Id: 2
Name: Kalyan
Salary: 43000

Id: 3
Name: Renuka
Salary: 50000

Id: 4
Name: Archana
Salary: 15000

Id: 5
Name: Trupthi
Salary: 45000

Id: 6
Name: Suchatra
Salary: 33000

Id: 7
Name: Rahul
Salary: 39000

Apache Derby-데이터 업데이트

UPDATE 문은 테이블의 데이터를 업데이트하는 데 사용됩니다. Apache Derby는 두 가지 유형의 업데이트 (구문)를 제공합니다.searched 업데이트 및 positioned 최신 정보.

검색된 UPDATE 문은 테이블의 지정된 모든 열을 업데이트합니다.

통사론

다음은 UPDATE 쿼리의 구문입니다-

ij> UPDATE table_name
 SET column_name = value, column_name = value, ...
 WHERE conditions;

WHERE 절은 =,! =, <,>, <= 및> =와 같은 비교 연산자와 BETWEEN 및 LIKE 연산자를 사용할 수 있습니다.

예

아래와 같이 4 개의 레코드가있는 데이터베이스에 Employee 테이블이 있다고 가정합니다.

ID |NAME |SALARY |LOCATION
----------------------------------------------------------
1 |Amit |30000 |Hyderabad
2 |Kalyan |40000 |Vishakhapatnam
3 |Renuka |50000 |Delhi
4 |Archana |15000 |Mumbai

다음 SQL UPDATE 문은 이름이 Kaylan 인 직원의 위치와 급여를 업데이트합니다.

ij> UPDATE Employees SET Location = 'Chennai', Salary = 43000 WHERE Name =
'Kalyan';
1 rows inserted/updated/deleted

Employees 테이블의 내용을 가져 오면 UPDATE 쿼리에 의해 수행 된 변경 사항을 관찰 할 수 있습니다.

ij> select * from Employees;
ID |NAME |SALARY |LOCATION
----------------------------------------------------------
1 |Amit |30000 |Hyderabad 
2 |Kalyan |43000 |Chennai
3 |Renuka |50000 |Delhi
4 |Archana |15000 |Mumbai
4 rows selected

JDBC 프로그램을 사용하여 데이터 업데이트

이 섹션에서는 JDBC 애플리케이션을 사용하여 Apache Derby 데이터베이스에서 테이블의 기존 레코드를 업데이트하는 방법을 설명합니다.

네트워크 클라이언트를 사용하여 Derby 네트워크 서버를 요청하려면 서버가 실행 중인지 확인하십시오. 네트워크 클라이언트 드라이버의 클래스 이름은 org.apache.derby.jdbc.ClientDriver이고 URL은 jdbc : derby : // localhost : 1527 /입니다.DATABASE_NAME; create = true; user =USER_NAME; passw ord =PASSWORD"

Apache Derby에서 테이블의 기존 레코드를 업데이트하려면 아래 단계를 따르십시오.

1 단계 : 드라이버 등록

2 단계 : 연결하기

일반적으로 데이터베이스와 통신하기 위해 수행하는 첫 번째 단계는 데이터베이스에 연결하는 것입니다. Connection 클래스는 데이터베이스 서버와의 물리적 연결을 나타냅니다. 다음을 호출하여 연결 개체를 만들 수 있습니다.getConnection() 의 방법 DriverManager수업. 이 방법을 사용하여 연결을 만듭니다.

3 단계 : 문 개체 만들기

당신은 Statement 또는 PreparedStatement or, CallableStatement데이터베이스에 SQL 문을 보내는 개체. 방법을 사용하여 만들 수 있습니다.createStatement(), prepareStatement() 과, prepareCall()각기. 적절한 방법을 사용하여 이러한 개체 중 하나를 만듭니다.

4 단계 : 쿼리 실행

문을 만든 후에는 실행해야합니다. 그만큼Statement 클래스는 다음과 같은 쿼리를 실행하는 다양한 방법을 제공합니다. execute()둘 이상의 결과 집합을 반환하는 문을 실행하는 메서드입니다. 그만큼executeUpdate()메소드는 INSERT, UPDATE, DELETE와 같은 쿼리를 실행합니다. 그만큼executeQuery()메서드는 데이터를 반환합니다. 이 방법 중 하나를 사용하고 이전에 만든 문을 실행합니다.

예

다음 JDBC 예제는 JDBC 프로그램을 사용하여 Apache Derby에서 테이블의 기존 레코드를 업데이트하는 방법을 보여줍니다. 여기서는 임베디드 드라이버를 사용하여 sampleDB (존재하지 않는 경우 생성)라는 데이터베이스에 연결합니다.

import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.SQLException;
import java.sql.Statement;
public class UpdateData {
   public static void main(String args[]) throws Exception {
      //Registering the driver
      Class.forName("org.apache.derby.jdbc.EmbeddedDriver");
      //Getting the Connection object
      String URL = "jdbc:derby:sampleDB;create=true";
      Connection conn = DriverManager.getConnection(URL);

      //Creating the Statement object
      Statement stmt = conn.createStatement();

      //Creating a table and populating it
      String query = "CREATE TABLE Employees("
         + "Id INT NOT NULL GENERATED ALWAYS AS IDENTITY, "
         + "Name VARCHAR(255), Salary INT NOT NULL, "
         + "Location VARCHAR(255), "
         + "PRIMARY KEY (Id))";
      String query = "INSERT INTO Employees("
         + "Name, Salary, Location) VALUES "
         + "('Amit', 30000, 'Hyderabad'), "
         + "('Kalyan', 40000, 'Vishakhapatnam'), "
         + "('Renuka', 50000, 'Delhi'), "
         + "('Archana', 15000, 'Mumbai'), "
         + "('Trupthi', 45000, 'Kochin'), "
         + "('Suchatra', 33000, 'Pune'), "
         + "('Rahul', 39000, 'Lucknow'), "
         + "('Trupti', 45000, 'Kochin')";
      //Executing the query
      String query = "UPDATE Employees SET Location = 'Chennai', Salary = 43000 WHERE
         Name = 'Kalyan'";
      int num = stmt.executeUpdate(query);
      System.out.println("Number of records updated are: "+num);
   }
}

산출

위의 프로그램을 실행하면 다음과 같은 출력이 나타납니다.

Number of records updated are: 1

Apache Derby-데이터 삭제

DELETE 문은 테이블의 행을 삭제하는 데 사용됩니다. UPDATE 문과 마찬가지로 Apache Derby는 두 가지 유형의 삭제 (구문)를 제공합니다.searched 삭제 및 positioned 지우다.

검색된 delete 문은 테이블의 지정된 모든 열을 삭제합니다.

통사론

DELETE 문의 구문은 다음과 같습니다.

ij> DELETE FROM table_name WHERE condition;

예

아래에 표시된 것처럼 5 개의 레코드가있는 employee라는 테이블이 있다고 가정 해 보겠습니다.

ID |NAME |SALARY |LOCATION
----------------------------------------------------------------------------
1 |Amit |30000 |Hyderabad
2 |Kalyan |40000 |Vishakhapatnam
3 |Renuka |50000 |Delhi
4 |Archana |15000 |Mumbai
5 |Trupti |45000 |Kochin
5 rows selected

다음 SQL DELETE 문은 이름이 Trupti 인 레코드를 삭제합니다.

ij> DELETE FROM Employees WHERE Name = 'Trupti';
1 row inserted/updated/deleted

Employees 테이블의 내용을 얻으면 아래와 같이 4 개의 레코드 만 볼 수 있습니다.

ID |NAME |SALARY |LOCATION
----------------------------------------------------------------------------
1 |Amit |30000 |Hyderabad
2 |Kalyan |40000 |Vishakhapatnam
3 |Renuka |50000 |Delhi
4 |Archana |15000 |Mumbai 
4 rows selected

테이블의 모든 레코드를 삭제하려면 where 절없이 동일한 쿼리를 실행합니다.

ij> DELETE FROM Employees;
4 rows inserted/updated/deleted

이제 Employee 테이블의 내용을 얻으려고하면 아래와 같이 빈 테이블이 표시됩니다.

ij> select * from employees;
ID |NAME |SALARY |LOCATION
--------------------------------------------------------
0 rows selected

JDBC 프로그램을 사용하여 데이터 삭제

이 섹션에서는 JDBC 애플리케이션을 사용하여 Apache Derby 데이터베이스에서 테이블의 기존 레코드를 삭제하는 방법을 설명합니다.

Apache Derby에서 테이블의 기존 레코드를 삭제하려면 아래 단계를 따르십시오 ./p>

1 단계 : 드라이버 등록

먼저 데이터베이스와 통신하기 위해 드라이버를 등록해야합니다. 그만큼forName() 수업 방법 Class클래스 이름을 나타내는 String 값을 받아 메모리에로드하면 자동으로 등록됩니다. 이 방법을 사용하여 드라이버를 등록하십시오.

2 단계 : 연결하기

3 단계 : 문 개체 만들기

4 단계 : 쿼리 실행

문을 만든 후에는 실행해야합니다. 그만큼Statement 클래스는 다음과 같은 쿼리를 실행하는 다양한 방법을 제공합니다. execute()둘 이상의 결과 집합을 반환하는 문을 실행하는 메서드입니다. 그만큼executeUpdate()메소드는 INSERT, UPDATE, DELETE와 같은 쿼리를 실행합니다. 그만큼executeQuery()데이터를 반환하는 메서드 결과. 이 방법 중 하나를 사용하고 이전에 만든 문을 실행합니다.

예

다음 JDBC 예제는 JDBC 프로그램을 사용하여 Apache Derby에서 테이블의 기존 레코드를 삭제하는 방법을 보여줍니다. 여기서는 임베디드 드라이버를 사용하여 sampleDB (존재하지 않는 경우 생성)라는 데이터베이스에 연결합니다.

import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.SQLException;
import java.sql.Statement;
public class DeleteData {
   public static void main(String args[]) throws Exception {
      //Registering the driver
      Class.forName("org.apache.derby.jdbc.EmbeddedDriver");
      //Getting the Connection object
      String URL = "jdbc:derby:sampleDB;create=true";
      Connection conn = DriverManager.getConnection(URL);

      //Creating the Statement object
      Statement stmt = conn.createStatement();
      //Creating a table and populating it
      String query = "CREATE TABLE Employees("
         + "Id INT NOT NULL GENERATED ALWAYS AS IDENTITY, "
         + "Name VARCHAR(255), Salary INT NOT NULL, "
         + "Location VARCHAR(255), "
         + "PRIMARY KEY (Id))";
      String query = "INSERT INTO Employees("
         + "Name, Salary, Location) VALUES "
         + "('Amit', 30000, 'Hyderabad'), "
         + "('Kalyan', 40000, 'Vishakhapatnam'), "
         + "('Renuka', 50000, 'Delhi'), "
         + "('Archana', 15000, 'Mumbai'), "
         + "('Trupthi', 45000, 'Kochin'), "
         + "('Suchatra', 33000, 'Pune'), "
         + "('Rahul', 39000, 'Lucknow'), "
         + "('Trupthi', 45000, 'Kochin')";
      //Executing the query
      String query = "DELETE FROM Employees WHERE Name = 'Trupthi'";
      int num = stmt.executeUpdate(query);
      System.out.println("Number of records deleted are: "+num);
   }
}

산출

위의 프로그램을 실행하면 다음과 같은 출력이 나타납니다.

Number of records deleted are: 1

Apache Derby-Where 절

WHERE 절은 SELECT, DELETE 또는 UPDATE 문에서 작업을 수행해야하는 행을 지정하는 데 사용됩니다. 일반적으로이 절 뒤에는 부울 값을 반환하는 조건 또는식이옵니다. 선택, 삭제 또는 업데이트 작업은 주어진 조건을 충족하는 행에서만 수행됩니다.

ij> SELECT * from table_name WHERE condition;
or,
ij> DELETE from table_name WHERE condition;
or,
ij> UPDATE table_name SET column_name = value WHERE condition;

WHERE 절은 =,! =, <,>, <= 및> =와 같은 비교 연산자와 BETWEEN 및 LIKE 연산자를 사용할 수 있습니다.

예

아래에 표시된 것처럼 7 개의 레코드가있는 데이터베이스에 Employees라는 테이블이 있다고 가정 해 보겠습니다.

ID |NAME |SALARY |LOCATION
-----------------------------------------------------------------------------
1 |Amit |30000 |Hyderabad
2 |Kalyan |40000 |Vishakhapatnam
3 |Renuka |50000 |Delhi
4 |Archana |15000 |Mumbai
5 |Trupthi |45000 |Kochin
6 |Suchatra |33000 |Pune
7 |Rahul |39000 |Lucknow

다음 SQL DELETE 문은 급여가 35000 이상인 직원의 레코드를 가져옵니다.

ij> SELECT * FROM Employees WHERE Salary>35000;

이것은 다음과 같은 출력을 생성합니다-

ID |NAME |SALARY |LOCATION 
---------------------------------------------------
2 |Kalyan |40000 |Vishakhapatnam
3 |Renuka |50000 |Delhi
5 |Trupthi |45000 |Kochin
7 |Rahul |39000 |Lucknow
4 rows selected

마찬가지로이 절을 사용하여 레코드를 삭제하고 업데이트 할 수도 있습니다.

다음 예는 급여가 30000 미만인 사람들의 위치를 업데이트합니다.

ij> UPDATE Employees SET Location = 'Vijayawada' WHERE Salary<35000;
3 rows inserted/updated/deleted

표의 내용을 확인하면 아래와 같이 업데이트 된 표를 볼 수 있습니다.

ij> SELECT * FROM Employees;
ID |NAME |SALARY |LOCATION
------------------------------------------------------------------------------
1 |Amit |30000 |Vijayawada
2 |Kalyan |40000 |Vishakhapatnam
3 |Renuka |50000 |Delhi
4 |Archana |15000 |Vijayawada
5 |Trupthi |45000 |Kochin
6 |Suchatra |33000 |Vijayawada
7 |Rahul |39000 |Lucknow
7 rows selected

Where 절 JDBC 예제

이 섹션에서는 JDBC 애플리케이션을 사용하여 Apache Derby 데이터베이스의 테이블에서 WHERE 절을 사용하고 CURD 작업을 수행하는 방법을 설명합니다.

네트워크 클라이언트를 사용하여 Derby 네트워크 서버를 요청하려면 서버가 실행 중인지 확인하십시오. 네트워크 클라이언트 드라이버의 클래스 이름은 org.apache.derby.jdbc.ClientDriver이고 URL은 jdbc : derby : // localhost : 1527 /입니다.DATABASE_NAME; create = true; user =USER_NAME;passw ord =PASSWORD".

WHERE 절을 사용하고 Apache Derby의 테이블에서 CURD 작업을 수행하려면 아래 단계를 따르십시오.

1 단계 : 드라이버 등록

데이터베이스와 통신하려면 먼저 드라이버를 등록해야합니다. 그만큼forName() 수업 방법 Class클래스 이름을 나타내는 String 값을 받아 메모리에로드하면 자동으로 등록됩니다. 이 방법을 사용하여 드라이버 등록

2 단계 : 연결하기

3 단계 : 문 개체 만들기

4 단계 : 쿼리 실행

문을 만든 후에는 실행해야합니다. 그만큼Statement 클래스는 다음과 같은 쿼리를 실행하는 다양한 방법을 제공합니다. execute()둘 이상의 결과 집합을 반환하는 문을 실행하는 메서드입니다. 그만큼executeUpdate()메소드는 INSERT, UPDATE, DELETE와 같은 쿼리를 실행합니다. 그만큼executeQuery()데이터를 반환하는 메서드 결과. 이 방법 중 하나를 사용하고 이전에 만든 문을 실행합니다.

예

다음 JDBC 예제는 JDBC 프로그램을 사용하여 Apache Derby의 테이블에서 WHERE 절을 사용하고 CURD 작업을 수행하는 방법을 보여줍니다. 여기서는 임베디드 드라이버를 사용하여 sampleDB (존재하지 않는 경우 생성)라는 데이터베이스에 연결합니다.

import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.Statement;
import java.sql.ResultSet;
public class WhereClauseExample {
   public static void main(String args[]) throws Exception {
      //Registering the driver
      Class.forName("org.apache.derby.jdbc.EmbeddedDriver");
      //Getting the Connection object
      String URL = "jdbc:derby:sampleDB;create=true";
      Connection conn = DriverManager.getConnection(URL);

      //Creating the Statement object
      Statement stmt = conn.createStatement();

      //Creating a table and populating it
      String query = "CREATE TABLE Employees("
         + "Id INT NOT NULL GENERATED ALWAYS AS IDENTITY, "
         + "Name VARCHAR(255), Salary INT NOT NULL, "
         + "Location VARCHAR(255), "
         + "PRIMARY KEY (Id))";
      String query = "INSERT INTO Employees("
         + "Name, Salary, Location) VALUES "
         + "('Amit', 30000, 'Hyderabad'), "
         + "('Kalyan', 40000, 'Vishakhapatnam'), "
         + "('Renuka', 50000, 'Delhi'), "
         + "('Archana', 15000, 'Mumbai'), "
         + "('Trupthi', 45000, 'Kochin'), "
         + "('Suchatra', 33000, 'Pune'), "
         + "('Rahul', 39000, 'Lucknow'), "
         + "('Trupti', 45000, 'Kochin')";
      //Executing the query
      String query = "SELECT * FROM Employees WHERE Salary>35000";
      ResultSet rs = stmt.executeQuery(query);
      while(rs.next()) {
         System.out.println("Id: "+rs.getString("Id"));
         System.out.println("Name: "+rs.getString("Name"));
         System.out.println("Salary: "+rs.getString("Salary"));
         System.out.println("Location: "+rs.getString("Location"));
         System.out.println(" ");
      }
   }
}

산출

위의 프로그램을 실행하면 다음과 같은 출력이 나타납니다.

Id: 2
Name: Kalyan
Salary: 43000
Location: Chennai

Id: 3
Name: Renuka
Salary: 50000
Location: Delhi

Id: 5
Name: Trupthi
Salary: 45000
Location: Kochin

Id: 7
Name: Rahul
Salary: 39000
Location: Lucknow

Apache Derby-GROUP BY 절

GROUP BY 절은 SELECT 문과 함께 사용됩니다. 동일한 데이터의 경우 하위 집합을 형성하는 데 사용됩니다. 일반적으로이 절 뒤에는 ORDER BY 절이 나오고 WHERE 절 뒤에 위치합니다.

통사론

다음은 GROUP BY 절의 구문입니다-

ij>SELECT column1, column2, . . . table_name GROUP BY column1, column2, . . .;

예

다음과 같은 레코드가있는 데이터베이스에 Employees라는 테이블이 있다고 가정합니다.

ID |NAME |SALARY |LOCATION
------------------------------------------------------------------
1 |Amit |30000 |Hyderabad
2 |Rahul |39000 |Lucknow
3 |Renuka |50000 |Hyderabad
4 |Archana |15000 |Vishakhapatnam
5 |Kalyan |40000 |Hyderabad
6 |Trupthi |45000 |Vishakhapatnam
7 |Raghav |12000 |Lucknow
8 |Suchatra |33000 |Vishakhapatnam
9 |Rizwan |20000 |Lucknow

GROUP BY 절이있는 다음 SELECT 문은 위치에 따라 테이블을 그룹화합니다. 한 위치에서 직원에게 지급 된 총 급여 금액을 표시합니다.

ij> SELECT Location, SUM(Salary) from Employees GROUP BY Location;

이것은 다음과 같은 출력을 생성합니다-

LOCATION |2
-------------------------------------------------------
Hyderabad |120000
Lucknow |71000
Vishakhapatnam |93000
3 rows selected

같은 방식으로 다음 쿼리는 직원에게 한 위치에서 급여로 지출 한 평균 금액을 찾습니다.

ij> SELECT Location, AVG(Salary) from Employees GROUP BY Location;

이것은 다음과 같은 출력을 생성합니다-

LOCATION |2
-----------------------------------------------------
Hyderabad |40000
Lucknow |23666
Vishakhapatnam |31000
3 rows selected

Group By 절 JDBC 예제

이 섹션에서는 JDBC 애플리케이션을 사용하여 Apache Derby 데이터베이스의 테이블에서 Group By 절을 사용하고 CURD 작업을 수행하는 방법을 설명합니다.

아래 단계에 따라 Group By 절을 사용하고 Apache Derby의 테이블에서 CURD 작업을 수행합니다.

1 단계 : 드라이버 등록

2 단계 : 연결하기

3 단계 : 문 개체 만들기

4 단계 : 쿼리 실행

문을 만든 후에는 실행해야합니다. 그만큼Statement 클래스는 다음과 같은 쿼리를 실행하는 다양한 방법을 제공합니다. execute()둘 이상의 결과 집합을 반환하는 문을 실행하는 메서드입니다. 그만큼executeUpdate()메소드는 INSERT, UPDATE, DELETE와 같은 쿼리를 실행하는 데 사용됩니다. 그만큼executeQuery()메서드는 데이터를 반환합니다. 이 방법 중 하나를 사용하고 이전에 만든 문을 실행합니다.

예

다음 JDBC 예제는 사용 방법을 보여줍니다. Group ByJDBC 프로그램을 사용하여 Apache Derby의 테이블에서 CURD 작업을 수행합니다. 여기서는 임베디드 드라이버를 사용하여 sampleDB (존재하지 않는 경우 생성)라는 데이터베이스에 연결합니다.

import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.Statement;
import java.sql.ResultSet;
public class GroupByClauseExample {
   public static void main(String args[]) throws Exception {
      //Registering the driver
      Class.forName("org.apache.derby.jdbc.EmbeddedDriver");

      //Getting the Connection object
      String URL = "jdbc:derby:sampleDB;create=true";
      Connection conn = DriverManager.getConnection(URL);

      //Creating the Statement object
      Statement stmt = conn.createStatement();

      //Creating a table and populating it
      stmt.execute("CREATE TABLE EmployeesData( "
         + "Id INT NOT NULL GENERATED ALWAYS AS IDENTITY, "
         + "Name VARCHAR(255), "
         + "Salary INT NOT NULL, "
         + "Location VARCHAR(255), "
         + "PRIMARY KEY (Id))");
      stmt.execute("INSERT INTO EmployeesData(Name, Salary, Location) "
         + "VALUES ('Amit', 30000, 'Hyderabad'), "
         + "('Rahul', 39000, 'Lucknow'), "
         + "('Renuka', 50000, 'Hyderabad'), "
         + "('Archana', 15000, 'Vishakhapatnam'), "
         + "('Kalyan', 40000, 'Hyderabad'), "
         + "('Trupthi', 45000, 'Vishakhapatnam'), "
         + "('Raghav', 12000, 'Lucknow'), "
         + "('Suchatra', 33000, 'Vishakhapatnam'), "
         + "('Rizwan', 20000, 'Lucknow')");

      //Executing the query
      String query = "SELECT Location, SUM(Salary) from EmployeesData GROUP BY Location";
      ResultSet rs = stmt.executeQuery(query);
      while(rs.next()) {
         System.out.println("Location: "+rs.getString(1));
         System.out.println("Sum of salary: "+rs.getString(2));
         System.out.println(" ");
      }
   }
}

산출

위의 프로그램을 실행하면 다음과 같은 출력이 나타납니다.

Location: Hyderabad
Sum of salary: 120000

Location: Lucknow
Sum of salary: 71000

Location: Vishakhapatnam
Sum of salary: 93000

Apache Derby-Order By 절

ORDER BY 절은 키워드를 사용하는 순서대로 결과 집합의 내용을 정렬하는 데 사용됩니다. ASC는 오름차순을 나타내고 DESC는 내림차순을 나타냅니다. 이들 중 어느 것도 언급하지 않으면 컨텐츠가 기본적으로 오름차순으로 정렬됩니다.

통사론

다음은 ORDER BY 절의 구문입니다-

SELECT * FROM table_name ORDER BY column_name ASC|DESC.

예

다음과 같은 레코드가있는 데이터베이스에 Employees라는 테이블이 있다고 가정합니다.

ID |NAME |SALARY |LOCATION
------------------------------------------------------------------------------
1 |Amit |30000 |Vijayawada
2 |Kalyan |40000 |Vishakhapatnam
3 |Renuka |50000 |Delhi
4 |Archana |15000 |Vijayawada
5 |Trupthi |45000 |Kochin
6 |Suchatra |33000 |Vijayawada
7 |Rahul |39000 |Lucknow

다음 쿼리는 직원 이름을 기준으로 오름차순으로 테이블의 내용을 정렬합니다.

ij> SELECT * FROM Employees ORDER BY Name;

이것은 다음과 같은 출력을 생성합니다-

ID |NAME |SALARY |LOCATION
---------------------------------------------------------------
1 |Amit |30000 |Hyderabad
4 |Archana |15000 |Mumbai
2 |Kalyan |40000 |Vishakhapatnam 
7 |Rahul |39000 |Lucknow
3 |Renuka |50000 |Delhi
6 |Suchatra |33000 |Pune
5 |Trupthi |45000 |Kochin
7 rows selected

유사하게, 다음 쿼리는 직원의 급여를 기준으로 내림차순으로 테이블의 내용을 정렬합니다-

ij> SELECT * FROM Employees ORDER BY Salary DESC;

이것은 다음과 같은 출력을 생성합니다-

ID |NAME |SALARY |LOCATION
---------------------------------------------------------------
3 |Renuka |50000 |Delhi
5 |Trupthi |45000 |Kochin
2 |Kalyan |40000 |Vishakhapatnam
7 |Rahul |39000 |Lucknow
6 |Suchatra |33000 |Pune
1 |Amit |30000 |Hyderabad
4 |Archana |15000 |Mumbai
7 rows selected

JDBC 프로그램을 사용하여 데이터 정렬

이 섹션에서는 JDBC를 사용하여 Derby에서 테이블의 내용을 정렬하는 방법을 설명합니다. ORDER BY 절과 키워드 ASC (오름차순 표시) 및 DSC (내림차순 표시)를 사용하여 레코드를 순서대로 정렬 할 수 있습니다.

Apache Derby에서 테이블의 레코드를 정렬하려면 아래 단계를 따르십시오.

1 단계 : 드라이버 등록

2 단계 : 연결하기

일반적으로 데이터베이스와 통신하기 위해 수행하는 첫 번째 단계는 데이터베이스에 연결하는 것입니다. 그만큼 Connection클래스는 데이터베이스 서버와의 물리적 연결을 나타냅니다. 다음을 호출하여 연결 개체를 만들 수 있습니다. getConnection() 의 방법 DriverManager수업. 이 방법을 사용하여 연결을 만듭니다.

3 단계 : 문 개체 만들기

4 단계 : 쿼리 실행

문을 만든 후에는 실행해야합니다. 그만큼Statement 클래스는 다음과 같은 쿼리를 실행하는 다양한 방법을 제공합니다. execute()둘 이상의 결과 집합을 반환하는 문을 실행하는 메서드입니다. 그만큼executeUpdate()메소드는 INSERT, UPDATE, DELETE와 같은 쿼리를 실행합니다. 그만큼executeQuery()메서드는 데이터를 반환합니다. 이 방법 중 하나를 사용하고 이전에 만든 문을 실행합니다.

예

다음 JDBC 예제는 JDBC 프로그램을 사용하여 Apache Derby에서 테이블의 레코드를 정렬하는 방법을 보여줍니다. 여기서는 임베디드 드라이버를 사용하여 sampleDB (존재하지 않는 경우 생성)라는 데이터베이스에 연결합니다.

import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;
public class SortData {
   public static void main(String args[]) throws SQLException, ClassNotFoundException {
      //Registering the driver
      Class.forName("org.apache.derby.jdbc.EmbeddedDriver");

      //Getting the Connection object
      String URL = "jdbc:derby:SampleDB;create=true";
      Connection conn = DriverManager.getConnection(URL);

      //Creating the Statement object
      Statement stmt = conn.createStatement();

      //Creating a table and populating it
      String query = "CREATE TABLE Employees("
         + "Id INT NOT NULL GENERATED ALWAYS AS IDENTITY, "
         + "Name VARCHAR(255), Salary INT NOT NULL, "
         + "Location VARCHAR(255), "
         + "PRIMARY KEY (Id))";
      String query = "INSERT INTO Employees("
         + "Name, Salary, Location) VALUES "
         + "('Amit', 30000, 'Hyderabad'), "
         + "('Kalyan', 40000, 'Vishakhapatnam'), "
         + "('Renuka', 50000, 'Delhi'), "
         + "('Archana', 15000, 'Mumbai'), "
         + "('Trupthi', 45000, 'Kochin'), "
         + "('Suchatra', 33000, 'Pune'), "
         + "('Rahul', 39000, 'Lucknow'), "
         + "('Trupti', 45000, 'Kochin')";
      //Executing the query
      String query = "SELECT Location, SUM(Salary) " + "from Employees GROUP BY Location";
      ResultSet rs = stmt.executeQuery(query);
      while(rs.next()) {
         System.out.println("Salary: "+rs.getString(1));
         System.out.println("Location: "+rs.getString(2));
         System.out.println(" ");
      }
   }
}

산출

위의 프로그램을 실행하면 다음과 같은 출력이 나타납니다.

Salary: Chennai
Location: 43000

Salary: Delhi
Location: 50000

Salary: Hyderabad
Location: 30000

Salary: Kochin
Location: 45000

Salary: Lucknow
Location: 39000

Salary: Mumbai
Location: 15000

Salary: Pune
Location: 33000

Apache Derby-having 절

HAVING 절을 사용하면 결과에 나타나는 그룹 결과를 필터링하는 조건을 지정할 수 있습니다.

WHERE 절은 선택한 열에 조건을 배치하는 반면 HAVING 절은 GROUP BY 절에 의해 생성 된 그룹에 조건을 배치합니다.

통사론

다음은 HAVING 절의 구문입니다-

ij> SELECT column1, column2 . . . from table_name GROUP BY column having
condition;

예

아래와 같이 13 개의 레코드가있는 데이터베이스에 Employees라는 테이블이 있다고 가정합니다.

ID |NAME |SALARY |LOCATION
------------------------------------------------------------------
1 |Amit |30000 |Hyderabad
2 |Rahul |39000 |Lucknow
3 |Kalyan |40000 |Vishakhapatnam
4 |Renuka |50000 |Hyderabad
5 |Archana |15000 |Vishakhapatnam
6 |Krishna |40000 |Hyderabad
7 |Trupthi |45000 |Vishakhapatnam
8 |Raghav |12000 |Lucknow
9 |Radha |50000 |Delhi
10 |Anirudh |15000 |Mumbai
11 |Tara |45000 |Kochin
12 |Sucharita |44000 |Kochin
13 |Rizwan |20000 |Lucknow

다음 쿼리는 직원이 3 명 이상인 위치에있는 직원의 최대 급여를 표시합니다.

ij> SELECT Location, MAX(Salary) from Employees GROUP BY Location having
count(Location)>=3;

이것은 다음과 같은 출력을 생성합니다-

LOCATION |2
------------------------------------------------------------
Hyderabad |50000
Lucknow |39000
Vishakhapatnam |45000
3 rows selected

JDBC 프로그램을 사용하여 데이터 정렬

이 섹션에서는 JDBC 애플리케이션을 사용하여 Apache Derby 데이터베이스에서 Have a 절을 사용하는 방법을 설명합니다.

Apache Derby에서 테이블의 레코드를 정렬하려면 아래 단계를 따르십시오.

1 단계 : 드라이버 등록

데이터베이스와 통신하려면 먼저 드라이버를 등록해야합니다. 그만큼forName() 수업 방법 Class클래스 이름을 나타내는 문자열 값을 받아 메모리에로드하면 자동으로 등록됩니다. 이 방법을 사용하여 드라이버를 등록하십시오.

2 단계 : 연결하기

3 단계 : 문 개체 만들기

4 단계 : 쿼리 실행

문을 만든 후에는 실행해야합니다. 그만큼Statement 클래스는 다음과 같은 쿼리를 실행하는 다양한 방법을 제공합니다. execute()둘 이상의 결과 집합을 반환하는 문을 실행하는 메서드입니다. 그만큼executeUpdate()메소드는 INSERT, UPDATE, DELETE와 같은 쿼리를 실행합니다. 그만큼executeQuery()메서드는 데이터를 반환합니다. 이 방법 중 하나를 사용하고 이전에 만든 문을 실행합니다.

예

다음 JDBC 예제는 JDBC 프로그램을 사용하여 Apache Derby의 테이블에서 Group By 절을 사용하고 CURD 작업을 수행하는 방법을 보여줍니다. 여기서는 임베디드 드라이버를 사용하여 sampleDB (존재하지 않는 경우 생성)라는 데이터베이스에 연결합니다.

import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.Statement;
import java.sql.ResultSet;
public class HavingClauseExample {
   public static void main(String args[]) throws Exception {
      //Registering the driver
      Class.forName("org.apache.derby.jdbc.EmbeddedDriver");

      //Getting the Connection object
      String URL = "jdbc:derby:sampleDB;create=true";
      Connection conn = DriverManager.getConnection(URL);

      //Creating the Statement object
      Statement stmt = conn.createStatement();

      //Creating a table and populating it
      stmt.execute("CREATE TABLE EmployeesData( "
         + "Id INT NOT NULL GENERATED ALWAYS AS IDENTITY, "
         + "Name VARCHAR(255), "
         + "Salary INT NOT NULL, "
         + "Location VARCHAR(255), "
         + "PRIMARY KEY (Id))");
      stmt.execute("INSERT INTO EmployeesData(Name, Salary, Location) "
         + "VALUES ('Amit', 30000, 'Hyderabad'), "
         + "('Rahul', 39000, 'Lucknow'), "
         + "('Renuka', 50000, 'Hyderabad'), "
         + "('Archana', 15000, 'Vishakhapatnam'), "
         + "('Kalyan', 40000, 'Hyderabad'), "
         + "('Trupthi', 45000, 'Vishakhapatnam'), "
         + "('Raghav', 12000, 'Lucknow'), "
         + "('Suchatra', 33000, 'Vishakhapatnam'), "
         + "('Rizwan', 20000, 'Lucknow')");
      //Executing the query
      String query = "SELECT Location, MAX(Salary) "
         + "from EmployeesData GROUP BY Location having "
         + "count(Location)>=3";
      ResultSet rs = stmt.executeQuery(query);
      while(rs.next()) {
         System.out.println(rs.getString(1));
         System.out.println(rs.getString(2));
         System.out.println(" ");
      }
   }
}

산출

위의 프로그램을 실행하면 다음과 같은 출력이 나타납니다.

Hyderabad
50000

Lucknow
39000

Vishakhapatnam
45000

Apache Derby-테이블 문 변경

ALTER TABLE 문을 사용하면 기존 테이블을 변경할 수 있습니다. 이것을 사용하면 다음을 수행 할 수 있습니다.

열 추가, 제약 조건 추가
열 삭제, 제약 조건 삭제
테이블의 행 수준 잠금 변경

아래와 같이 Employees라는 테이블을 만들었다 고 가정 해 보겠습니다.

ij> CREATE TABLE Employees (
   Id INT NOT NULL GENERATED ALWAYS AS IDENTITY,
   Name VARCHAR(255),
   Salary INT NOT NULL,
   Location VARCHAR(255),
   PRIMARY KEY (Id)
);

그리고 다음과 같이 insert 문을 사용하여 4 개의 레코드를 삽입했습니다.

ij> INSERT INTO Employees (Name, Salary, Location) VALUES
 ('Amit', 30000, 'Hyderabad'),
 ('Kalyan', 40000, 'Vishakhapatnam'),
 ('Renuka', 50000, 'Delhi'),
 ('Archana', 15000, 'Mumbai');

테이블에 열 추가

다음은 ALTER 문을 사용하여 테이블에 열을 추가하는 구문입니다.

ALTER TABLE table_name ADD COLUMN column_name column_type;

예

ALTER 문을 사용하여 정수 유형의 Age라는 새 열을 추가하려고합니다.

ALTER TABLE Employees ADD COLUMN Age INT;
0 rows inserted/updated/deleted

정수 유형으로 Phone_No라는 다른 열을 추가하십시오.

ALTER TABLE Employees ADD COLUMN Phone_No BIGINT;
0 rows inserted/updated/deleted

DESCRIBE 명령은 테이블이있는 경우 열과 세부 사항을 나열하여 지정된 테이블을 설명합니다. DESCRIBE하면 Employees 테이블에서 아래와 같이 새로 추가 된 열을 관찰 할 수 있습니다.

ij> DESCRIBE Employees;
COLUMN_NAME |TYPE_NAME|DEC&|NUM&|COLUM&|COLUMN_DEF|CHAR_OCTE&|IS_NULL&
------------------------------------------------------------------------------
ID |INTEGER |0 |10 |10 |AUTOINCRE&|NULL |NO
NAME |VARCHAR |NULL|NULL|255 |NULL |510 |YES
SALARY |INTEGER |0 |10 |10 |NULL |NULL |NO
LOCATION |VARCHAR |NULL|NULL|255 |NULL |510 |YES
AGE |INTEGER |0 |10 |10 |NULL |NULL |YES
PHONE_NO |INTEGER |0 |10 |10 |NULL |NULL |YES
6 rows selected

테이블에 제약 추가

다음은 ALTER 문을 사용하여 테이블의 열에 제약 조건을 추가하는 구문입니다.

ALTER TABLE table_name ADD CONSTRAINT constraint_name constraint (column_name);

어디 constraint NOT NULL, NULL, PRIMARY KEY, UNIQUE, FOREIGN KEY, CHECK가 될 수 있습니다.

예

ALTER 문을 사용하여 제약 조건을 추가하려고합니다. UNIQUE Phone_No 열에.

ij> ALTER TABLE Employees ADD CONSTRAINT New_Constraint UNIQUE(Phone_No);
0 rows inserted/updated/deleted

한 번 열에 UNIQUE 제약 조건을 추가하면 두 행에 대해 동일한 값을 가질 수 없습니다. 즉, 전화 번호는 각 직원에 대해 고유해야합니다.

동일한 전화 번호로 두 개의 열을 추가하려고하면 아래와 같은 예외가 발생합니다.

ij> INSERT INTO Employees (Name, Salary, Location, Age, Phone_No) VALUES
('Amit', 30000, 'Hyderabad', 30, 9848022338);
1 row inserted/updated/deleted
ij> INSERT INTO Employees (Name, Salary, Location, Age, Phone_No) VALUES
('Sumit', 35000, 'Chennai', 25, 9848022338);
ERROR 23505: The statement was aborted because it would have caused a duplicate
key value in a unique or primary key constraint or unique index identified by
'NEW_CONSTRAINT' defined on 'EMPLOYEES'.

테이블에서 제약 조건 삭제

다음은 열의 제약 조건을 삭제하는 구문입니다-

ALTER TABLE table_name DROP CONSTRAINT constraint_name;

예

다음 쿼리는 위에서 만든 Phone_No 열에서 제약 이름 New_Constraint를 삭제합니다.

ij> ALTER TABLE Employees DROP CONSTRAINT New_Constraint;
0 rows inserted/updated/deleted

Phone_No 열에서 UNIQUE 제약 조건을 제거 했으므로 동일한 전화 번호로 열을 추가 할 수 있습니다.

ij> INSERT INTO Employees (Name, Salary, Location, Age, Phone_No) VALUES
('Sumit', 35000, 'Chennai', 25, 9848022338);
1 row inserted/updated/deleted

표의 내용을 확인할 수 있습니다. ij> 다음과 같이 Employees에서 *를 선택하십시오-

ID |NAME |SALARY |LOCATION |AGE |PHONE_NO
-------------------------------------------------------------------------
1 |Amit |30000 |Hyderabad |30 |9848022338
2 |Sumit |35000 |Chennai |25 |9848022338
2 rows selected

테이블에서 컬럼 삭제

다음은 열의 열을 삭제하는 구문입니다.

ALTER TABLE table_name DROP COLUMN column_name;

예

다음 쿼리는 이름이 지정된 열을 삭제합니다. age of the employee −

ij> ALTER TABLE Employees DROP COLUMN Age;
0 rows inserted/updated/deleted

표를 설명하면 4 개의 열만 볼 수 있습니다.

ij> DESCRIBE Employees;
COLUMN_NAME |TYPE_NAME|DEC&|NUM&|COLUM&|COLUMN_DEF|CHAR_OCTE&|IS_NULL&
------------------------------------------------------------------------------
ID |INTEGER |0 |10 |10 |AUTOINCRE&|NULL |NO
NAME |VARCHAR |NULL|NULL|255 |NULL |510 |YES
SALARY |INTEGER |0 |10 |10 |NULL |NULL |NO
LOCATION |VARCHAR |NULL|NULL|255 |NULL |510 |YES
PHONE_NO |BIGINT |0 |10 |19 |NULL |NULL |YES

JDBC 프로그램을 사용하여 테이블 변경

다음은 ALTER 쿼리를 사용하여 테이블을 변경하는 JDBC 프로그램입니다-

import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;
public class AlterTableExample {
   public static void main(String args[]) throws Exception {
      //Registering the driver
      Class.forName("org.apache.derby.jdbc.EmbeddedDriver");
      //Getting the Connection object
      String URL = "jdbc:derby:sampleDB;create=true";
      Connection conn = DriverManager.getConnection(URL);

      //Creating the Statement object
      Statement stmt = conn.createStatement();

      //Executing the query
      String createQuery = "CREATE TABLE Employees( "
         + "Id INT NOT NULL GENERATED ALWAYS AS IDENTITY, "
         + "Name VARCHAR(255), "
         + "Salary INT NOT NULL, "
         + "Location VARCHAR(255), "
         + "PRIMARY KEY (Id))";

      stmt.execute(createQuery);
      System.out.println("Table created");
      System.out.println(" ");

      //Executing the query
      String insertQuery = "INSERT INTO Employees("
         + "Name, Salary, Location) VALUES "
         + "('Amit', 30000, 'Hyderabad'), "
         + "('Kalyan', 40000, 'Vishakhapatnam'), "
         + "('Renuka', 50000, 'Delhi'), "
         + "('Archana', 15000, 'Mumbai'), "
         + "('Trupti', 45000, 'Kochin')";

      stmt.execute(insertQuery);
      System.out.println("Values inserted");
      System.out.println(" ");

      //Executing the query
      String selectQuery = "SELECT * FROM Employees";
      ResultSet rs = stmt.executeQuery(selectQuery);
      System.out.println("Contents of the table after inserting the table");
      while(rs.next()) {
         System.out.println("Id: "+rs.getString("Id"));
         System.out.println("Name: "+rs.getString("Name"));
         System.out.println("Salary: "+rs.getString("Salary"));
         System.out.println("Location: "+rs.getString("Location"));
      }
      System.out.println(" ");

      //Altering the table
      stmt.execute("ALTER TABLE Employees ADD COLUMN Age INT");
      stmt.execute("ALTER TABLE Employees ADD COLUMN Phone_No BigINT");
      stmt.execute("ALTER TABLE Employees " + "ADD CONSTRAINT New_Constraint UNIQUE(Phone_No)");

      stmt.execute("INSERT INTO Employees "
         + "(Name, Salary, Location, Age, Phone_No) "
         + "VALUES ('Amit', 30000, 'Hyderabad', 30, 9848022338)");
      ResultSet alterResult = stmt.executeQuery("Select * from Employees");
      System.out.println("Contents of the table after altering "
         + "the table and inserting values to it: ");
      while(alterResult.next()) {
         System.out.println("Id: "+alterResult.getString("Id"));
         System.out.println("Name: "+alterResult.getString("Name"));
         System.out.println("Salary: "+alterResult.getString("Salary"));
         System.out.println("Location: "+alterResult.getString("Location"));
         System.out.println("Age: "+alterResult.getString("Age"));
         System.out.println("Phone_No: "+alterResult.getString("Phone_No"));
      }
   }
}

산출

위의 프로그램을 실행하면 다음과 같은 출력이 생성됩니다.

Table created

Values inserted

Contents of the table after inserting the table
Id: 1
Name: Amit
Salary: 30000
Location: Hyderabad
Id: 2
Name: Kalyan
Salary: 40000
Location: Vishakhapatnam
Id: 3
Name: Renuka
Salary: 50000
Location: Delhi
Id: 4
Name: Archana
Salary: 15000
Location: Mumbai
Id: 5
Name: Trupti
Salary: 45000
Location: Kochin

Contents of the table after altering the table and inserting values to it:
Id: 1
Name: Amit
Salary: 30000
Location: Hyderabad
Age: null
Phone_No: null
Id: 2
Name: Kalyan
Salary: 40000
Location: Vishakhapatnam
Age: null
Phone_No: null
Id: 3
Name: Renuka
Salary: 50000
Location: Delhi
Age: null
Phone_No: null
Id: 4
Name: Archana
Salary: 15000
Location: Mumbai
Age: null
Phone_No: null
Id: 5
Name: Trupti
Salary: 45000
Location: Kochin
Age: null
Phone_No: null
Id: 6
Name: Amit
Salary: 30000
Location: Hyderabad
Age: 30
Phone_No: 9848022338

Apache Derby-Derby 인덱스

테이블의 인덱스는 데이터에 대한 포인터 일뿐입니다. 이들은 테이블에서 데이터 검색 속도를 높이는 데 사용됩니다.

인덱스를 사용하면 INSERT 및 UPDATE 문이 더 느린 단계에서 실행됩니다. SELECT 및 WHERE는 더 짧은 시간에 실행됩니다.

인덱스 생성

CREATE INDEX 문은 Derby 데이터베이스의 테이블에 새 인덱스를 만드는 데 사용됩니다.

통사론

다음은 CREATE INDEX 문의 구문입니다-

CTREATE INDEX index_name on table_name (column_name);

예

아래와 같이 Apache Derby에 Employees라는 테이블을 만들었다 고 가정 해 보겠습니다.

CREATE TABLE Emp ( Id INT NOT NULL GENERATED ALWAYS AS IDENTITY,
   Name VARCHAR(255),
   Salary INT NOT NULL,
   Location VARCHAR(255),
   Phone_Number BIGINT
);

다음 SQL 문은 Employees 테이블의 Salary 열에 인덱스를 만듭니다.

ij> CREATE INDEX example_index on Emp (Salary);
0 rows inserted/updated/deleted

고유 인덱스 생성

Apache Derby에서 UNIQUE 인덱스는 데이터 통합에 사용됩니다. 테이블의 열에 UNIQUE 인덱스를 생성하면 중복 값이 허용되지 않습니다.

통사론

다음은 고유 인덱스를 만드는 구문입니다.

CREATE UNIQUE INDEX index_name on table_name (column_name);

예

다음 예에서는 Employee 테이블의 Id 열에 UNIQUE 인덱스를 만듭니다.

ij> CREATE UNIQUE INDEX unique_index on Emp (Phone_Number);
0 rows inserted/updated/deleted

열에 고유 인덱스를 만든 후에는 해당 열에 대해 동일한 값을 다른 행에 입력 할 수 없습니다. 즉, UNIQE 인덱스가있는 열은 중복 값을 허용하지 않습니다.

아래와 같이 Emp 테이블에 행을 삽입합니다.

ij> INSERT INTO Emp(Name, Salary, Location, Phone_Number) VALUES ('Amit',
45000, 'Hyderabad', 9848022338);
1 row inserted/updated/deleted

Phone_No 열에 고유 인덱스를 생성 했으므로 이전 레코드와 동일한 값을 입력하면 오류가 표시됩니다.

ij> INSERT INTO Emp(Name, Salary, Location, Phone_Number) VALUES ('Sumit',
35000, 'Chennai', 9848022338);
ERROR 23505: The statement was aborted because it would have caused a duplicate
key value in a unique or primary key constraint or unique index identified by
'UNIQUE_INDEX' defined on 'EMP'.

COMPOSITE 인덱스 생성

두 행에 단일 인덱스를 만들 수 있으며이를 복합 인덱스라고합니다.

통사론

다음은 복합 색인의 구문입니다.

CREATE INDEX index_name on table_name (column_name1, column_name2);

예

다음 색인은 Name 및 Location 열에 복합 색인을 만듭니다.

ij> CREATE INDEX composite_index on Emp (Name, Location);
0 rows inserted/updated/deleted

인덱스 표시

SHOW INDEXES 쿼리는 테이블의 인덱스 목록을 표시합니다.

통사론

다음은 SHOW INDEXES 문의 구문입니다-

SHOW INDEXES FROM table_name;

예

다음 예에서는 Employees 테이블에 인덱스를 표시합니다.

ij> SHOW INDEXES FROM Emp;

이것은 다음과 같은 결과를 생성합니다.

ij> SHOW INDEXES FROM Emp;
TABLE_NAME |COLUMN_NAME |NON_U&|TYPE|ASC&|CARDINA&|PAGES
----------------------------------------------------------------------------
EMP |PHONE_NUMBER |false |3 |A |NULL |NULL
EMP |NAME |true |3 |A |NULL |NULL
EMP |LOCATION |true |3 |A |NULL |NULL
EMP |SALARY |true |3 |A |NULL |NULL
4 rows selected

인덱스 삭제

Drop Index 문은 열에서 주어진 인덱스를 삭제 / 삭제합니다.

통사론

다음은 DROP INDEX 문의 구문입니다.

DROP INDEX index_name;

예

다음 예제는 위에서 만든 composite_index 및 unique_index라는 인덱스를 삭제합니다.

ij> DROP INDEX composite_index;
0 rows inserted/updated/deleted
ij>Drop INDEX unique_index;
0 rows inserted/updated/deleted

이제 인덱스 목록을 확인하면 나머지는 삭제 했으므로 한 열의 인덱스를 볼 수 있습니다.

ij> SHOW INDEXES FROM Emp;
TABLE_NAME |COLUMN_NAME |NON_U&|TYPE|ASC&|CARDINA&|PAGES
----------------------------------------------------------------------------
EMP |SALARY |true |3 |A |NULL |NULL
1 row selected

JDBC 프로그램을 사용하여 인덱스 처리

다음 JDBC 프로그램은 테이블의 열에 드롭 인덱스를 작성하는 방법을 보여줍니다.

import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.SQLException;
import java.sql.Statement;
public class IndexesExample {
   public static void main(String args[]) throws Exception {

      //Registering the driver
      Class.forName("org.apache.derby.jdbc.EmbeddedDriver");
      //Getting the Connection object
      String URL = "jdbc:derby:MYDATABASE;create=true";
      Connection conn = DriverManager.getConnection(URL);

      //Creating the Statement object
      Statement stmt = conn.createStatement();

      //Creating the Emp table
      String createQuery = "CREATE TABLE Emp( "
         + "Id INT NOT NULL GENERATED ALWAYS AS IDENTITY, "
         + "Name VARCHAR(255), "
         + "Salary INT NOT NULL, "
         + "Location VARCHAR(255), "
         + "Phone_Number BIGINT )";
      stmt.execute(createQuery);
      System.out.println("Table created");
      System.out.println(" ");

      //Creating an Index on the column Salary
      stmt.execute("CREATE INDEX example_index on Emp (Salary)");
      System.out.println("Index example_index inserted");
      System.out.println(" ");

      //Creating an Unique index on the column Phone_Number
      stmt.execute("CREATE UNIQUE INDEX unique_index on Emp (Phone_Number)");
      System.out.println("Index unique_index inserted");
      System.out.println(" ");

      //Creating a Composite Index on the columns Name and Location
      stmt.execute("CREATE INDEX composite_index on Emp (Name, Location)");
      System.out.println("Index composite_index inserted");
      System.out.println(" ");

      //listing all the indexes
      System.out.println("Listing all the columns with indexes");

      //Dropping indexes
      System.out.println("Dropping indexes unique_index and, composite_index ");
      stmt.execute("Drop INDEX unique_index");
      stmt.execute("DROP INDEX composite_index");
   }
}

산출

실행시 다음 결과가 생성됩니다.

Table created
Index example_index inserted

Index unique_index inserted

Index composite_index inserted

Listing all the columns with indexes
Dropping indexes unique_index and, composite_index

Apache Derby-절차

이 장에서는 Derby에서 프로 시저를 만들고 삭제하는 방법을 설명합니다.

프로 시저 생성

CREATE PROCEDURE 문을 사용하여 프로 시저를 만들 수 있습니다.

통사론

다음은 CREATE PROCEDURE 문의 구문입니다.

CREATE PROCEDURE procedure_name (parameter_type parameter_name1, parameter_type
parameter_name2 . . . .) parameter_style;

예

아래와 같이 Derby에 테이블을 만들었다 고 가정 해 보겠습니다.

CREATE TABLE Emp ( Id INT NOT NULL GENERATED ALWAYS AS IDENTITY,
   Name VARCHAR(255),
   Salary INT NOT NULL,
   Location VARCHAR(255),
   Phone_Number BIGINT
);

그리고 다음과 같이 삽입 된 값-

INSERT INTO Employees(Name, Salary, Location) VALUES
('Amit', 30000, 'Hyderabad'),
('Kalyan', 40000, 'Vishakhapatnam'),
('Renuka', 50000, 'Delhi'),
('Archana', 15000, 'Mumbai'),
('Trupthi', 45000, 'Kochin')";

다음 예제는 JAVA 매개 변수를 허용하는 Update_Procedure라는 프로 시저를 작성합니다.

ij> CREATE PROCEDURE Update_Procedure(IN id INTEGER, IN name VARCHAR(10))
PARAMETER STYLE JAVA READS SQL DATA LANGUAGE JAVA EXTERNAL NAME
'ProcedureExample.testProc';
> 0 rows inserted/updated/deleted

ProcedureExample 클래스는 다음과 같습니다.

import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.PreparedStatement;
public class ProcedureExample {
   public static void testProc(int salary, String name) throws Exception {
      String connectionURL = "jdbc:derby:MYDATABASE;create=true";
      Connection conn = DriverManager.getConnection(connectionURL);
      String query = "UPDATE Employees SET SALARY = ? WHERE NAME = ?";
      PreparedStatement pstmt = conn.prepareStatement(query);
      pstmt.setInt(1, salary);
      pstmt.setString (2, name);
      pstmt.executeUpdate();
   }
}

다음을 사용하여 절차 목록을 확인할 수 있습니다. SHOW PROCEDURES 질문.

ij> SHOW PROCEDURES;
PROCEDURE_SCHEM |PROCEDURE_NAME |REMARKS
------------------------------------------------------------------------
APP |UPDATE_PROCEDURE |ProcedureExample.te&
SALES |EXAMPLE_ PROCEDURE |com.example.sales.c&
SQLJ |INSTALL_JAR |org.apache.derby.ca&
SQLJ |REMOVE_JAR |org.apache.derby.ca&
SQLJ |REPLACE_JAR |org.apache.derby.ca&
SYSCS_UTIL |SYSCS_BACKUP_DATABASE |org.apache.derby.ca&
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

여기에서 새로 생성 된 절차를 관찰 할 수 있습니다.

절차 삭제

DROP PROCEDURE 문을 사용하여 프로 시저를 삭제할 수 있습니다.

통사론

다음은 DROP PROCEDURE 문의 구문입니다.

DROP PROCEDURE procedure_name;

예

다음 예제는 위에서 만든 Update_Procedure라는 프로 시저를 삭제합니다.

ij> DROP PROCEDURE Update_Procedure;
> 0 rows inserted/updated/deleted

Apache Derby-스키마

데이터베이스 스키마는 전체 데이터베이스의 논리적보기를 나타내는 골격 구조입니다. 데이터가 구성되는 방식과 데이터 간의 관계가 연결되는 방식을 정의합니다. 데이터에 적용될 모든 제약 조건을 공식화합니다.

스키마 생성

CREATE SCHEMA 문을 사용하여 Apache Derby에서 스키마를 생성 할 수 있습니다.

통사론

다음은 CREATE SCHEMA 문의 구문입니다.

CREATE SCHEMA schema_name AUTHORIZATION id

예

다음 예제는 Derby 데이터베이스에 my_schema라는 스키마를 작성합니다.

ij> CREATE SCHEMA AUTHORIZATION my_schema;
0 rows inserted/updated/deleted

그런 다음 아래와 같이이 스키마에 테이블을 생성 할 수 있습니다.

ij> CREATE TABLE my_schema.Emp ( Id INT NOT NULL GENERATED ALWAYS AS IDENTITY,
   Name VARCHAR(255),
   Salary INT NOT NULL,
   Location VARCHAR(255),
   Phone_Number BIGINT
);
> > > > > 0 rows inserted/updated/deleted

SHOW SCHEMAS 쿼리를 사용하여 스키마 목록을 확인할 수 있습니다. 여기에서 생성 된 스키마 목록을 찾을 수 있습니다.

ij> show schemas;
TABLE_SCHEM
------------------------------
APP
MY_SCHEMA
NULLID
SQLJ
SYS
SYSCAT
SYSCS_DIAG
SYSCS_UTIL
SYSFUN
SYSIBM
SYSPROC
SYSSTAT
12 rows selected

스키마 삭제

DROP SCHEMA 문을 사용하여 기존 스키마를 삭제할 수 있습니다.

통사론

다음은 DROPS SCHEMA 문의 구문입니다.

DROP SCHEMA my_schema RESTRICT;

예

스키마에 개체가없는 경우에만 스키마를 삭제할 수 있습니다. 스키마를 삭제하려면 모든 테이블을 삭제하고 스키마를 삭제하십시오.

ij> DROP TABLE my_schema.Emp;
0 rows inserted/updated/deleted

다음 예제는 위에서 생성 된 스키마를 삭제합니다.

ij> DROP SCHEMA my_schema RESTRICT;
0 rows inserted/updated/deleted

JDBC 예

다음 JDBC 예제는 my_schema라는 스키마를 만들고 삭제합니다.

import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.SQLException;
import java.sql.Statement;
public class CreateSchemaExample {
   public static void main(String args[]) throws Exception {
      //Registering the driver
      Class.forName("org.apache.derby.jdbc.EmbeddedDriver");
      //Getting the Connection object
      String URL = "jdbc:derby:sampleDB;create=true";
      Connection conn = DriverManager.getConnection(URL);

      //Creating the Statement object
      Statement stmt = conn.createStatement();

      stmt.execute("CREATE SCHEMA AUTHORIZATION my_schema");
      //Executing the query
      String query = "CREATE TABLE my_schema.Employees( "
         + "Id INT NOT NULL GENERATED ALWAYS AS IDENTITY, "
         + "Name VARCHAR(255), "
         + "Salary INT NOT NULL, "
         + "Location VARCHAR(255), "
         + "PRIMARY KEY (Id))";
      stmt.execute(query);
      System.out.println("Table created in schema");
      stmt.execute("DROP TABLE my_schema.Employees");
      stmt.execute("DROP SCHEMA my_schema RESTRICT");
      System.out.println("Schema dropped");
   }
}

산출

실행시 위의 프로그램은 다음과 같은 예제를 생성합니다.

Table created in schema
Schema dropped

Apache Derby-트리거

데이터베이스에서 트리거는 이벤트가 발생할 때마다 실행되는 명령문 / 코드입니다. 테이블의 특정 이벤트에 대한 트리거를 생성하면 이벤트가 발생할 때마다 트리거에 지정된 코드가 실행됩니다. 단일 테이블에 여러 트리거를 만들 수 있습니다.

이 장에서는 Apache Derby를 사용하여 트리거를 만들고 삭제하는 방법을 설명합니다.

트리거 만들기

CREATE TRIGGER 문을 사용하여 Derby에서 트리거를 작성할 수 있습니다.

통사론

다음은 CREATE TRIGGER 쿼리 구문입니다.

CREATE TRIGGER trigger_name
{ NO CASCADE BEFORE | AFTER }
{INSERT [OR] | UPDATE [OR] | DELETE}[OF col_name]
ON table_name
[REFERENCING OLD AS o NEW AS n]
[FOR EACH ROW]
Statement

예

아래와 같이 Derby에서 Emp라는 테이블을 만들었다 고 가정 해 보겠습니다.

CREATE TABLE Emp (
   Id INT NOT NULL,
   Name VARCHAR(255),
   Salary INT NOT NULL,
   Location VARCHAR(255) );

그리고 거기에 5 개의 행을 삽입했습니다.

INSERT INTO Emp(Id, Name, Salary, Location) VALUES
(1, 'Amit', 30000, 'Hyderabad'), (2, 'Kalyan', 40000, 'Vishakhapatnam'),
(3,'Renuka', 50000, 'Delhi'), (4, 'Archana', 15000, 'Mumbai'), (5, 'Trupthi',
45000, 'Kochin');

BackUp이라는 다른 테이블이 있고 Emp 테이블에서 삭제 된 행을 여기에 저장하려는 경우.

CREATE TABLE BackUp (
   Id INT NOT NULL,
   Name VARCHAR(255),
   Salary INT NOT NULL,
   Location VARCHAR(255)
);

다음 쿼리는 DELETE 쿼리 테이블에 트리거를 만듭니다. Emp. 삭제 된 행을 저장합니다.Emp 테이블 백업에.

ij> CREATE TRIGGER my_trigger
AFTER DELETE ON Emp
REFERENCING OLD AS oldRow
FOR EACH ROW MODE DB2SQL
INSERT INTO BackUp
VALUES (oldRow.Id, oldRow.Name, oldRow.Salary, oldRow.Location);

이제 Emp 테이블에서 행을 삭제하십시오.

ij> Delete From Emp where Name = 'Kalyan';
1 row inserted/updated/deleted
ij> Delete From Emp where Name = 'Amit';
1 row inserted/updated/deleted

BackUp 테이블을 확인하면 삭제 된 행을 볼 수 있습니다.

ij> select * from BackUp;
ID |NAME |SALARY |LOCATION
-------------------------------------------------------------------------
2 |Kalyan |40000 |Vishakhapatnam
1 |Amit |30000 |Hyderabad

2 rows selected

트리거 삭제

DROP TRIGGER 문을 사용하여 Derby에서 트리거를 삭제할 수 있습니다.

통사론

다음은 DROP TRIGGER 쿼리의 구문입니다-

ij> Drop trigger tigger_name;

예

다음 예제는 위에서 생성 된 my_trigger 트리거를 삭제합니다.

ij> Drop trigger my_trigger;
0 rows inserted/updated/deleted

JDBC 예

다음 JDBC 프로그램은 Derby에서 트리거를 작성하고 삭제합니다.

import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;
public class Triggers_Example {
   public static void main(String args[]) throws SQLException, ClassNotFoundException {
      //Registering the driver
      Class.forName("org.apache.derby.jdbc.EmbeddedDriver");
      //Getting the Connection object
      String URL = "jdbc:derby:TestDataBase;create=true";
      Connection conn = DriverManager.getConnection(URL);

      //Creating the Statement object
      Statement stmt = conn.createStatement();

      //Creating the Emp table
      stmt.execute("CREATE TABLE Emp ( "
         + "Id INT NOT NULL, "
         + "Name VARCHAR(255), "
         + "Salary INT NOT NULL, "
         + "Location VARCHAR(255))");

      //Insert values in to the EMp table
      String query = "INSERT INTO Emp(Id, Name, Salary, Location) VALUES \r\n"
         +"(1, 'Amit', 30000, 'Hyderabad'), "
         + "(2, 'Kalyan', 40000, 'Vishakhapatnam'), "
         + "(3,'Renuka', 50000, 'Delhi'), "
         + "(4, 'Archana', 15000, 'Mumbai'), "
         + "(5, 'Trupthi', 45000, 'Kochin')";
         stmt.execute(query);

      //Creating the BackUp table
      stmt.execute("CREATE TABLE BackUp ( "
         + "Id INT NOT NULL, "
         + "Name VARCHAR(255), "
         + "Salary INT NOT NULL, "
         + "Location VARCHAR(255))");

      //Creating a trigger
      String createTrigger = "CREATE TRIGGER my_trigger "
         + "AFTER DELETE ON Emp "
         + "REFERENCING OLD AS oldRow "
         + "FOR EACH ROW MODE DB2SQL "
         + "INSERT INTO BackUp "
         + "VALUES (oldRow.Id, oldRow.Name, oldRow.Salary, oldRow.Location)";
      stmt.execute(createTrigger);
      System.out.println("Trigger created");

      //Deleting records from Emp table
      stmt.executeUpdate("Delete From Emp where Name = 'Kalyan'");
      stmt.executeUpdate("Delete From Emp where Name = 'Amit'");
      //Getting the contents of BackUp table
      ResultSet rs = stmt.executeQuery("SELECT * from BackUp");
      while(rs.next()){
         System.out.println(rs.getInt("Id"));
         System.out.println(rs.getString("Name"));
         System.out.println(rs.getString("Salary"));
         System.out.println(rs.getString("Location"));
         System.out.println(" ");
      }
   }
}

산출

위의 프로그램을 실행하면 다음과 같은 출력이 생성됩니다.

Trigger created
2
Kalyan
40000
Vishakhapatnam
1
Amit
30000
Hyderabad