java 43 lines · 7 steps

Streaming large JDBC result sets safely

A JDBC query streams rows one at a time via fetch size and a callback instead of loading everything into memory at once.

Explained by highlit

Intermediate jdbc streaming resource-management transactions callbacks

1public List<OrderSummary> streamRecentOrders(LocalDateTime since, Consumer<OrderSummary> handler) {
  String sql = """
      SELECT id, customer_id, total_cents, status, created_at
      FROM orders
      WHERE created_at >= ?
      ORDER BY created_at
      """;
8 
  List<OrderSummary> processed = new ArrayList<>();
10 
  try (Connection conn = dataSource.getConnection()) {
      conn.setAutoCommit(false);
13 
      try (PreparedStatement ps = conn.prepareStatement(
              sql,
              ResultSet.TYPE_FORWARD_ONLY,
              ResultSet.CONCUR_READ_ONLY)) {
18 
          ps.setFetchSize(500);
          ps.setTimestamp(1, Timestamp.valueOf(since));
21 
          try (ResultSet rs = ps.executeQuery()) {
              while (rs.next()) {
                  OrderSummary order = new OrderSummary(
                          rs.getLong("id"),
                          rs.getLong("customer_id"),
                          rs.getLong("total_cents"),
                          OrderStatus.valueOf(rs.getString("status")),
                          rs.getTimestamp("created_at").toLocalDateTime());
30 
                  handler.accept(order);
                  processed.add(order);
              }
          }
      }
36 
      conn.commit();
  } catch (SQLException e) {
      throw new DataAccessException("Failed to stream recent orders", e);
  }
41 
  return processed;
43}

01 / 01

STEP 01

Walkthrough

Space play ←→ step click any line

Three takeaways

1Setting a fetch size lets the driver pull rows in batches instead of buffering the entire result set in memory.
2Nested try-with-resources guarantees every JDBC resource closes in the right order even when errors occur.
3A Consumer callback lets callers process each row as it arrives, decoupling iteration from what happens per row.

Related explainers

java

package com.example.config.condition;
 
import org.springframework.context.annotation.Condition;
import org.springframework.context.annotation.ConditionContext;

A custom @Conditional feature flag in Spring

conditional beans feature flags annotations

Intermediate 7 steps

javascript

const express = require('express');
const EventEmitter = require('events');
 
const router = express.Router();

Server-Sent Events with Express

server-sent-events streaming event-emitter

Advanced 8 steps

python

import json
import time
import queue

Server-Sent Events streaming in Flask

server-sent-events streaming pub-sub

Advanced 9 steps

java

public class DuplicateFinder {
 
    public Map<String, List<Path>> findDuplicates(Path root) throws IOException {
        Map<String, List<Path>> byHash = new HashMap<>();

Finding duplicate files by content hash

hashing file-io streams

Intermediate 8 steps

java

@Component
public class OrderRecoveryHandler {
 
    private final RabbitTemplate rabbitTemplate;

Dead-letter recovery with Spring AMQP

dead-letter-queue retry exponential-backoff

Advanced 9 steps

java

@Component
public class CorrelationIdWebFilter implements WebFilter, Ordered {
 
    public static final String CORRELATION_ID_HEADER = "X-Correlation-Id";