JDBC Quiz ( Advanced ) - All Questions

This advanced JDBC quiz is designed for experienced Java developers preparing for senior backend and database-focused interviews. It covers transaction isolation, connection pooling, batch optimization, metadata internals, concurrency issues, performance tuning, and real-world JDBC production scenarios.

Question 1: What is the primary drawback of using auto-commit mode in high-traffic applications?

Data inconsistency
Increased network round trips
Deadlocks
Memory leaks

Explanation: Auto-commit commits every statement, increasing round trips.

Question 2: Which JDBC isolation level prevents dirty reads?

READ UNCOMMITTED
READ COMMITTED
REPEATABLE READ
SERIALIZABLE

Explanation: READ COMMITTED prevents dirty reads.

Question 3: Which isolation level prevents phantom reads completely?

READ COMMITTED
REPEATABLE READ
SERIALIZABLE
READ UNCOMMITTED

Explanation: SERIALIZABLE prevents phantom reads.

Question 4: What is a phantom read in JDBC transactions?

Reading uncommitted data
Reading deleted rows
Seeing new rows in repeated queries
Incorrect data type mapping

Explanation: Phantom reads occur when new rows appear between queries.

Question 5: Which JDBC object is NOT thread-safe?

Connection
PreparedStatement
ResultSet
All of the above

Explanation: JDBC objects are generally not thread-safe.

Question 6: Why should a JDBC Connection not be shared across threads?

It causes compilation errors
It breaks SQL syntax
It can lead to data corruption
It disables pooling

Explanation: Concurrent access may corrupt transaction state.

Question 7: What is the main benefit of connection pooling?

Lower memory usage
Reduced connection creation overhead
Automatic indexing
Improved query syntax

Explanation: Pooling avoids expensive connection creation.

Question 8: Which library is commonly used for JDBC connection pooling?

Hibernate
HikariCP
Jackson
JUnit

Explanation: HikariCP is a high-performance JDBC pool.

Question 9: What happens if a connection is not returned to the pool?

Compilation fails
Pool exhaustion occurs
Auto-commit is enabled
Connection is reused

Explanation: Leaked connections exhaust the pool.

Question 10: Which JDBC feature ensures atomicity?

Batch processing
Transactions
PreparedStatement
Indexes

Explanation: Transactions ensure atomic execution.

Question 11: Why is batch processing faster than individual statements?

Uses more memory
Reduces database round trips
Skips validation
Disables constraints

Explanation: Batching minimizes network calls.

Question 12: What happens if one statement fails in a batch?

All statements succeed
Only failed statement rolls back
Execution stops and throws exception
Batch is ignored

Explanation: Batch execution stops and throws an exception.

Question 13: Which exception provides partial batch execution results?

SQLException
BatchUpdateException
SQLWarning
RuntimeException

Explanation: BatchUpdateException contains update counts.

Question 14: Which JDBC method improves performance for repeated queries?

execute()
executeQuery()
PreparedStatement reuse
ResultSet caching

Explanation: PreparedStatements can be reused efficiently.

Question 15: Why should ResultSet be closed early?

Improve syntax
Free database cursors
Avoid deadlocks
Improve indexing

Explanation: Open ResultSets hold DB resources.

Question 16: Which ResultSet type reflects database changes dynamically?

TYPE_FORWARD_ONLY
TYPE_SCROLL_INSENSITIVE
TYPE_SCROLL_SENSITIVE
TYPE_READ_ONLY

Explanation: TYPE_SCROLL_SENSITIVE reflects DB changes.

Question 17: What is the risk of using TYPE_SCROLL_SENSITIVE?

Lower accuracy
Higher memory usage
Unexpected data changes
Compilation errors

Explanation: Data may change during traversal.

Question 18: Which metadata provides information about DB capabilities?

ResultSetMetaData
DatabaseMetaData
StatementMetaData
DriverMetaData

Explanation: DatabaseMetaData describes DB features.

Question 19: Which JDBC feature supports optimistic locking?

Isolation levels
Version columns
Auto-commit
Batch processing

Explanation: Version columns enable optimistic locking.

Question 20: Why is optimistic locking preferred over pessimistic locking?

More secure
Better performance under low contention
Simpler syntax
Lower memory usage

Explanation: Optimistic locking avoids heavy locks.

Question 21: Which JDBC call retrieves database warnings?

getWarnings()
getErrors()
getExceptions()
getLogs()

Explanation: getWarnings() retrieves SQLWarning.

