Dans Article précédent, l'instruction SQL INSERT, l'instruction UPDATE, l'instruction DELETE et l'instruction SELECT sont séparées par méthode et l'instruction SQL est exécutée par la méthode main. J'ai réussi à le faire. Ce n'était pas pratique car les données que je voulais ajouter, modifier ou supprimer étaient fixées dans l'instruction SQL.
Par conséquent, j'ai pensé que si je pouvais transmettre les données que je voulais ajouter lors de l'appel de chaque méthode de l'instruction SQL à partir de la méthode principale, ce serait un code source plus utile, alors je l'ai essayé.
L'environnement cette fois est le suivant.
Tout d'abord, examinons la méthode de l'instruction INSERT dans le code précédent.
Méthode de l'instruction INSERT précédente
/**
*Instruction INSERT
*/
public static void insertData() {
try {
// create a database connection
connection = DriverManager.getConnection(URL);
Statement statement = connection.createStatement();
statement.setQueryTimeout(30); // set timeout to 30 sec.
statement.executeUpdate("INSERT INTO person VALUES(1, 'Satou')");
statement.executeUpdate("INSERT INTO person VALUES(2, 'Tanaka')");
statement.executeUpdate("INSERT INTO person VALUES(3, 'Suzuki')");
} catch(SQLException e) {
// if the error message is "out of memory",
// it probably means no database file is found
System.err.println(e.getMessage());
} finally {
try {
if(connection != null)
connection.close();
} catch(SQLException e) {
// connection close failed.
System.err.println(e);
}
}
}
Comme vous pouvez le voir, les données que vous souhaitez ajouter sont fixées dans l'instruction SQL, vous ne pouvez donc pas ajouter de données arbitraires simplement en l'appelant à partir de la méthode principale.
Afin de transmettre les données que vous souhaitez ajouter lors de l'appel à partir de la méthode principale, il est nécessaire de satisfaire les deux éléments suivants.
--Utiliser des espaces réservés
--Utilisez PreparedStatement au lieu deStatement
Les espaces réservés vous permettent de transmettre des chaînes arbitraires aux instructions SQL. De plus, lorsque vous utilisez des espaces réservés, il est nécessaire de définir des instructions SQL à l'avance, il est donc maintenant possible de transmettre des données en utilisant PreparedStatement au lieu deStatement comme suit.
Code utilisant Statement
// ...
Statement statement = connection.createStatement();
statement.setQueryTimeout(30); // set timeout to 30 sec.
statement.executeUpdate("INSERT INTO person VALUES(1, 'Satou')");
statement.executeUpdate("INSERT INTO person VALUES(2, 'Tanaka')");
statement.executeUpdate("INSERT INTO person VALUES(3, 'Suzuki')");
// ...
Code utilisant PreparedStatement
// ...
String sql = "INSERT INTO person (name) VALUES(?)";
try {
PreparedStatement ps = null;
ps = connection.prepareStatement(sql);
ps.setString(1, "Satou");
ps.executeUpdate();
connection.commit();
ps.close();
} catch (SQLException e){
// ...
Note) À ce stade, «INCREMENT AUTOMATIQUE DE CLÉ PRIMAIRE» est ajouté à l'identifiant pour rendre le code source aussi facile à comprendre que possible.
Ensuite, afin de transmettre les données de la méthode main, en passant la partie data de ps.setString (1," Satou "); comme argument, la partie data de l'instruction SQL peut être arbitrairement définie par l'opération de la méthode main. J'ai pu le changer.
Le code source et le résultat de l'exécution sont décrits ci-dessous.
Ce but
import java.sql.*;
/**
* TestDataBaseAccess
*/
public class TestDataBaseAccess {
static Connection connection;
static PreparedStatement ps;
static String URL = "jdbc:sqlite:sample.db";
public static void main(String[] args) throws ClassNotFoundException {
// load the sqlite-JDBC driver using the current class loader
Class.forName("org.sqlite.JDBC");
connection = null;
ps = null;
dropTable();
createTable();
insertData("Satou");
insertData("Tanaka");
insertData("Suzuki");
loadData();
System.out.println("---------");
updateData(1, "Takahashi");
loadData();
System.out.println("---------");
deleteData(3);
loadData();
}
/**
*Instruction SELECT
*/
public static void loadData() {
try {
// create a database connection
connection = DriverManager.getConnection(URL);
Statement statement = connection.createStatement();
statement.setQueryTimeout(30); // set timeout to 30 sec.
ResultSet rs = statement.executeQuery("SELECT * FROM person");
while(rs.next()){
// read the result set
System.out.println("id = " + rs.getInt("id") + " | name = " + rs.getString("name"));
}
} catch(SQLException e) {
// if the error message is "out of memory",
// it probably means no database file is found
System.err.println(e.getMessage());
} finally {
try {
if(connection != null)
connection.close();
} catch(SQLException e) {
// connection close failed.
System.err.println(e);
}
}
}
/**
*Instruction INSERT
*/
public static void insertData(String name) {
String sql = "INSERT INTO person (name) VALUES(?)";
try {
connection = DriverManager.getConnection(URL);
connection.setAutoCommit(false);
ps = connection.prepareStatement(sql);
ps.setString(1, name);
ps.executeUpdate();
connection.commit();
ps.close();
} catch(SQLException e) {
// if the error message is "out of memory",
// it probably means no database file is found
System.err.println(e.getMessage());
} finally {
try {
if(connection != null)
connection.close();
} catch(SQLException e) {
// connection close failed.
System.err.println(e);
}
}
}
/**
*Instruction UPDATE
*/
public static void updateData(int id, String name) {
try {
String sql = "UPDATE person SET name = ? WHERE id = ?";
// create a database connection
connection = DriverManager.getConnection(URL);
connection.setAutoCommit(false);
ps = connection.prepareStatement(sql);
ps.setString(1, name);
ps.setInt(2, id);
ps.executeUpdate();
connection.commit();
ps.close();
} catch(SQLException e) {
// if the error message is "out of memory",
// it probably means no database file is found
System.err.println(e.getMessage());
} finally {
try {
if(connection != null)
connection.close();
} catch(SQLException e) {
// connection close failed.
System.err.println(e);
}
}
}
/**
*Instruction DELETE
*/
public static void deleteData(int id) {
try {
String sql = "DELETE FROM person WHERE id = ?";
// create a database connection
connection = DriverManager.getConnection(URL);
connection.setAutoCommit(false);
ps = connection.prepareStatement(sql);
ps.setInt(1, id);
ps.executeUpdate();
connection.commit();
ps.close();
} catch(SQLException e) {
// if the error message is "out of memory",
// it probably means no database file is found
System.err.println(e.getMessage());
} finally {
try {
if(connection != null)
connection.close();
} catch(SQLException e) {
// connection close failed.
System.err.println(e);
}
}
}
/**
*Créer une table
*/
public static void createTable() {
try {
// create a database connection
connection = DriverManager.getConnection(URL);
Statement statement = connection.createStatement();
statement.setQueryTimeout(30); // set timeout to 30 sec.
statement.executeUpdate("CREATE TABLE person (id INTEGER PRIMARY KEY AUTOINCREMENT, name STRING)");
} catch(SQLException e) {
// if the error message is "out of memory",
// it probably means no database file is found
System.err.println(e.getMessage());
} finally {
try {
if(connection != null)
connection.close();
} catch(SQLException e) {
// connection close failed.
System.err.println(e);
}
}
}
/**
*Supprimer la table
*/
public static void dropTable() {
try {
// create a database connection
connection = DriverManager.getConnection(URL);
Statement statement = connection.createStatement();
statement.setQueryTimeout(30); // set timeout to 30 sec.
statement.executeUpdate("DROP TABLE IF EXISTS person");
} catch(SQLException e) {
// if the error message is "out of memory",
// it probably means no database file is found
System.err.println(e.getMessage());
} finally {
try {
if(connection != null)
connection.close();
} catch(SQLException e) {
// connection close failed.
System.err.println(e);
}
}
}
}
javac TestDataBaseAccess.java && java -cp .:sqlite-jdbc-3.30.1.jar TestDataBaseAccess
id = 1 | name = Satou
id = 2 | name = Tanaka
id = 3 | name = Suzuki
---------
id = 1 | name = Takahashi
id = 2 | name = Tanaka
id = 3 | name = Suzuki
---------
id = 1 | name = Takahashi
id = 2 | name = Tanaka
Je pense que ce changement nous a rapprochés d'un code plus réutilisable. À l'avenir, j'aimerais l'utiliser dans un logiciel et en faire un meilleur code source.
[Database] SQLite3 / JDBC Summary
Recommended Posts