docs(jdbc): add deep-dive explanation of JDBC Statement types

What
- Added an in-depth guide explaining the three JDBC statement interfaces:
  1. `Statement`
  2. `PreparedStatement`
  3. `CallableStatement`
- Covered creation, execution, use cases, and differences between them.
- Included practical code examples for each:
  - `Statement stmt = con.createStatement();`
  - `PreparedStatement pstmt = con.prepareStatement("SELECT ... WHERE deptno = ?");`
  - `CallableStatement cstmt = con.prepareCall("{call getStudentData(?,?)}");`
- Explained key supporting concepts:
  - `Connection` and `ResultSet` lifecycles.
  - Methods `executeQuery()`, `executeUpdate()`, and `execute()`.
  - Security aspects like SQL injection prevention with PreparedStatement.
  - Stored procedure calls using CallableStatement.
- Added real-world usage example for inserting data using PreparedStatement.

Why
- Developers often confuse when to use Statement vs. PreparedStatement vs. CallableStatement.
- Provides clarity on efficiency, security, and suitability for different query types.
- Establishes best practices like:
  - Prefer PreparedStatement for user inputs.
  - Use CallableStatement for stored procedures.
  - Limit Statement to simple, static SQL.

How
- Structured documentation into sections:
  - Overview → Creation → Execution → When to Use → Benefits → Practical Examples.
- Highlighted downsides of `Statement` (prone to SQL injection, inefficient).
- Showed how PreparedStatement improves performance via precompilation and parameter binding.
- Described how CallableStatement bridges Java code and server-side business logic.
- Reinforced resource management: always close `ResultSet`, `Statement`, and `Connection`.

Key Takeaways
- **Statement** → best for simple, one-off queries without parameters.
- **PreparedStatement** → best for queries with parameters, safer and more efficient.
- **CallableStatement** → best for stored procedures or DB-side functions.
- Closing resources or using try-with-resources is mandatory to avoid leaks.

Real-life Applications
- Login/authentication systems → PreparedStatement to validate credentials safely.
- Banking apps → CallableStatement to call complex stored procedures for transactions.
- Reporting dashboards → PreparedStatement for dynamic filters in queries.
- ETL or batch operations → Statement for static, bulk schema modifications.

Notes
- Use `PreparedStatement` as the default choice when dealing with user input.
- Stored procedures differ across databases → ensure JDBC driver compatibility.
- Resource handling should always use try-with-resources in modern Java.

Signed-off-by: https://github.com/Someshdiwan <[email protected]>

Author: Someshdiwan

Section28JDBCusingSQLite/JAVA SQL Interfaces/in-depth explanation of the different types of JDBC Statement object Statement PreparedStatement and CallableStatement.txt renamed to Section28JDBCusingSQLite/JAVA SQL Interfaces/Different types of JDBC Statement.txt

@@ -10,21 +10,19 @@ CallableStatement — including how they’re created, when to use them, and why
 - It is created via a Connection object’s createStatement() method.
 - Typically used for static SQL queries without parameters.
 
-### How to Create a Statement
+### How to Create a Statement:
 
 // Assume you already have a Connection object "con"
 Statement stmt = con.createStatement();
 
 ### Executing Queries with Statement
 
 1. SELECT queries:
-
    ResultSet rs = stmt.executeQuery("SELECT * FROM students");
 
    - Returns a ResultSet that you can iterate over to read rows from the database.
 
 2. DML queries (INSERT, UPDATE, DELETE):
-
    int rowsAffected = stmt.executeUpdate(INSERT INTO students VALUES (101, 'Alice', 'NY', 10));
 
    - Returns an integer indicating how many rows were affected.
@@ -54,7 +52,6 @@ PreparedStatement pstmt = con.prepareStatement(sql);
 ### Executing Queries with PreparedStatement
 
 1. Setting Parameters:
-
    pstmt.setInt(1, 10);  // Replaces the first "?" with 10
 
 2. Executing:
@@ -64,7 +61,7 @@ PreparedStatement pstmt = con.prepareStatement(sql);
    - INSERT/UPDATE/DELETE:
      int rowsAffected = pstmt.executeUpdate();
 