Question 22: What is the main risk of using Statement instead of PreparedStatement?

Lower performance only
SQL injection vulnerability
No batch support
No transaction support

Explanation: Statements are vulnerable to SQL injection.

Question 23: Which JDBC feature supports streaming large result sets?

Batch processing
Fetch size
Auto-commit
Metadata

Explanation: Fetch size enables streaming.

Question 24: What does setFetchSize() control?

Batch size
Rows fetched per round trip
Transaction size
ResultSet type

Explanation: It controls how many rows are fetched at once.

Question 25: Why should fetch size be tuned carefully?

Affects SQL syntax
Impacts memory and latency
Breaks transactions
Disables pooling

Explanation: Large fetch sizes increase memory usage.

Question 26: Which JDBC object manages transaction boundaries?

Statement
ResultSet
Connection
Driver

Explanation: Connection controls commit and rollback.

Question 27: What happens if commit() is never called?

Changes are saved automatically
Changes are rolled back on close
DB crashes
Connection leaks

Explanation: Uncommitted changes are rolled back.

Question 28: Which JDBC feature supports fail-fast behavior?

Auto-commit
Connection validation
Batch execution
Lazy loading

Explanation: Validation detects broken connections early.

Question 29: Why should try-with-resources be used in JDBC?

Better syntax
Automatic resource cleanup
Improved performance
Thread safety

Explanation: It prevents resource leaks.

Question 30: Which JDBC object is most expensive to create?

ResultSet
Statement
Connection
PreparedStatement

Explanation: Connections are costly to create.

Question 31: Which practice improves JDBC scalability most?

Auto-commit
Connection pooling
Large ResultSets
Scrollable cursors

Explanation: Pooling improves scalability.

Question 32: What is the impact of long-running transactions?

Better consistency
Increased lock contention
Lower memory usage
Improved throughput

Explanation: Long transactions hold locks longer.

Question 33: Which JDBC feature helps prevent lost updates?

Batching
Isolation levels
Fetch size
Metadata

Explanation: Higher isolation prevents lost updates.

Question 34: Which JDBC API is best for high-frequency inserts?

Statement
PreparedStatement with batch
CallableStatement
ResultSet

Explanation: PreparedStatement batching is optimal.

Question 35: What does getUpdateCount() return after execute()?

Always zero
Number of affected rows
ResultSet size
Transaction count

Explanation: It returns affected row count.

Question 36: Which JDBC feature enables database portability?

DriverManager
Standardized API
Metadata
Pooling

Explanation: JDBC standardizes DB access.

Question 37: Why should vendor-specific SQL be minimized?

Security issues
Reduces portability
Slower execution
Compilation errors

Explanation: Vendor SQL limits portability.

Question 38: Which JDBC feature is most critical in microservices?

Scrollable ResultSet
Connection pooling
Metadata usage
Batch size

Explanation: Pooling is critical for scalability.

Question 39: What is the main cause of JDBC connection leaks?

Wrong SQL
Unclosed connections
Invalid drivers
Slow queries

Explanation: Connections not closed cause leaks.

Question 40: Which monitoring metric best indicates JDBC health?

Table count
Active connection count
Schema size
Index count

Explanation: Active connections reflect pool health.

Question 41: Which JDBC feature supports large object handling?

Batch processing
BLOB and CLOB
Metadata
Isolation levels

Explanation: BLOB/CLOB handle large data.

Question 42: Why should streams be used for BLOBs?

Simpler syntax
Avoid loading entire object into memory
Faster compilation
Automatic commits

Explanation: Streams reduce memory usage.

Question 43: Which JDBC feature helps detect slow queries?

Batch processing
Query timeout
Auto-commit
Metadata

Explanation: Query timeout limits execution time.

Question 44: Which method cancels a long-running query?

stop()
cancel()
terminate()
rollback()

Explanation: cancel() stops query execution.

Question 45: Which JDBC feature is essential for ACID compliance?

PreparedStatement
Transactions
Batch processing
Fetch size

Explanation: Transactions enforce ACID.

Question 46: Which JDBC practice best supports maintainability?

Hardcoded SQL
Centralized DAO layer
Inline queries
Static connections

Explanation: DAO layer improves maintainability.

Question 47: What is the ultimate goal of using JDBC correctly?

Faster compilation
Reliable, scalable database interaction
Avoid SQL usage
Simpler syntax

Explanation: JDBC aims for scalable and reliable DB access.

Back to programming Quizzes

JDBC Quiz ( Advanced )

Questions

Minutes

Min Limit