Prepared Statements vs Statement & JDBC Driver Types

Part 1: Difference Between PreparedStatement and Statement

Example of Statement:

Statement stmt = con.createStatement();
ResultSet rs = stmt.executeQuery("SELECT * FROM users WHERE id = 1");

Example of PreparedStatement:

PreparedStatement pstmt = con.prepareStatement("SELECT * FROM users WHERE id = ?");
pstmt.setInt(1, 1);
ResultSet rs = pstmt.executeQuery();

Part 2: Types of JDBC Drivers

There are 4 types of JDBC drivers:

Type 1: JDBC-ODBC Bridge Driver

• Converts JDBC method calls into ODBC method calls.
• Requires an ODBC driver to be installed and configured on the client machine.
• Does not directly interact with the database.
• Can connect to any type of database.
• Least efficient due to multiple layers of conversion.

Type 2: Native-API Driver

• Written partially in Java and partially in native code.
• Converts JDBC method calls into native calls of the database API.
• The Native-API of the specific database must be installed on the client system before use.
• Faster than Type 1 but still requires native installation.

Type 3: Net Pure Java Driver (Network Protocol Driver)

• Fully written in Java.
• The JDBC driver on the client machine uses a socket to communicate with middleware at the server.
• Client database access requests are sent through the network to the middleware, which then communicates with the database.
• No client-side database installation required.

Type 4: Pure Java Driver (Thin Driver)

• Fully written in Java, hence it is a portable driver.
• Interacts directly with the database without any middleware or native library.
• No client-side or server-side installation required.
• Most commonly used driver in modern applications.

Summary: Type 4 (Pure Java Driver) is the most preferred driver due to its portability, direct database interaction, and no dependency on native libraries.

Socket Programming: Circle Area Computation

What is a Socket?

A socket is an endpoint for communication between two machines over a network. It provides a mechanism for two programs (client and server) to communicate with each other using standard input/output streams. In Java, the Socket class (client side) and ServerSocket class (server side) from the java.net package are used to establish TCP-based socket communication.

Steps for Writing Server Program:

1. Create an object of ServerSocket class
2. Accept the connection from the client
3. Get input and output streams from the client
4. Read/Write data to the socket
5. Close streams and socket

Steps for Writing Client Program:

1. Open a socket
2. Open input and output streams to the socket
3. Read from and write to the socket streams
4. Close the socket

Server Program

import java.net.*;
import java.io.*;

public class CircleServer {
    public static void main(String args[]) throws IOException {

        // Step 1: Create ServerSocket on port 1254
        ServerSocket ss = new ServerSocket(1254);
        System.out.println("Server is waiting for client...");

        // Step 2: Accept connection from client
        Socket cs = ss.accept();
        System.out.println("Client connected.");

        // Step 3: Get input and output streams
        Scanner ins = new Scanner(cs.getInputStream());
        PrintWriter outs = new PrintWriter(cs.getOutputStream(), true);

        // Step 4: Read radius sent by client
        double radius = ins.nextDouble();
        System.out.println("Radius received from client: " + radius);

        // Step 5: Compute area of circle
        double area = Math.PI * radius * radius;
        System.out.println("Computed Area: " + area);

        // Step 6: Send computed area back to client
        outs.println(area);

        // Step 7: Close streams and socket
        ins.close();
        outs.close();
        cs.close();
        ss.close();
    }
}

Client Program

import java.net.*;
import java.io.*;
import java.util.*;

public class CircleClient {
    public static void main(String args[]) throws IOException {

        // Step 1: Open a socket and connect to server at localhost, port 1254
        Socket cs = new Socket("localhost", 1254);

        // Step 2: Open input and output streams
        Scanner ins = new Scanner(cs.getInputStream());
        PrintWriter outs = new PrintWriter(cs.getOutputStream(), true);

        // Step 3: Read radius from user
        Scanner userInput = new Scanner(System.in);
        System.out.print("Enter radius of circle: ");
        double radius = userInput.nextDouble();

        // Step 4: Send radius to server
        outs.println(radius);

        // Step 5: Receive computed area from server
        double area = ins.nextDouble();

        // Step 6: Display the area
        System.out.println("Area of circle received from Server: " + area);

        // Step 7: Close streams and socket
        ins.close();
        outs.close();
        cs.close();
    }
}

Sample Output

-- Server Side --
Server is waiting for client...
Client connected.
Radius received from client: 7.0
Computed Area: 153.93804002589985

-- Client Side --
Enter radius of circle: 7
Area of circle received from Server: 153.93804002589985

Summary of Communication Flow

Client                          Server
  |                               |
  |--- sends radius (7.0) ------> |
  |                               | computes area = π * r²
  |<-- receives area (153.93) --- |
  |                               |
displays area                  displays area

Note: Both programs use port 1254 for communication. The server must be started before the client. The formula used is Area = π × r² computed using Math.PI in Java.

Short Notes

a. Grid Layout

GridPane (Grid Layout in JavaFX) is a layout manager that arranges nodes in a flexible grid of rows and columns. It allows multiple nodes to be placed in multiple rows and columns within a single container.

Key Features:

• Nodes can be placed in any cell of the grid by specifying the column index and row index.
• The grid is flexible -- rows can have different heights and columns can have different widths.
• A more advanced form, GridBagLayout, is a sophisticated and flexible layout manager that allows components to span more than one cell.
• It is useful for creating form-like interfaces where labels and input fields are aligned in rows and columns.

Example Usage (JavaFX GridPane):

GridPane grid = new GridPane();
grid.add(new Label("Name:"), 0, 0);   // column 0, row 0
grid.add(new TextField(), 1, 0);      // column 1, row 0
grid.add(new Label("Email:"), 0, 1);  // column 0, row 1
grid.add(new TextField(), 1, 1);      // column 1, row 1

This creates a structured, tabular arrangement of UI components.

b. Ragged Array

A ragged array (also called a jagged array) is a multidimensional array in Java where each row can have a different number of columns. Unlike a regular 2D array where all rows have the same length, a ragged array allows rows of varying sizes.

Key Features:

• In Java, a 2D array is essentially an array of arrays, so each row can be independently sized.
• This saves memory when rows do not need equal lengths.
• Each row is a separate one-dimensional array object.

Declaration and Initialization:

int[][] ragged = new int[3][];   // 3 rows, columns not yet defined

ragged[0] = new int[2];          // row 0 has 2 columns
ragged[1] = new int[4];          // row 1 has 4 columns
ragged[2] = new int[3];          // row 2 has 3 columns

Visual Representation:

Row 0:  [ ][ ]
Row 1:  [ ][ ][ ][ ]
Row 2:  [ ][ ][ ]

Example with values:

int[][] ragged = {
    {1, 2},
    {3, 4, 5, 6},
    {7, 8, 9}
};

Ragged arrays are particularly useful in applications like triangular matrices or storing data of unequal lengths, where allocating equal-sized rows would waste memory.