-### When to Use
+### When to Use:
 - For queries with parameters** (e.g., user input or variables in your code).
 - If you need to execute the same SQL statement multiple times with different parameter values,
   PreparedStatement is more efficient than Statement because the query can be precompiled by the database.
@@ -74,8 +71,8 @@ PreparedStatement pstmt = con.prepareStatement(sql);
 
 ### Key Benefits
 1. Efficiency: The SQL statement is parsed/compiled once, and can be executed multiple times.
-2. **Security: Automatic handling of special characters in parameters reduces the risk of injection attacks.
-3. **Readability: Clear separation of the SQL query structure from the data being inserted.
+2. Security: Automatic handling of special characters in parameters reduces the risk of injection attacks.
+3. Readability: Clear separation of the SQL query structure from the data being inserted.
 
 ---
 
@@ -91,15 +88,13 @@ PreparedStatement pstmt = con.prepareStatement(sql);
 // Example stored procedure call: {call getStudentData(?,?)}
 CallableStatement cstmt = con.prepareCall("{call getStudentData(?,?)}");
 
-### Using Parameters
-
+### Using Parameters:
 - You can set IN parameters with setXxx() methods, and register OUT parameters if the procedure returns values.
 
   cstmt.setInt(1, 101); // Setting an IN parameter
   cstmt.registerOutParameter(2, Types.VARCHAR); // Registering an OUT parameter
 
-### Executing
-
+### Executing:
 - Execute the stored procedure:
 
   cstmt.execute();
@@ -108,24 +103,23 @@ CallableStatement cstmt = con.prepareCall("{call getStudentData(?,?)}");
 
   String studentName = cstmt.getString(2);
 
-### When to Use
-
+### When to Use:
 - When you have stored procedures or functions in your database that perform complex tasks.
 - Useful for reusing database-side logic and possibly improving performance.
 
 ---
 
-## Important Terms and Applications
+## Important Terms and Applications:
 
-1. Connection
+1. Connection:
    - Represents a session with a specific database.
    - All statements (Statement, PreparedStatement, CallableStatement) require an active Connection.
 
-2. ResultSet
-   - Represents the **result** of a SELECT query.
+2. ResultSet:
+   - Represents the result of a SELECT query.
    - Provides methods like next(), getInt(), getString(), etc. to **iterate through rows.
 
-3. executeQuery() vs. executeUpdate() vs. execute()
+3. executeQuery() vs. executeUpdate() vs. execute():
    - executeQuery(): For SELECT statements (returns a ResultSet).
    - executeUpdate(): For INSERT, UPDATE, DELETE statements (returns an integer indicating rows affected).
    - execute(): General-purpose method for statements that might return multiple results or unknown types
@@ -139,15 +133,15 @@ CallableStatement cstmt = con.prepareCall("{call getStudentData(?,?)}");
    - Pre-compiled routines on the database server that can be invoked using CallableStatement.
    - Often used to encapsulate business logic and improve performance by reducing network calls.
 
-6. Resource Management
-   - Always close your ResultSet, Statement, and Connection objects in a finally block (or use try-with-resources)
+6. Resource Management:
+   - Always close your ResultSet, Statement, and Connection objects in a final block (or use try-with-resources)
      to avoid memory leaks.
 
 ---
 
-## Practical Example:
+Practical Example:
 
-### Using PreparedStatement for a Parameterized Query
+Using PreparedStatement for a Parameterized Query:
 
 // 1. Get a connection
 Connection con = DriverManager.getConnection("jdbc:sqlite:univ.db");
@@ -171,11 +165,10 @@ System.out.println("Rows inserted: " + rowsInserted);
 // 6. Close resources
 pstmt.close();
 con.close();
-```
 
 ---
 
-## Summary of Statement Types
+## Summary of Statement Types:
 
 1. Statement:
    - Simple, ad-hoc queries without parameters.  
@@ -191,4 +184,4 @@ con.close();
    - Invokes stored procedures or functions in the database.  
    - Useful for encapsulating complex logic on the database server side.
 
-Using these three interfaces effectively allows you to write **clean, efficient, and secure database-access code in Java.
+Using these three interfaces effectively allows you to write clean, efficient, and secure database-access code in Java.