jdbd-and-databases

shreyyq · shreyyq · commit 502d907f3227 · 2024-05-19T14:49:57.000+05:30
diff --git a/docs/java/jdbc-and-databases/connecting-to-a-database.md b/docs/java/jdbc-and-databases/connecting-to-a-database.md
@@ -0,0 +1,72 @@
+To connect to a database using JDBC, you need to follow these steps:
+
+1. **Load the JDBC Driver**: Load the appropriate JDBC driver for the database you want to connect to. The driver class must be included in your classpath.
+
+2. **Establish Connection**: Create a connection to the database by providing the database URL, username, and password.
+
+3. **Create Statement**: Create a Statement object to execute SQL queries against the database.
+
+4. **Execute Query**: Execute SQL queries using the Statement object.
+
+5. **Process Results**: Process the results returned by the query.
+
+6. **Close Resources**: Close the ResultSet, Statement, and Connection objects when you're done to release database resources.
+
+Here's an example of how to connect to a MySQL database using JDBC:
+
+```java
+import java.sql.*;
+
+public class MySQLExample {
+    public static void main(String[] args) {
+        // Database connection parameters
+        String url = "jdbc:mysql://localhost:3306/mydatabase";
+        String username = "username";
+        String password = "password";
+
+        // JDBC objects
+        Connection connection = null;
+        Statement statement = null;
+        ResultSet resultSet = null;
+
+        try {
+            // Load the MySQL JDBC driver
+            Class.forName("com.mysql.cj.jdbc.Driver");
+
+            // Establish connection
+            connection = DriverManager.getConnection(url, username, password);
+
+            // Create statement
+            statement = connection.createStatement();
+
+            // Execute query
+            resultSet = statement.executeQuery("SELECT * FROM mytable");
+
+            // Process results
+            while (resultSet.next()) {
+                int id = resultSet.getInt("id");
+                String name = resultSet.getString("name");
+                // Process other columns as needed
+                System.out.println("ID: " + id + ", Name: " + name);
+            }
+        } catch (ClassNotFoundException e) {
+            e.printStackTrace();
+        } catch (SQLException e) {
+            e.printStackTrace();
+        } finally {
+            // Close resources
+            try {
+                if (resultSet != null) resultSet.close();
+                if (statement != null) statement.close();
+                if (connection != null) connection.close();
+            } catch (SQLException e) {
+                e.printStackTrace();
+            }
+        }
+    }
+}
+```
+
+Replace `"jdbc:mysql://localhost:3306/mydatabase"`, `"username"`, and `"password"` with your actual database URL, username, and password respectively.
+
+Remember to handle exceptions properly and close resources in a finally block to ensure proper cleanup even if an exception occurs.
diff --git a/docs/java/jdbc-and-databases/executing-sql-statements-and-transactions.md b/docs/java/jdbc-and-databases/executing-sql-statements-and-transactions.md
@@ -0,0 +1,87 @@
+To execute SQL statements and transactions using JDBC, you can use the Statement and PreparedStatement interfaces. Here's how you can execute SQL statements and transactions:
+
+### Executing SQL Statements
+
+1. **Statement**: Use when you have a static SQL query that does not contain user input.
+
+```java
+try {
+    Statement statement = connection.createStatement();
+    ResultSet resultSet = statement.executeQuery("SELECT * FROM my_table");
+    // Process ResultSet
+    statement.close();
+} catch (SQLException e) {
+    e.printStackTrace();
+}
+```
+
+2. **PreparedStatement**: Use when you have a dynamic SQL query that may contain user input.
+
+```java
+try {
+    PreparedStatement preparedStatement = connection.prepareStatement("SELECT * FROM my_table WHERE id = ?");
+    preparedStatement.setInt(1, 1); // Set parameter values
+    ResultSet resultSet = preparedStatement.executeQuery();
+    // Process ResultSet
+    preparedStatement.close();
+} catch (SQLException e) {
+    e.printStackTrace();
+}
+```
+
+### Executing Transactions
+
+1. **Auto-commit Mode**: By default, JDBC operates in auto-commit mode, where each SQL statement is automatically committed as soon as it is executed. To start a transaction, you need to disable auto-commit.
+
+```java
+try {
+    connection.setAutoCommit(false); // Disable auto-commit
+    // Execute SQL statements
+    connection.commit(); // Commit transaction
+} catch (SQLException e) {
+    e.printStackTrace();
+    try {
+        connection.rollback(); // Rollback transaction if an exception occurs
+    } catch (SQLException ex) {
+        ex.printStackTrace();
+    }
+} finally {
+    try {
+        connection.setAutoCommit(true); // Enable auto-commit
+    } catch (SQLException ex) {
+        ex.printStackTrace();
+    }
+}
+```
+
+2. **Savepoints**: You can set savepoints within a transaction to mark points where you can rollback to if necessary.
+
+```java
+try {
+    connection.setAutoCommit(false); // Disable auto-commit
+    // Execute SQL statements
+    Savepoint savepoint = connection.setSavepoint("savepoint1"); // Set savepoint
+    // More SQL statements
+    connection.rollback(savepoint); // Rollback to savepoint
+    connection.commit(); // Commit transaction
+} catch (SQLException e) {
+    e.printStackTrace();
+    try {
+        connection.rollback(); // Rollback transaction if an exception occurs
+    } catch (SQLException ex) {
+        ex.printStackTrace();
+    }
+} finally {
+    try {
+        connection.setAutoCommit(true); // Enable auto-commit
+    } catch (SQLException ex) {
+        ex.printStackTrace();
+    }
+}
+```
+
+### Note:
+
+- Always handle exceptions properly and close resources in a finally block to ensure proper cleanup.
+- Use PreparedStatement to prevent SQL injection attacks and improve performance.
+- Transactions are typically used when you need to execute multiple SQL statements as a single unit of work, ensuring data consistency.
diff --git a/docs/java/jdbc-and-databases/introduction-to-jdbc.md b/docs/java/jdbc-and-databases/introduction-to-jdbc.md
@@ -0,0 +1,89 @@
+
+
+## Introduction to JDBC
+
+Java Database Connectivity (JDBC) is a Java API for connecting and interacting with relational databases from Java programs. It provides a standard interface for Java applications to access databases, execute SQL queries, and manipulate database data.
+
+### Key Components of JDBC
+
+1. **Driver Manager**: Manages a list of database drivers. It is responsible for loading the appropriate driver based on the database URL provided by the application.
+
+2. **Driver**: Implements the JDBC interfaces to communicate with a specific type of database. Each database vendor provides its own JDBC driver.
+
+3. **Connection**: Represents a connection to a database. It is used to establish communication with the database and provides methods for executing SQL statements.
+
+4. **Statement**: Represents an SQL statement to be executed against the database. It can be a simple statement, a prepared statement, or a callable statement.
+
+5. **ResultSet**: Represents the result of a query executed against the database. It provides methods for navigating through the rows of the result set and retrieving column values.
+
+### Steps to Use JDBC
+
+1. **Load the Driver**: Register the JDBC driver using `Class.forName()` or let the DriverManager automatically load the appropriate driver.
+
+2. **Establish Connection**: Create a connection to the database using `DriverManager.getConnection()` method by providing the database URL, username, and password.
+
+3. **Create Statement**: Create a Statement object using the connection to execute SQL queries.
+
+4. **Execute Query**: Execute SQL queries using the Statement object. For example, `executeQuery()` for SELECT queries and `executeUpdate()` for INSERT, UPDATE, DELETE queries.
+
+5. **Process Results**: Process the results returned by the query using the ResultSet object.
+
+6. **Close Resources**: Close the ResultSet, Statement, and Connection objects when they are no longer needed to release database resources.
+
+### Example Code Snippet
+
+```java
+import java.sql.*;
+
+public class JDBCDemo {
+    public static void main(String[] args) {
+        try {
+            // Load the driver
+            Class.forName("com.mysql.cj.jdbc.Driver");
+
+            // Establish connection
+            String url = "jdbc:mysql://localhost:3306/mydatabase";
+            String username = "username";
+            String password = "password";
+            Connection connection = DriverManager.getConnection(url, username, password);
+
+            // Create statement
+            Statement statement = connection.createStatement();
+
+            // Execute query
+            ResultSet resultSet = statement.executeQuery("SELECT * FROM employees");
+
+            // Process results
+            while (resultSet.next()) {
+                int id = resultSet.getInt("id");
+                String name = resultSet.getString("name");
+                double salary = resultSet.getDouble("salary");
+                System.out.println("ID: " + id + ", Name: " + name + ", Salary: " + salary);
+            }
+
+            // Close resources
+            resultSet.close();
+            statement.close();
+            connection.close();
+        } catch (ClassNotFoundException | SQLException e) {
+            e.printStackTrace();
+        }
+    }
+}
+```
+
+### JDBC Drivers
+
+There are four types of JDBC drivers:
+
+1. **Type 1 (JDBC-ODBC Bridge)**: Uses ODBC (Open Database Connectivity) to connect to databases. It requires native code and is platform-dependent.
+
+2. **Type 2 (Native-API Driver)**: Uses a database-specific native library to communicate with the database. It is platform-dependent and requires native code.
+
+3. **Type 3 (Network Protocol Driver)**: Communicates with a middle-tier server using a database-independent protocol, which then communicates with the database. It is platform-independent but requires additional software.
+
+4. **Type 4 (Thin Driver, JDBC Net Pure Java Driver)**: Communicates directly with the database using a pure Java implementation. It is platform-independent and does not require additional software.
+
+### Conclusion
+
+JDBC provides a powerful and flexible API for Java applications to interact with relational databases. By following the JDBC architecture and using appropriate drivers, developers can easily connect to databases, execute SQL queries, and manage database data from their Java programs.
