Почему PreparedStatement так называется?

Почему PreparedStatement так называется?

Краткий ответ

PreparedStatement называется "prepared" потому что оператор (SQL query) предварительно подготавливается (parsed и compiled) на стороне базы данных один раз, а затем может быть выполнен множество раз с разными параметрами. Это в отличие от обычного Statement, который парсится и компилируется каждый раз при выполнении.

История и контекст

Regular Statement (неподготовленный)

import java.sql.*;

// Плохой способ - Regular Statement
Statement stmt = connection.createStatement();

String query = "SELECT * FROM users WHERE id = " + userId;
ResultSet rs = stmt.executeQuery(query);

// Проблемы:
// 1. Строка скомбинирована с значением (SQL injection!)
// 2. При каждом выполнении БД парсит и компилирует весь SQL
// 3. Если выполнить 100 раз с разными userId, парсинг случится 100 раз

Проблемы с Regular Statement:

• SQL Injection vulnerability: Атакующий может передать вредоносный SQL
• Performance issue: Повторное парсирование одного и того же SQL паттерна
• Network overhead: Больший трафик между Java и БД (полная SQL строка каждый раз)

PreparedStatement (подготовленный)

// Хороший способ - PreparedStatement
String query = "SELECT * FROM users WHERE id = ?";  // ? = placeholder
PreparedStatement pstmt = connection.prepareStatement(query);

// Этап 1: БД подготавливает (prepares) шаблон один раз
// - Парсирование SQL
// - Валидация синтаксиса
// - Компиляция в bytecode (в СУБД)
// - Создание execution plan
// Все это сохраняется на сервере БД

// Этап 2: Выполнение с параметрами (много раз)
for (int userId : userIds) {
    pstmt.setInt(1, userId);  // Подставляем параметр
    ResultSet rs = pstmt.executeQuery();  // Только выполняем (БД уже подготовлена)
    // Обработка результатов
}

Процесс подготовки (Preparation)

┌─────────────────────────────────────────────────────────────────────────┐
│ ЖИЗНЕННЫЙ ЦИКЛ PREPAREDSTATEMENT                                       │
└─────────────────────────────────────────────────────────────────────────┘

1. PREPARATION (один раз на сервере БД):
   ┌──────────────────────────────────────┐
   │ connection.prepareStatement(query)   │
   │ "SELECT * FROM users WHERE id = ?"   │
   └──────────────────────────────────────┘
          ↓
   ┌──────────────────────────────────────┐
   │ PARSING (синтаксический анализ)      │
   │ ✓ Проверка синтаксиса SQL            │
   │ ✓ Распознание таблиц и столбцов      │
   │ ✓ Валидация типов                    │
   └──────────────────────────────────────┘
          ↓
   ┌──────────────────────────────────────┐
   │ COMPILATION (компиляция плана)       │
   │ ✓ Создание execution plan            │
   │ ✓ Оптимизация запроса                │
   │ ✓ Выбор индексов                     │
   └──────────────────────────────────────┘
          ↓
   ┌──────────────────────────────────────┐
   │ CACHING (кеширование на сервере)     │
   │ ✓ Сохранение скомпилированного плана│
   │ ✓ Готово к выполнению                │
   └──────────────────────────────────────┘
          ↓

2. EXECUTION (много раз):
   ┌──────────────────────────────────────┐
   │ pstmt.setInt(1, userId)              │
   │ pstmt.executeQuery()                 │
   └──────────────────────────────────────┘
          ↓
   ┌──────────────────────────────────────┐
   │ PARAMETER BINDING (привязка параметров) │
   │ ✓ Подставляются значения вместо ?   │
   │ ✓ Типобезопасная передача            │
   └──────────────────────────────────────┘
          ↓
   ┌──────────────────────────────────────┐
   │ EXECUTION (выполнение)               │
   │ ✓ Использование готового плана       │
   │ ✓ БД не переанализирует SQL          │
   └──────────────────────────────────────┘
          ↓
   ┌──────────────────────────────────────┐
   │ RESULTS (результаты)                 │
   │ ✓ ResultSet передается клиенту       │
   └──────────────────────────────────────┘

Практический пример: Statement vs PreparedStatement

public class StatementComparison {
    
    // ПРИМЕР 1: Regular Statement (ПЛОХООО)
    public void badWay(Connection conn, int[] userIds) throws SQLException {
        Statement stmt = conn.createStatement();
        
        for (int userId : userIds) {
            // Каждый раз БД:
            // 1. Парсит всю строку
            // 2. Компилирует execution plan
            // 3. Выполняет запрос
            String sql = "SELECT * FROM users WHERE id = " + userId;
            ResultSet rs = stmt.executeQuery(sql);
            // Обработка...
        }
    }
    
