Apache-derby-quick-guide
Apache Derby-はじめに
Apache Derbyは* R elational D atabase M anagement S * ystemであり、Javaプログラミング言語に完全に基づいています（作成/実装）。 これは、Apache Software Foundationによって開発されたオープンソースデータベースです。
Oracleは、JavaDBという名前のApache Derbyに相当するものをリリースしました。
Apache Derbyの機能
以下は、Derbyデータベースの注目すべき機能です-
- プラットフォームに依存しない-Derbyは、データベース内のデータベースが、データベースと同じ名前のディレクトリ内のディスク内のファイルに保存されるオンディスクデータベース形式を使用します。
- データを変更しない-このため、データを変更せずにダービーデータベースを他のマシンに移動できます。
- トランザクションサポート-Derbyは、データの整合性を保証するトランザクションを完全にサポートします。
- データベースを含める-ビルド前/既存のデータベースを現在のダービーアプリケーションに含めることができます。
- スペースが少ない-Derbyデータベースはフットプリントが小さい、つまり占有スペースが少なく、 簡単に使用および展開できます。
- * Javaアプリケーションで埋め込み*-Derbyは、Javaアプリケーションに組み込むことができる組み込みデータベースエンジンを提供し、アプリケーションと同じJVMで実行されます。 ドライバーをロードするだけでデータベースが起動し、アプリケーションで停止します。
Apache Derbyの制限
Apache Derbyの制限は次のとおりです-
- Derbyは、BLOBやLONGVARCHARなどのデータ型のインデックスをサポートしていません。
- Derbyに十分なディスク容量がない場合、すぐにシャットダウンします。
データストレージ
データを保存する間、Apache Derbyは conglomerate として知られる概念に従います。 この場合、テーブルのデータは別のファイルに保存されます。 同様に、テーブルの各インデックスも個別のファイルに保存されます。 したがって、データベース内のすべてのテーブルまたはインデックスに個別のファイルがあります。
Apache Derbyライブラリ/コンポーネント
Apache Derbyディストリビューションは、さまざまなコンポーネントを提供します。 ダウンロードしたApacheディストリビューションのlibフォルダーでは、さまざまなコンポーネントを表すjarファイルを確認できます。
| Jar file | Component | Description |
|---|---|---|
| derby.jar | Database Engine and JDBC driver |
The Database engine of Apache Derby is an embedded relational database engine which supports JDBC and SQL API’s. これは組み込みドライバーとしても機能し、これを使用してJavaアプリケーションを使用してDerbyと通信できます。 |
| derbynet.jar derbyrun.jar | Network server | The Network Sever of Apache Derby provides the client server functionality, where the clients can connect to the Derby server through a network. |
| derbyclient.jar | Network client JDBC driver | |
| derbytools.jar | Command line tools | This jar file holds tools such as sysinfo, ij, and dblook. |
| derbyoptionaltools.jar | Optional command line utilities (tools) | This jar file provides optional tools: databaseMetaData optional tool, foreignViews optional tool, luceneSupport optional tool, rawDBReader optional tool, simpleJson optional tool, etc |
| derbyLocale_XX.jar | Jar files to localize messages | In addition to the above mentioned jar files, you can see several derbyLocale_XX.jar (es, fr, hu, it, ja, etc.). Using these, you can localize the messages of Apache Derby. |
Apache Derby-展開モード
Apache derbyは、埋め込みモードとサーバーモードの2つのモードでデプロイできます。
埋め込みモード
Javaアプリケーション（埋め込みドライバーを使用）を使用して、埋め込みモードでダービーを実行できます。 Derbyを組み込みモードでデプロイすると、データベースエンジンはJavaアプリケーションと同じJVMで実行されます。 アプリケーションで開始および停止します。 このアプリケーションでのみデータベースにアクセスできます。
サーバーモード
サーバーモードでは、ダービーはアプリケーションサーバーのJVMで実行され、サーバーにアクセスするリクエストをサーバーに送信できます。 組み込みモードとは異なり、複数のアプリケーション（java）はサーバーにリクエストを送信し、データベースにアクセスできます。
Apache Derby-環境設定
次の章では、Apache Derbyをダウンロードしてインストールする方法について説明します。
Apache Derbyのダウンロード
Apache Derbyホームページのホームページhttps://db.apache.org/derby/にアクセスしてください。 [ダウンロード]タブをクリックします。
Apache Derbyの最新バージョンのリンクを選択してクリックします。
選択したリンクをクリックすると、Apacheダービーの Distributions ページにリダイレクトされます。 ここで確認した場合、derbyは、db-derby-bin、db-derbylib.zip、db-derby-lib-debug.zip、およびdb-derby-src.zipという配布を提供しています。
*db-derby-bin* フォルダーをダウンロードします。 そのコンテンツを、Apache Derbyをインストールする別のフォルダーにコピーします。 （たとえば、 *C：\ Derby* と言います）さて、ダービーと仕事をするために、
- Javaインストールフォルダーのbinフォルダーの場所を渡すことで、 JAVA_HOME 変数が既に設定されていることを確認し、PATH変数に JAVA_HOME/bin を含めます。
- 値C：\ Derbyを使用して、新しい環境変数 DERBY_HOME を作成します。
- db-derby-binディストリビューションのbinフォルダー（C：\ Derby \ binに変更）には、必要なすべてのjarファイルが含まれています。
説明したように、Apache Derbyは次の2つの方法でインストール/デプロイできます-
- 埋め込みモード-これでは、埋め込みDerby JDBCドライバーを使用してデータベースにアクセスする必要があります。 Javaアプリケーションからダービーを開始および停止できます。 データベースエンジンとアプリケーションの両方が同じJVMで実行されます。
- ネットワークサーバーモード-このモードでは、Derbyがサーバーシステムに組み込まれている一般的なクライアントサーバー形式でDerbyにアクセスできます。 次に、別のJVM（サーバーのJVM）で実行されているクライアントマシンがサーバーにリクエストを送信し、サーバーがそれらのリクエストに応答します。
クライアントは、サーバーの同じシステムマシン内の別のJVMでも、リモートシステムのJavaアプリケーションでもかまいません。
組み込みモードでのDerbyのインストール
Apache Derbyを埋め込みモードでインストールするには、jarファイル derby.jar をCLASSPATHに含めます。
または、 setEmbeddedCP コマンドを実行して、必要なjarファイルのクラスパスを設定できます。 Apache Derbyの bin ディレクトリを参照し、以下に示すようにこのファイルを実行します-
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\finddevguides\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\finddevguides\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に含める必要があります。
または、 setNetworkServerCP コマンドを実行して、必要なjarファイルのクラスパスを設定できます。 Apache Derbyの bin ディレクトリを参照し、以下に示すようにこのファイルを実行します-
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\finddevguides\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\finddevguides\Google Drive\Office\37.Junit
Update\jars;C:\Program Files\Apache Software Foundation\Tomcat
8.5\lib\*;C:\Derby\lib\*;サーバーモードでのDerbyの起動
コマンド startNetworkServer を実行して、Network Serverを起動できます。 Apache Derbyの bin ディレクトリを参照し、次のようにこのコマンドを実行します-
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.jar をCLASSPATHに追加します。 または、以下に示すように 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\finddevguides\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\finddevguides\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 Pathを以下のように選択します-
*Libraries* タブの *Java Build Path* フレームで、 *Add External JARs* をクリックします。そして、Derbyインストールフォルダーのlibフォルダーで必要な jar ファイルを選択し、*適用して閉じる*をクリックします。
Apache Derby-ツール
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\finddevguides\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\finddevguides\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: finddevguides
Java user home: C:\Users\finddevguides
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シェル*を提供します-
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-構文
この章では、すべての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_nameSQL 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);UNIQUEインデックスの作成
CREATE UNIQUE INDEX index_name on table_name (column_name);複合インデックスの作成
CREATE INDEX index_name on table_name (column_name1, column_name2);インデックスの表示
SHOW INDEXES FROM table_name;インデックスの削除
DROP INDEX index_name;Apache Derby-データ型
データ型は、オブジェクトのデータ型を指定する属性です。 各列、変数、および式には、関連するデータ型があります。 テーブルの作成中にこれらのデータ型を使用できます。 要件に基づいて、テーブル列のデータ型を選択できます。
Derby Serverは、以下にリストされているように、使用のためのデータ型のいくつかのカテゴリを提供します-
整数の数値データ型
以下は、整数の数値データ型のリストです-
| DATA TYPE | SIZE | FROM | TO |
|---|---|---|---|
| SMALLINT | 2 bytes | -32768 | 32767 |
| INTEGER | 4 bytes | -2,147,483,648 | 2,147,483,647 |
| BIGINT | 8 bytes | -9223372036854775808 | 9223372036854775808 |
おおよその数値データ型
以下は、おおよその数値データ型のリストです-
| DATA TYPE | SIZE | FROM | TO |
|---|---|---|---|
| REAL | 4 bytes | -3.40E + 38 | 3.40E + 38 |
| DOUBLE PRECISION | 8 bytes | -1.79E + 308 | 1.79E + 308 |
| FLOAT | -1.79E + 308 | 1.79E + 308 |
正確な数値データ型
以下は、正確な数値データ型のリストです-
| DATA TYPE | FROM | TO |
|---|---|---|
| DECIMAL | -10^38 +1 | 10^38 -1 |
| NUMERIC | -10^38 +1 | 10^38 -1 |
Apache Derby-テーブルの作成
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ステートメントは、4列の Student という名前のテーブルを作成します。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/deletedDESCRIBEコマンドは、テーブルが存在する場合、列とその詳細をリストすることにより、指定されたテーブルを記述します。 このコマンドを使用して、テーブルが作成されているかどうかを確認できます。
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 selectedJDBCプログラムを使用してテーブルを作成する
このセクションでは、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 は、クラス名を表す文字列値を受け入れてメモリにロードし、メモリが自動的に登録します。 この方法を使用してドライバーを登録します。
ステップ2：接続を取得する
一般に、データベースと通信するための最初のステップは、データベースとの接続です。 Connection クラスは、データベースサーバーとの物理的な接続を表します。 DriverManager クラスの* getConnection（）*メソッドを呼び出すことにより、接続オブジェクトを作成できます。 このメソッドを使用して接続を作成します。
ステップ3：ステートメントオブジェクトを作成する
SQLステートメントをデータベースに送信するには、 Statement 、 PreparedStatement、またはCallableStatement オブジェクトを作成する必要があります。 これらは、それぞれ* 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 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 createdApache Derby-ドロップテーブル
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 STUDENTJDBCプログラムを使用したテーブルの削除
このセクションでは、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：ドライバーを登録する
データベースと通信するには、まずドライバーを登録する必要があります。 クラス Class の* forName（）*メソッドは、クラス名を表す文字列値を受け入れて、メモリにロードし、メモリが自動的に登録します。 この方法を使用してドライバーを登録します。
ステップ2：接続を取得する
一般に、データベースと通信するための最初のステップは、データベースとの接続です。 Connection クラスは、データベースサーバーとの物理的な接続を表します。 DriverManager クラスの* getConnection（）*メソッドを呼び出すことにより、接続オブジェクトを作成できます。 このメソッドを使用して接続を作成します。
ステップ3：ステートメントオブジェクトを作成する
SQLステートメントをデータベースに送信するには、 Statement 、 PreparedStatement 、または CallableStatement オブジェクトを作成する必要があります。 これらは、それぞれ* 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.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 droppedApache Derby-データの挿入
挿入クエリは、データを挿入します：新しいレコード、テーブルに。
構文
INSERTステートメントの基本的な構文は次のとおりです-
ij>INSERT INTO table_name VALUES (column_name1, column_name2, ...);ここで、column1、column2は、挿入される行の列値です。
例
次のSQL INSERTステートメントは、Studentテーブルに新しい行を挿入し、 id、age、firstname 、 lastname の列に値を挿入します。
SQL> INSERT INTO Student VALUES (101, 20, 'Zara', 'Ali');構文2
または、以下に示すように、列名を言及することにより、2つの特定の列を挿入することができます-
ij>INSERT INTO table_name VALUES (column_name1, column_name2, ...) VALUES
(value1, value2, ...);注-Apache Derbyは、生成された列の値を自動的に計算します。 たとえば、このチュートリアルの前半で作成したstudentテーブルのid列の値を渡す必要はありません。 テーブルで列が生成されている場合は、 syntax2 を使用します。
例
ij> INSERT INTO Student(Age, First_Name, Last_Name) VALUES (21, 'Sucharitha' , 'Tyagi');
1 row inserted/updated/deletedまた、次のように1つのステートメントを使用して2行を挿入することもできます-
ij>INSERT INTO Student(Age, First_Name, Last_Name) VALUES (20, 'Amit',
'Bhattacharya'), (22, 'Rahul', 'Desai');
2 rows inserted/updated/deletedSELECTコマンドを使用して、テーブルの内容を確認できます（このコマンドについては、このチュートリアルで後ほど説明します）。
構文3
次のように挿入ステートメントで別のクエリを使用できます-
INSERT INTO table_Name Query例
学生テーブルと同様の列を持つ以下に示すように、データベースに First_Year という名前のテーブルがあるとします-
ID |AGE |FIRST_NAME |LAST_NAME
-----------------------------------------------------------------
1 |20 |Raju |Pendyala
2 |21 |Bhargav |Prayaga
3 |22 |Deepthi |Yerramilli次のように上記の構文を使用して、この表の値を学生表に挿入できます-
ij> INSERT INTO Student (Age, First_Name, Last_Name)
SELECT Age, First_Name, Last_Name FROM First_Year;
> 3 rows inserted/updated/deleted上記のすべての挿入ステートメントを実行した後、学生テーブルは次のようになります-
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 |YerramilliJDBCプログラムを使用したデータの挿入
このセクションでは、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 は、クラス名を表す文字列値を受け入れてメモリにロードし、メモリが自動的に登録します。 この方法を使用してドライバーを登録します。
ステップ2：接続を取得する
一般に、データベースと通信するための最初のステップは、データベースとの接続です。 Connection クラスは、データベースサーバーとの物理的な接続を表します。 DriverManager クラスの* getConnection（）*メソッドを呼び出すことにより、接続オブジェクトを作成できます。 このメソッドを使用して接続を作成します。
ステップ3：ステートメントオブジェクトを作成する
SQLステートメントをデータベースに送信するには、 Statement 、 PreparedStatement、またはCallableStatement オブジェクトを作成する必要があります。 これらは、それぞれ* 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 insertedApache Derby-データの取得
SELECTステートメントは、テーブルからデータを取得するために使用されます。 これは、結果セットと呼ばれるテーブルの形式でデータを返します。
構文
SELECTステートメントの構文は次のとおりです-
ij> SELECT column_name, column_name, ... FROM table_name;
Or,
Ij>SELECT * from table_name例
以下に示すように、データベースに従業員という名前のテーブルがあると仮定します-
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 selectedJDBCプログラムを使用してデータを取得する
このセクションでは、JDBCアプリケーションを使用してApache Derbyデータベースのテーブルからデータを取得する方法を説明します。
ネットワーククライアントを使用してDerbyネットワークサーバーを要求する場合は、サーバーが稼働中であることを確認してください。 ネットワーククライアントドライバーのクラス名はorg.apache.derby.jdbc.ClientDriverで、URLはjdbc：derby：//localhost：1527/* DATABASE_NAME ; create = true; user = *USER_NAME ; passw ord = です。 *パスワード*"
Apache Derbyのテーブルからデータを取得するには、以下の手順に従ってください-
ステップ1：ドライバーを登録する
データベースと通信するには、まずドライバーを登録する必要があります。 クラス Class の* forName（）*メソッドは、クラス名を表す文字列値を受け入れて、メモリにロードし、メモリが自動的に登録します。 この方法を使用してドライバーを登録します。
ステップ2：接続を取得する
一般に、データベースと通信するための最初のステップは、データベースとの接続です。 Connection クラスは、データベースサーバーとの物理的な接続を表します。 DriverManager クラスの* getConnection（）*メソッドを呼び出すことにより、接続オブジェクトを作成できます。 このメソッドを使用して接続を作成します。
ステップ3：ステートメントオブジェクトを作成する
SQLステートメントをデータベースに送信するには、 Statement 、 PreparedStatement 、または CallableStatement オブジェクトを作成する必要があります。 これらを作成するには、それぞれ* createStatement（）、 prepareStatement（）、および prepareCall（）*メソッドを使用します。 適切な方法を使用して、これらのオブジェクトのいずれかを作成します。
ステップ4：クエリを実行する
ステートメントを作成したら、それを実行する必要があります。 Statement クラスは、* execute（）メソッドなどのクエリを実行して、複数の結果セットを返すステートメントを実行するためのさまざまなメソッドを提供します。 * executeUpdate（）*メソッドは、INSERT、UPDATE、DELETEなどのクエリを実行します。 データなどを返す結果への executeQuery（）*メソッド これらのメソッドのいずれかを使用して、以前に作成したステートメントを実行します。
例
次のJDBCの例は、JDBCプログラムを使用してApache Derbyのテーブルからデータを取得する方法を示しています。 ここでは、組み込みドライバーを使用して、sampleDBという名前のデータベースに接続しています（存在しない場合は作成されます）。
- executeQuery（）メソッドは、ステートメントの結果を保持する *ResultSet オブジェクトを返します。 最初は結果セットポインターは最初のレコードにあり、* next（）および getXXX（）*メソッドを使用してResultSetオブジェクトの内容を印刷できます。
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: 39000Apache Derby-データの更新
UPDATEステートメントは、テーブル内のデータを更新するために使用されます。 Apache Derbyは、 searched 更新と positioned 更新の2種類の更新（構文）を提供します。
検索された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/deletedEmployeesテーブルの内容を取得すると、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 selectedJDBCプログラムを使用したデータの更新
このセクションでは、JDBCアプリケーションを使用してApache Derbyデータベースのテーブルの既存のレコードを更新する方法について説明します。
ネットワーククライアントを使用してDerbyネットワークサーバーを要求する場合は、サーバーが稼働中であることを確認してください。 ネットワーククライアントドライバーのクラス名はorg.apache.derby.jdbc.ClientDriverで、URLはjdbc：derby：//localhost：1527/* DATABASE_NAME ; create = true; user = *USER_NAME ; passw ord = です。 *パスワード*"
以下の手順に従って、Apache Derbyのテーブルの既存のレコードを更新します。
ステップ1：ドライバーを登録する
データベースと通信するには、まずドライバーを登録する必要があります。 クラス Class の* forName（）*メソッドは、クラス名を表す文字列値を受け入れて、メモリにロードし、メモリが自動的に登録します。 この方法を使用してドライバーを登録します。
ステップ2：接続を取得する
一般に、データベースと通信するための最初のステップは、データベースとの接続です。 Connectionクラスは、データベースサーバーとの物理的な接続を表します。 DriverManager クラスの* getConnection（）*メソッドを呼び出すことにより、接続オブジェクトを作成できます。 このメソッドを使用して接続を作成します。
ステップ3：ステートメントオブジェクトを作成する
SQLステートメントをデータベースに送信するには、 Statement 、 PreparedStatement、またはCallableStatement オブジェクトを作成する必要があります。 これらを作成するには、それぞれ* 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: 1Apache Derby-データの削除
DELETEステートメントは、テーブルの行を削除するために使用されます。 UPDATEステートメントと同様に、Apache Derbyには、 searched deleteと positioned deleteの2種類の削除（構文）があります。
検索された削除ステートメントは、テーブルの指定されたすべての列を削除します。
構文
DELETE文の構文は次のとおりです-
ij> DELETE FROM table_name WHERE condition;例
以下に示すように5つのレコードを持つ従業員という名前のテーブルがあると仮定します-
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あなたが従業員テーブルの内容を取得する場合、以下に示すように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さて、あなたが従業員テーブルの内容を取得しようとすると、以下に示すように空のテーブルを取得します-
ij> select *from employees;
ID |NAME |SALARY |LOCATION
--------------------------------------------------------
0 rows selectedJDBCプログラムを使用してデータを削除する
このセクションでは、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のテーブルの既存のレコードを削除します：/p>
ステップ1：ドライバーを登録する
まず、データベースと通信するためにドライバーを登録する必要があります。 クラス Class の* forName（）*メソッドは、クラス名を表す文字列値を受け入れて、メモリにロードし、メモリが自動的に登録します。 この方法を使用してドライバーを登録します。
ステップ2：接続を取得する
一般に、データベースと通信するための最初のステップは、データベースとの接続です。 Connection クラスは、データベースサーバーとの物理接続を表します。 DriverManager クラスの* getConnection（）*メソッドを呼び出すことにより、接続オブジェクトを作成できます。 このメソッドを使用して接続を作成します。
ステップ3：ステートメントオブジェクトを作成する
SQLステートメントをデータベースに送信するには、 Statement 、 PreparedStatement、またはCallableStatement オブジェクトを作成する必要があります。 これらは、それぞれ* 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 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: 1Apache 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 selectedWhere節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です= パスワード* "。
以下の手順に従って、WHERE句を使用し、Apache DerbyのテーブルでCURD操作を実行します。
ステップ1：ドライバーを登録する
データベースと通信するには、まずドライバーを登録する必要があります。 クラス Class の* forName（）*メソッドは、クラス名を表す文字列値を受け入れて、メモリにロードし、メモリが自動的に登録します。 この方法を使用してドライバーを登録します
ステップ2：接続を取得する
一般に、データベースと通信するための最初のステップは、データベースとの接続です。 Connection クラスは、データベースサーバーとの物理的な接続を表します。 DriverManager クラスの* getConnection（）*メソッドを呼び出すことにより、接続オブジェクトを作成できます。 このメソッドを使用して接続を作成します。
ステップ3：ステートメントオブジェクトを作成する
SQLステートメントをデータベースに送信するには、 Statement 、 PreparedStatement 、または CallableStatement オブジェクトを作成する必要があります。 これらは、それぞれ* createStatement（）、prepareStatement（）、およびprepareCall（）*メソッドを使用して作成できます。 適切な方法を使用して、これらのオブジェクトのいずれかを作成します。
ステップ4：クエリを実行する
ステートメントを作成したら、それを実行する必要があります。 Statement クラスは、* execute（）メソッドなどのクエリを実行して、複数の結果セットを返すステートメントを実行するためのさまざまなメソッドを提供します。 * executeUpdate（）*メソッドは、INSERT、UPDATE、DELETEなどのクエリを実行します。 データを返す executeQuery（）*メソッドの結果。 これらのメソッドのいずれかを使用して、以前に作成したステートメントを実行します。
例
次のJDBCの例は、WHERE句を使用し、JDBCプログラムを使用してApache Derbyのテーブルで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: LucknowApache Derby-GROUP BY句
GROUP BY句は、SELECTステートメントで使用されます。 同じデータの場合にサブセットを形成するために使用されます。 通常、この句の後にORDER BY句が続き、WHERE句の後に配置されます。
構文
GROUP BY句の構文は次のとおりです-
ij>SELECT column1, column2, . . . table_name GROUP BY column1, column2, . . .;例
次のレコードを持つデータベースに従業員という名前のテーブルがあると仮定します-
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 |LucknowGROUP 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 selectedGroup By句JDBCの例
このセクションでは、Group By句を使用して、JDBCアプリケーションを使用してApache DerbyデータベースのテーブルでCURD操作を実行する方法を説明します。
ネットワーククライアントを使用してDerbyネットワークサーバーを要求する場合は、サーバーが稼働中であることを確認してください。 ネットワーククライアントドライバーのクラス名はorg.apache.derby.jdbc.ClientDriverで、URLはjdbc：derby：//localhost：1527/* DATABASE_NAME; create = true; user = USER_NAME; です。 passw ord = * *PASSWORD * "
以下の手順に従って、Group By句を使用し、Apache DerbyのテーブルでCURD操作を実行します
ステップ1：ドライバーを登録する
データベースと通信するには、まずドライバーを登録する必要があります。 クラス Class の* forName（）*メソッドは、クラス名を表す文字列値を受け入れて、メモリにロードし、メモリが自動的に登録します。 この方法を使用してドライバーを登録します。
ステップ2：接続を取得する
一般に、データベースと通信するための最初のステップは、データベースとの接続です。 Connection クラスは、データベースサーバーとの物理的な接続を表します。 DriverManager クラスの* getConnection（）*メソッドを呼び出すことにより、接続オブジェクトを作成できます。 このメソッドを使用して接続を作成します。
ステップ3：ステートメントオブジェクトを作成する
SQLステートメントをデータベースに送信するには、 Statement 、 PreparedStatement 、または CallableStatement オブジェクトを作成する必要があります。 これらは、それぞれ* createStatement（）、prepareStatement（）、およびprepareCall（）*メソッドを使用して作成できます。 適切な方法を使用して、これらのオブジェクトのいずれかを作成します。
ステップ4：クエリを実行する
ステートメントを作成したら、それを実行する必要があります。 Statement クラスは、* execute（）*メソッドなどのクエリを実行して、複数の結果セットを返すステートメントを実行するためのさまざまなメソッドを提供します。 * executeUpdate（）*メソッドは、INSERT、UPDATE、DELETEなどのクエリを実行するために使用されます。 * executeQuery（）*メソッドはデータを返します。 これらのメソッドのいずれかを使用して、以前に作成したステートメントを実行します。
例
次のJDBCの例は、 Group By 句を使用し、JDBCプログラムを使用して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: 93000Apache Derby-句による順序
ORDER BY句は、キーワードを使用する順序で結果セットの内容を配置するために使用されます。ASCは昇順を表し、DESCは降順を表します。 これらのいずれにも言及しない場合、コンテンツはデフォルトで昇順で配置されます。
構文
以下は、ORDER BY句の構文です-
SELECT *FROM table_name ORDER BY column_name ASC|DESC.例
次のレコードを持つデータベースに従業員という名前のテーブルがあると仮定します-
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 selectedJDBCプログラムを使用したデータのソート
このセクションでは、JDBCを使用してDerbyのテーブルの内容をソートする方法を説明します。 ORDER BY句とキーワードASC（昇順を示す）、およびDSC（降順を示す）を使用して、レコードを順番に並べることができます。
ネットワーククライアントを使用してDerbyネットワークサーバーを要求する場合は、サーバーが稼働中であることを確認してください。 ネットワーククライアントドライバーのクラス名はorg.apache.derby.jdbc.ClientDriverで、URLはjdbc：derby：//localhost：1527/* DATABASE_NAME; create = true; user = USER_NAME; です。 passw ord = * *PASSWORD * "。
Apache Derbyのテーブルのレコードをソートするには、以下の手順に従ってください-
ステップ1：ドライバーを登録する
データベースと通信するには、まずドライバーを登録する必要があります。 クラス Class の* forName（）*メソッドは、クラス名を表す文字列値を受け入れて、メモリにロードし、メモリが自動的に登録します。 この方法を使用してドライバーを登録します。
ステップ2：接続を取得する
*ConnectiongetConnection（）DriverManager*ステップ3：ステートメントオブジェクトを作成する
SQLステートメントをデータベースに送信するには、 Statement 、 PreparedStatement 、または CallableStatement オブジェクトを作成する必要があります。 これらは、それぞれ* 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.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: 33000Apache Derby-句を持っている
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 selectedJDBCプログラムを使用したデータのソート
このセクションでは、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：ドライバーを登録する
データベースと通信するには、まずドライバーを登録する必要があります。 クラス Class の* forName（）*メソッドは、クラス名を表すString値を受け入れ、それをメモリにロードします。メモリに自動的に登録されます。 この方法を使用してドライバーを登録します。
ステップ2：接続を取得する
一般に、データベースと通信するための最初のステップは、データベースとの接続です。 Connection クラスは、データベースサーバーとの物理的な接続を表します。 DriverManager クラスの* getConnection（）*メソッドを呼び出すことにより、接続オブジェクトを作成できます。 このメソッドを使用して接続を作成します。
ステップ3：ステートメントオブジェクトを作成する
SQLステートメントをデータベースに送信するには、 Statement 、 PreparedStatement、またはCallableStatement オブジェクトを作成する必要があります。 これらは、それぞれ* createStatement（）、prepareStatement（）、およびprepareCall（）*メソッドを使用して作成できます。 適切な方法を使用して、これらのオブジェクトのいずれかを作成します。
ステップ4：クエリを実行する
ステートメントを作成したら、それを実行する必要があります。 Statement クラスは、* execute（）*メソッドなどのクエリを実行して、複数の結果セットを返すステートメントを実行するためのさまざまなメソッドを提供します。 * executeUpdate（）*メソッドは、INSERT、UPDATE、DELETEなどのクエリを実行します。 * executeQuery（）*メソッドはデータを返します。 これらのメソッドのいずれかを使用して、以前に作成したステートメントを実行します。
例
次のJDBCの例は、Group By句を使用し、JDBCプログラムを使用してApache Derbyのテーブルで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
45000Apache 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)
);そして、挿入ステートメントを使用して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/deletedDESCRIBEコマンドは、テーブルが存在する場合、列とその詳細をリストすることにより、指定されたテーブルを記述します。 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ステートメントを使用して、Phone_No列に制約 UNIQUE を追加しようとしています。
ij> ALTER TABLE Employees ADD CONSTRAINT New_Constraint UNIQUE(Phone_No);
0 rows inserted/updated/deletedUNIQUE制約を列に追加すると、2つの行に同じ値を持つことはできません。つまり、電話番号は従業員ごとに一意である必要があります。
同じ電話番号で2つの列を追加しようとすると、以下に示すように例外が発生します。
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/deletedPhone_No列のUNIQUE制約を削除したため、同じ電話番号の列を追加できます。
ij> INSERT INTO Employees (Name, Salary, Location, Age, Phone_No) VALUES
('Sumit', 35000, 'Chennai', 25, 9848022338);
1 row inserted/updated/deleted次のように、テーブルij> select * 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 という名前の列を削除します-
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 |YESJDBCプログラムを使用したテーブルの変更
以下は、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: 9848022338Apache 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/deletedUNIQUEインデックスの作成
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/deletedPhone_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'.複合インデックスの作成
2つの行に単一のインデックスを作成できます。これは複合インデックスと呼ばれます。
構文
以下は複合インデックスの構文です。
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インデックスのリストを確認すると、残りの列が削除されているため、1つの列のインデックスを確認できます。
ij> SHOW INDEXES FROM Emp;
TABLE_NAME |COLUMN_NAME |NON_U&|TYPE|ASC&|CARDINA&|PAGES
----------------------------------------------------------------------------
EMP |SALARY |true |3 |A |NULL |NULL
1 row selectedJDBCプログラムを使用したインデックスの処理
次の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_indexApache 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/deletedProcedureExampleクラスは次のようになります-
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/deletedApache 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/deletedJDBCの例
次の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 droppedApache Derby-トリガー
データベースでは、トリガーはイベントが発生するたびに実行されるステートメント/コードです。 テーブルの特定のイベントに対するトリガーを作成すると、トリガーで指定されたコードは、イベントが発生するたびに実行されます。 1つのテーブルに複数のトリガーを作成できます。
この章では、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例
以下に示すように、ダービーに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)
);次のクエリは、 Emp という名前のDELETEクエリテーブルにトリガーを作成します。 Emp の削除された行をテーブルBackupに保存します。
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/deletedBackUpテーブルを確認すると、削除された行を確認できます。
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/deletedJDBCの例
次の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
