Student Name J.

Mukesh Reddy
Student Registration Number 231U1R1120 Class &Section: CSE & C
Study Level : UG/PG UG Year &Term: II & III
Subject Name Java Programming

Name of the Assessment

Lab Report 10
Date of Submission 10/05/2025

1. Basic JDBC Connectivity and Table Creation

2. Inserting Records into Table

3. Fetching Records from Table

4. Updating a Record
5. Deleting a Record

My data is deleted
Objective

The objective of this lab session is to explore and understand the process of Java Database
Connectivity (JDBC), which allows interaction between Java applications and relational
databases like MySQL. We will cover key operations such as creating tables, inserting
data, retrieving data, updating records, and deleting records, with an increasing level of
complexity in the SQL queries and operations.

Introduction

JDBC (Java Database Connectivity) provides a standard API for connecting Java programs
with databases using SQL. Through JDBC, Java applications can query databases, manipulate
data, and update records. The API supports various database operations like:

 Create (Create new records or tables)

 Read (Retrieve or query data)
 Update (Modify data)
 Delete (Remove data)

JDBC acts as a bridge between a Java application and the database, allowing database
interactions in a way that is independent of the specific database being used (e.g., MySQL,
Oracle, etc.).

As we increase the number of records or the complexity of database operations (e.g., using
multiple tables, advanced queries, joins, etc.), understanding and using JDBC effectively
becomes more critical for efficient data management and scalability.
Steps Involved in JDBC Database Connectivity

1. Loading and Registering the JDBC Driver

The first step to establishing JDBC connectivity involves loading the appropriate JDBC
driver into memory. The driver acts as an intermediary that enables Java to communicate
with the database. Depending on the database used, different drivers are required.

In cases where databases like MySQL are used, the MySQL JDBC Driver (Connector/J) is
needed. This driver is loaded dynamically into the application using
Class.forName("com.mysql.cj.jdbc.Driver"). In large-scale applications where multiple databases
might be used, different drivers may need to be loaded conditionally at runtime.

2. Establishing the Connection

After loading the driver, the next step is to establish a connection to the database using the
DriverManager.getConnection() method. This step is crucial for any JDBC operation.

When the connection is made to the database, it is important to ensure that the connection
pool is used to avoid the overhead of opening and closing new connections repeatedly. For
large applications with frequent database access, managing database connections efficiently
through a connection pool increases performance and reduces the load on the database server.

Example:

Connection conn = DriverManager.getConnection("jdbc:mysql://localhost:3306/testdb", "root",

"your_password");

3. Creating a Statement
Once a connection is established, a Statement object is created to execute SQL queries. For
increased performance and security in larger systems, we often use PreparedStatement
objects. These are precompiled queries that allow parameterized queries to be executed more
efficiently, reducing SQL injection risks.

For more complex applications, it's not unusual to work with batch processing where a
group of SQL statements is executed together, reducing the overhead of executing queries
one at a time.

4. Executing SQL Queries

 Basic Operations: In this step, we perform standard SQL operations like CREATE,
INSERT, SELECT, UPDATE, and DELETE.
o CREATE: Used for creating new tables, schemas, or even database structures.
o INSERT: Adds new records into a table. This can range from a simple insert
of a few records to inserting large datasets, in which case batch processing is
used to improve efficiency.
o SELECT: Retrieves data. In cases of increased complexity (e.g., large
datasets), it's often necessary to optimize SELECT queries using indexes, joins,
or pagination for better performance.
o UPDATE: Modifies existing records. As the database grows, update
operations may require more sophisticated indexing or partitioning techniques
to ensure minimal performance degradation.
o DELETE: Removes records from the table. Deletion of large volumes of data
must be handled carefully to avoid performance issues, often requiring
cascading deletes or partitioning to manage the load.
 Transaction Management: For more complex operations where multiple queries
need to be executed atomically (e.g., bank transactions), transaction management in
 JDBC ensures that all queries are executed successfully, or none are executed if there
is a failure. This is achieved through commit and rollback statements.

Example:

conn.setAutoCommit(false); // Begin transaction

stmt.executeUpdate("INSERT INTO students VALUES(1, 'John Doe', 20)");
conn.commit(); // Commit changes

5. Retrieving Data

The ResultSet object is used to store and navigate the results of a SELECT query. As data
grows in size, managing and navigating through a ResultSet efficiently becomes increasingly
important. Using methods like next(), getString(), and getInt(), we retrieve individual records.
Advanced operations such as scrollable ResultSets allow users to move the cursor in both
directions for greater flexibility.

For large-scale applications, pagination of query results is often necessary to prevent

overwhelming the user interface with too much data at once.

6. Closing the Connection

Once all database operations are complete, it is important to close the Statement, ResultSet, and
Connection objects to release the database resources and avoid memory leaks. For production
systems, connection pooling libraries such as Apache DBCP or C3P0 are used to manage
connections more efficiently by reusing database connections.

Advanced Operations in JDBC

1. Batch Processing
In real-world applications where large volumes of data are inserted or updated, batch
processing is essential. JDBC allows batch execution of multiple queries, which significantly
improves performance by reducing the number of database round-trips.

Batch processing can be done using addBatch() and executeBatch() methods. This minimizes the
network latency and ensures efficient insertion or updating of large datasets.

2. Transaction Management

When performing multiple database operations that must be completed together (for instance,
transferring money between two accounts), JDBC allows transaction management using the
commit() and rollback() methods. This ensures data consistency and integrity, which is crucial
for business-critical applications.

3. Prepared Statements

As the complexity of database queries increases, PreparedStatement becomes essential.

Prepared statements:

 Allow for parameterized queries, which prevent SQL injection attacks.

 Improve performance by pre-compiling the SQL query once, instead of compiling it
every time it’s executed.

4. Error Handling and Logging

As systems scale, proper error handling and logging become critical. JDBC allows
developers to catch SQL exceptions and handle them gracefully. For example, if a connection
fails, an exception is thrown, and proper recovery mechanisms (like retries) should be
implemented in the production environment.
Conclusion

The lab session on JDBC Database Connectivity has been essential in understanding how to
interact with databases from a Java application. As the complexity of database operations
increases, key concepts such as transaction management, batch processing, and prepared
statements become more important for ensuring both performance and security in database-
driven applications.

In large-scale applications, optimizing SQL queries, managing database connections

effectively, and ensuring the atomicity of transactions are crucial aspects of designing an
efficient database interaction layer.