    // ПРИМЕР 2: PreparedStatement (ХОРОШО!)
    public void goodWay(Connection conn, int[] userIds) throws SQLException {
        String sql = "SELECT * FROM users WHERE id = ?";
        
        // БД парсит и компилирует ОДИН раз
        PreparedStatement pstmt = conn.prepareStatement(sql);
        
        // Затем просто выполняем много раз с разными параметрами
        for (int userId : userIds) {
            pstmt.setInt(1, userId);  // Привязываем параметр
            ResultSet rs = pstmt.executeQuery();  // Выполняем (БД уже готова)
            // Обработка...
        }
    }
}

Преимущества PreparedStatement

1. Производительность

Регулярный Statement:
100 выполнений × 100 парсингов = 100 × 100 = 10,000 единиц работы

PreparedStatement:
1 подготовка + 100 выполнений = 1 + 100 = 101 единица работы

Улучшение: ~100x (в реальности 5-50x в зависимости от БД)

2. SQL Injection Protection

// УЯЗВИМО - Regular Statement
String username = "admin' OR '1'='1";  // SQL injection
String sql = "SELECT * FROM users WHERE username = '" + username + "'";
// Реальный запрос: SELECT * FROM users WHERE username = 'admin' OR '1'='1'
// Это вернет ВСЕ пользователей!
Statement stmt = connection.createStatement();
ResultSet rs = stmt.executeQuery(sql);

// ЗАЩИЩЕНО - PreparedStatement
String username = "admin' OR '1'='1";  // То же значение
String sql = "SELECT * FROM users WHERE username = ?";
PreparedStatement pstmt = connection.prepareStatement(sql);
pstmt.setString(1, username);  // setString автоматически escapes символы
ResultSet rs = pstmt.executeQuery();
// БД ищет пользователя с username = именно "admin' OR '1'='1"
// Не находит и возвращает пустой результат (безопасно)

3. Меньший сетевой трафик

Regular Statement:
CLIENT → SERVER: "SELECT * FROM users WHERE id = 1"     (30 bytes)
CLIENT → SERVER: "SELECT * FROM users WHERE id = 2"     (30 bytes)
CLIENT → SERVER: "SELECT * FROM users WHERE id = 3"     (30 bytes)
Всего: 90 bytes для 3 запросов

PreparedStatement:
CLIENT → SERVER: "SELECT * FROM users WHERE id = ?"     (31 bytes) ONCE
CLIENT → SERVER: 1, 2, 3                                  (3 bytes each)
Всего: 31 + 3 + 3 + 3 = 40 bytes для 3 запросов

Улучшение: 90/40 = 2.25x меньше трафика

4. Типобезопасность

// Regular Statement - нет типопроверки
Statement stmt = connection.createStatement();
String query = "UPDATE users SET age = " + "not_a_number" + " WHERE id = 1";
// Ошибка только при выполнении на БД

// PreparedStatement - типопроверка на Java
PreparedStatement pstmt = connection.prepareStatement(
    "UPDATE users SET age = ? WHERE id = ?"
);
pstmt.setInt(1, 25);  // Типопроверка здесь, ошибка сразу видна
pstmt.setInt(2, 1);
pstmt.executeUpdate();

Как работает Parameter Binding

PreparedStatement pstmt = connection.prepareStatement(
    "INSERT INTO users (name, age, email) VALUES (?, ?, ?)"
);

// Привязка параметров (Parameter Binding)
pstmt.setString(1, "John Doe");      // ? → 'John Doe'
pstmt.setInt(2, 30);                 // ? → 30
pstmt.setString(3, "john@email.com"); // ? → 'john@email.com'

// БД знает типы параметров и не требует quotes вокруг чисел
// Это предотвращает SQL injection

// Итоговый запрос на БД (примерно):
// INSERT INTO users (name, age, email) VALUES ('John Doe', 30, 'john@email.com')

Connection Pooling с PreparedStatement

// Современные connection pools кешируют подготовленные statements
public class UserRepository {
    private final DataSource dataSource;
    
    public User findById(Long id) throws SQLException {
        // Даже при работе с пулом, PreparedStatement эффективнее
        try (Connection conn = dataSource.getConnection();
             PreparedStatement pstmt = conn.prepareStatement(
                 "SELECT * FROM users WHERE id = ?"
             )) {
            pstmt.setLong(1, id);
            ResultSet rs = pstmt.executeQuery();
            // Обработка...
        }
    }
}

// Многие JDBC drivers и connection pools автоматически кешируют
// подготовленные statements, дальше улучшая производительность

Когда использовать какой Statement

Вывод

PreparedStatement называется "prepared" потому что SQL-оператор предварительно подготавливается (парсится и компилируется) на стороне БД перед выполнением. Это позволяет:

1. Повысить производительность (~5-100x для повторяющихся запросов)
2. Защитить от SQL injection (благодаря parameter binding)
3. Уменьшить сетевой трафик (отправляются только параметры)
4. Обеспечить типобезопасность (на уровне Java)

Это fundamental best practice в Java разработке. Никогда не конкатенируй параметры напрямую в SQL строку — ВСЕГДА используй PreparedStatement с параметрами.