### Select All From Table

Source: https://github.com/assertj/assertj-db/blob/main/src/test/resources/output/html/test_change_output4.html

This SQL query retrieves all columns and rows from a specified table. It serves as a basic example for data retrieval.

```sql
select * from table
```

--------------------------------

### Navigate Database Changes by Type and Table

Source: https://context7.com/assertj/assertj-db/llms.txt

Filter database changes by type (creation, modification, deletion) and table name, then assert properties of individual changes. Requires setting start and end points for change tracking.

```java
import static org.assertj.db.api.Assertions.assertThat;
import org.assertj.db.type.Changes;

Changes changes = connection.changes().build();
changes.setStartPointNow();
// ... INSERT, UPDATE, DELETE operations ...
changes.setEndPointNow();

// Filter to creation changes on "movie" table and inspect the first one
assertThat(changes)
    .ofCreationOnTable("movie")
        .hasNumberOfChanges(1)
        .change()
            .isCreation()
            .hasPksValues(4)                       // primary key value of new row
            .rowAtEndPoint()
                .value("title").isEqualTo("Dune")
                .value("release_year").isEqualTo(2021);

// Filter to modification changes
assertThat(changes)
    .ofModification()
        .change()
            .isModification()
            .hasModifiedColumns("release_year")
            .rowAtStartPoint()
                .value("release_year").isEqualTo(1979)
            .rowAtEndPoint()
                .value("release_year").isEqualTo(1980);

// Filter to deletion changes on a specific table
assertThat(changes)
    .ofDeletionOnTable("movie")
        .change()
            .isDeletion()
            .rowAtStartPoint()
                .value("title").isEqualTo("The Village");

// Navigate to a change by primary key value
assertThat(changes)
    .changeOnTableWithPks("movie", 1)
        .isModification()
        .column("release_year")
            .valueAtStartPoint().isEqualTo(1979)
            .valueAtEndPoint().isEqualTo(1980);
```

--------------------------------

### BDDAssertions - BDD-style Entry Points

Source: https://context7.com/assertj/assertj-db/llms.txt

Provides BDD-style `then()` entry points as a drop-in replacement for `assertThat()`. Use for teams preferring Given/When/Then test language.

```java
import static org.assertj.db.api.BDDAssertions.then;
import org.assertj.db.type.*;

AssertDbConnection connection = 
    AssertDbConnectionFactory.of("jdbc:h2:mem:testdb", "sa", "").create();
Table table = connection.table("movie").build();

// BDD-style assertion chain — identical capability to assertThat()
then(table)
    .hasNumberOfRows(3)
    .row()
        .value("title").isEqualTo("Alien")
    .row()
        .value("title").isEqualTo("The Village")
    .column("release_year")
        .value(2).isEqualTo(2010);

// Works with Request and Changes too
Changes changes = connection.changes().build();
changes.setStartPointNow();
// ... operations ...
changes.setEndPointNow();

then(changes)
    .ofModificationOnTable("movie")
        .hasNumberOfChanges(1)
        .change()
            .isModification();

// Utility helpers also live in BDDAssertions
byte[] imageBytes = BDDAssertions.bytesContentFromClassPathOf("images/poster.png");
then(table).row().value("thumbnail").isEqualTo(imageBytes);
```

--------------------------------

### Create AssertDbConnection using AssertDbConnectionFactory

Source: https://context7.com/assertj/assertj-db/llms.txt

Use AssertDbConnectionFactory.of() to create an AssertDbConnection. This can be done from a JDBC URL with credentials or a DataSource. Optional configurations include schema metadata retrieval mode and letter case handling.

```java
import org.assertj.db.type.AssertDbConnection;
import org.assertj.db.type.AssertDbConnectionFactory;
import org.assertj.db.type.SchemaMetaDataMode;
import org.assertj.db.type.lettercase.LetterCase;
import javax.sql.DataSource;

// --- From a JDBC URL ---
AssertDbConnection connectionFromUrl =
    AssertDbConnectionFactory.of("jdbc:h2:mem:testdb", "sa", "")
        .create();

// --- From a DataSource ---
DataSource dataSource = ...; // e.g. Apache DBCP, HikariCP
AssertDbConnection connectionFromDs =
    AssertDbConnectionFactory.of(dataSource)
        .schemaMetaDataMode(SchemaMetaDataMode.STATIC)   // cache schema metadata once
        .letterCase(
            LetterCase.TABLE_DEFAULT,
            LetterCase.COLUMN_DEFAULT,
            LetterCase.PRIMARY_KEY_DEFAULT
        )
        .create();
```

--------------------------------

### AssertDbConnectionFactory.of()

Source: https://context7.com/assertj/assertj-db/llms.txt

Factory entry point for building an AssertDbConnection. Accepts either a JDBC URL with credentials or a javax.sql.DataSource, and optionally configures letter-case handling and schema metadata retrieval mode.

```APIDOC
## AssertDbConnectionFactory.of()

### Description
Factory entry point for building an `AssertDbConnection`. Accepts either a JDBC URL with credentials or a `javax.sql.DataSource`, and optionally configures letter-case handling and schema metadata retrieval mode. The resulting `AssertDbConnection` is used to build `Table`, `Request`, and `Changes` instances.

### Method
Factory method

### Endpoint
N/A (Java API)

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
None

### Request Example
```java
import org.assertj.db.type.AssertDbConnection;
import org.assertj.db.type.AssertDbConnectionFactory;
import org.assertj.db.type.SchemaMetaDataMode;
import org.assertj.db.type.lettercase.LetterCase;
import javax.sql.DataSource;

// --- From a JDBC URL ---
AssertDbConnection connectionFromUrl =
    AssertDbConnectionFactory.of("jdbc:h2:mem:testdb", "sa", "")
        .create();

// --- From a DataSource ---
DataSource dataSource = ...; // e.g. Apache DBCP, HikariCP
AssertDbConnection connectionFromDs =
    AssertDbConnectionFactory.of(dataSource)
        .schemaMetaDataMode(SchemaMetaDataMode.STATIC)   // cache schema metadata once
        .letterCase(
            LetterCase.TABLE_DEFAULT,
            LetterCase.COLUMN_DEFAULT,
            LetterCase.PRIMARY_KEY_DEFAULT
        )
        .create();
```

### Response
#### Success Response (AssertDbConnection)
- **connection** (AssertDbConnection) - An instance of AssertDbConnection ready for use.

#### Response Example
(See Request Example)
```

--------------------------------

### Load Binary Data for Assertions

Source: https://context7.com/assertj/assertj-db/llms.txt

Utility methods to load binary data into a byte array for assertions on binary columns. Use `bytesContentOf` for filesystem files and `bytesContentFromClassPathOf` for classpath resources.

```java
import static org.assertj.db.api.Assertions.*;
import java.io.File;

// From the filesystem
byte[] imageBytes = bytesContentOf(new File("/tmp/poster.png"));

// From the classpath (e.g. src/test/resources/images/poster.png)
byte[] classpathBytes = bytesContentFromClassPathOf("images/poster.png");

// Use in a value assertion
Table table = connection.table("movie").build();
assertThat(table)
    .row(0)
        .value("poster")
            .isBytes()
            .isEqualTo(classpathBytes);
```

--------------------------------

### Assertions.assertThat(Request)

Source: https://context7.com/assertj/assertj-db/llms.txt

Entry point for request assertions. Identical navigation API as table assertions — the result set is treated as an in-memory table.

```APIDOC
## `Assertions.assertThat(Request)` — Assert on a SQL query result

Entry point for request assertions. Identical navigation API as table assertions — the result set is treated as an in-memory table.

```java
import static org.assertj.db.api.Assertions.assertThat;
import org.assertj.db.type.Request;

Request request = connection
    .request("SELECT title, release_year FROM movie WHERE release_year > ?")
    .parameters(2000)
    .build();

assertThat(request)
    .hasNumberOfRows(2)
    .row()
        .value("title").isText().isEqualTo("The Village")
        .value("release_year").isNumber().isEqualTo(2004);

assertThat(request)
    .column("release_year")
        .isNumber(false)              // column type check (false = can be null)
        .hasValues(2004, 2010);
```
```

--------------------------------

### AssertDbConnection.request()

Source: https://context7.com/assertj/assertj-db/llms.txt

Builds a Request object from an arbitrary SQL query string with optional bind parameters. You can declare virtual primary key column names so that change tracking works correctly on query results that lack an inherent primary key.

```APIDOC
## AssertDbConnection.request()

### Description
Builds a `Request` object from an arbitrary SQL query string with optional bind parameters. You can declare virtual primary key column names so that change tracking works correctly on query results that lack an inherent primary key.

### Method
Instance method on AssertDbConnection

### Endpoint
N/A (Java API)

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
None

### Request Example
```java
import org.assertj.db.type.Request;

AssertDbConnection connection = 
    AssertDbConnectionFactory.of("jdbc:h2:mem:testdb", "sa", "").create();

// Simple query, no parameters
Request allMovies = connection.request("SELECT * FROM movie").build();

// Parameterized query
Request recentMovies = connection
    .request("SELECT title, release_year FROM movie WHERE release_year > ?")
    .parameters(2000)
    .build();

// Multi-parameter query with explicit primary key hint
Request specificActor = connection
    .request("SELECT id, first_name, last_name FROM actor WHERE id = ?")
    .parameters(3)
    .pksName("id")
    .build();
```

### Response
#### Success Response (Request)
- **request** (Request) - A Request assertion object.

#### Response Example
(See Request Example)
```

--------------------------------

### AssertDbConnection.table()

Source: https://context7.com/assertj/assertj-db/llms.txt

Builds a Table object representing a full database table. Supports restricting which columns are loaded, excluding specific columns, ordering rows, and wrapping identifiers with delimiters.

```APIDOC
## AssertDbConnection.table()

### Description
Builds a `Table` object representing a full database table. Supports restricting which columns are loaded (`columnsToCheck`), excluding specific columns (`columnsToExclude`), ordering rows (`columnsToOrder`), and wrapping identifiers with delimiters for databases with case-sensitive names.

### Method
Instance method on AssertDbConnection

### Endpoint
N/A (Java API)

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
None

### Request Example
```java
import org.assertj.db.type.AssertDbConnection;
import org.assertj.db.type.Table;
import static org.assertj.db.type.Table.Order.asc;
import static org.assertj.db.type.Table.Order.desc;

AssertDbConnection connection = 
    AssertDbConnectionFactory.of("jdbc:h2:mem:testdb", "sa", "").create();

// All columns, default ordering
Table movieTable = connection.table("movie").build();

// Only specific columns, ordered by release_year DESC
Table limitedTable = connection.table("movie")
    .columnsToCheck(new String[]{"id", "title", "release_year"})
    .columnsToOrder(new Table.Order[]{ desc("release_year"), asc("title") })
    .build();

// Exclude an audit column
Table withoutAudit = connection.table("actor")
    .columnsToExclude(new String[]{"last_modified_at"})
    .build();

// Quoted identifiers (e.g. case-sensitive PostgreSQL tables)
Table quotedTable = connection.table("MyTable")
    .delimiters('"', '"')
    .build();
```

### Response
#### Success Response (Table)
- **table** (Table) - A Table assertion object.

#### Response Example
(See Request Example)
```

--------------------------------

### Assertions.assertThat(Table)

Source: https://context7.com/assertj/assertj-db/llms.txt

Entry point for table assertions. Returns a TableAssert that exposes row-count, column-count, row-navigation, and column-navigation methods.

```APIDOC
## `Assertions.assertThat(Table)` — Assert on a table

Entry point for table assertions. Returns a `TableAssert` that exposes row-count, column-count, row-navigation, and column-navigation methods. Import from `org.assertj.db.api.Assertions` (or use `org.assertj.core.api.Assertions.assertThat` when the `Table` implements `AssertProvider`).

```java
import static org.assertj.db.api.Assertions.assertThat;
import org.assertj.db.type.Table;

Table table = connection.table("movie").build();

// Row count
assertThat(table).hasNumberOfRows(3);
assertThat(table).hasNumberOfRowsGreaterThan(0);
assertThat(table).hasNumberOfRowsLessThanOrEqualTo(100);
assertThat(table).isEmpty(); // 0 rows

// Column count
assertThat(table).hasNumberOfColumns(4);

// Navigate to the first row and assert a value by column name
assertThat(table)
    .row()
        .value("title").isEqualTo("Alien")
        .value("release_year").isEqualTo(1979);

// Navigate to a specific row by index (0-based)
assertThat(table)
    .row(1)
        .value("title").isEqualTo("The Village")
        .value("release_year").isEqualTo(2004);

// Navigate to a column and check all values
assertThat(table)
    .column("title")
        .hasValues("Alien", "The Village", "Inception");

// Navigate across rows and columns in a single chain
assertThat(table)
    .row()
        .value("title").isEqualTo("Alien")
    .row()
        .value("title").isEqualTo("The Village")
    .column("release_year")
        .value(2).isEqualTo(2010); // third row value
```
```

--------------------------------

### Track Database Changes with AssertJ DB

Source: https://context7.com/assertj/assertj-db/llms.txt

Use the `Changes` class to track database modifications between two points in time. You can monitor all tables, specific tables, or query results. The captured changes are exposed as `Change` objects (CREATION, MODIFICATION, DELETION) and can be asserted using `assertThat(Changes)`.

```java
import org.assertj.db.type.Changes;
import static org.assertj.db.api.Assertions.assertThat;

AssertDbConnection connection = 
    AssertDbConnectionFactory.of("jdbc:h2:mem:testdb", "sa", "").create();

// Monitor all tables
Changes allChanges = connection.changes().build();

// Monitor two specific tables only
Changes tableChanges = connection.changes()
    .table("movie")
    .table("actor")
    .build();

// Monitor a parameterized query result
Changes queryChanges = connection.changes()
    .request("SELECT * FROM movie WHERE genre = ?", r -> r.parameters("sci-fi"))
    .build();

// --- Usage pattern ---
allChanges.setStartPointNow();

// ... execute database operations ...
// e.g. jdbcTemplate.update("INSERT INTO movie (title, release_year) VALUES (?, ?)", "Dune", 2021);
// e.g. jdbcTemplate.update("UPDATE movie SET release_year = 1980 WHERE title = 'Alien'");
// e.g. jdbcTemplate.update("DELETE FROM movie WHERE title = 'The Village'");

allChanges.setEndPointNow();

// Assert on the captured changes
assertThat(allChanges)
    .hasNumberOfChanges(3)
    .hasNumberOfChangesGreaterThanOrEqualTo(1);
```

--------------------------------

### Assert Database Cell Values - Date/Time Comparisons

Source: https://context7.com/assertj/assertj-db/llms.txt

Assert equality and chronological order (before, after, before or equal to, after or equal to) for date, time, and datetime cell values using AssertJ DB's specific value types or Java 8 date/time API.

```java
// Date / time values using DateValue, TimeValue, DateTimeValue
assertThat(table).row().value("created_at")
    .isEqualTo(DateValue.of(2024, 6, 15));

assertThat(table).row().value("event_time")
    .isEqualTo(TimeValue.of(10, 30, 0));

assertThat(table).row().value("updated_at")
    .isEqualTo(DateTimeValue.of(DateValue.of(2024, 6, 15), TimeValue.of(10, 30)));

// Java 8 date/time API
assertThat(table).row().value("created_at")
    .isEqualTo(LocalDate.of(2024, 6, 15));

// Chronology assertions
assertThat(table).row().value("release_year")
    .isBefore(DateValue.of(2000, 1, 1))
    .isAfter(DateValue.of(1970, 1, 1))
    .isBeforeOrEqualTo(DateValue.of(1979, 1, 1));
```

--------------------------------

### SoftAssertions - Collect All Failures

Source: https://context7.com/assertj/assertj-db/llms.txt

Proxies standard assertions to collect all failures before reporting a single SoftAssertionError. Use when multiple assertions need to be checked regardless of prior failures.

```java
import org.assertj.db.api.SoftAssertions;
import org.assertj.db.type.*;

AssertDbConnection connection = 
    AssertDbConnectionFactory.of("jdbc:h2:mem:testdb", "sa", "").create();

Table table    = connection.table("movie").build();
Request request = connection.request("SELECT * FROM actor").build();
Changes changes = connection.changes().build();
changes.setStartPointNow();
// ... DB operations ...
changes.setEndPointNow();

SoftAssertions softly = new SoftAssertions();

// Table assertions – all evaluated even if some fail
softly.assertThat(table)
    .hasNumberOfRows(3)
    .row().value("title").isEqualTo("Alien");

// Request assertions
softly.assertThat(request)
    .hasNumberOfRows(2)
    .column("first_name").hasValues("Sigourney", "Tom");

// Changes assertions
softly.assertThat(changes)
    .ofCreation()
        .hasNumberOfChanges(1)
        .change()
            .rowAtEndPoint()
                .value("title").isEqualTo("Dune");

// Throws SoftAssertionError listing every failure (if any)
softly.assertAll();
```

--------------------------------

### Build Request assertion subject with AssertDbConnection

Source: https://context7.com/assertj/assertj-db/llms.txt

Use connection.request().build() to create a Request assertion subject from an SQL query. Supports parameterized queries and specifying virtual primary key column names for change tracking.

```java
import org.assertj.db.type.Request;

AssertDbConnection connection =
    AssertDbConnectionFactory.of("jdbc:h2:mem:testdb", "sa", "").create();

// Simple query, no parameters
Request allMovies = connection.request("SELECT * FROM movie").build();

// Parameterized query
Request recentMovies = connection
    .request("SELECT title, release_year FROM movie WHERE release_year > ?")
    .parameters(2000)
    .build();

// Multi-parameter query with explicit primary key hint
Request specificActor = connection
    .request("SELECT id, first_name, last_name FROM actor WHERE id = ?")
    .parameters(3)
    .pksName("id")
    .build();
```

--------------------------------

### Build Table assertion subject with AssertDbConnection

Source: https://context7.com/assertj/assertj-db/llms.txt

Use connection.table().build() to create a Table assertion subject. You can specify columns to check or exclude, order rows, and handle quoted identifiers for case-sensitive databases.

```java
import org.assertj.db.type.AssertDbConnection;
import org.assertj.db.type.Table;
import static org.assertj.db.type.Table.Order.asc;
import static org.assertj.db.type.Table.Order.desc;

AssertDbConnection connection =
    AssertDbConnectionFactory.of("jdbc:h2:mem:testdb", "sa", "").create();

// All columns, default ordering
Table movieTable = connection.table("movie").build();

// Only specific columns, ordered by release_year DESC
Table limitedTable = connection.table("movie")
    .columnsToCheck(new String[]{"id", "title", "release_year"})
    .columnsToOrder(new Table.Order[]{ desc("release_year"), asc("title") })
    .build();

// Exclude an audit column
Table withoutAudit = connection.table("actor")
    .columnsToExclude(new String[]{"last_modified_at"})
    .build();

// Quoted identifiers (e.g. case-sensitive PostgreSQL tables)
Table quotedTable = connection.table("MyTable")
    .delimiters('"', '"')
    .build();
```

--------------------------------

### Assert on a Table with AssertJ DB

Source: https://context7.com/assertj/assertj-db/llms.txt

Use `Assertions.assertThat(Table)` to assert properties of a database table. Supports assertions on row count, column count, and navigation to specific rows and columns for value checks. Requires importing `org.assertj.db.api.Assertions`.

```java
import static org.assertj.db.api.Assertions.assertThat;
import org.assertj.db.type.Table;

Table table = connection.table("movie").build();

// Row count
assertThat(table).hasNumberOfRows(3);
assertThat(table).hasNumberOfRowsGreaterThan(0);
assertThat(table).hasNumberOfRowsLessThanOrEqualTo(100);
assertThat(table).isEmpty(); // 0 rows

// Column count
assertThat(table).hasNumberOfColumns(4);

// Navigate to the first row and assert a value by column name
assertThat(table)
    .row()
        .value("title").isEqualTo("Alien")
        .value("release_year").isEqualTo(1979);

// Navigate to a specific row by index (0-based)
assertThat(table)
    .row(1)
        .value("title").isEqualTo("The Village")
        .value("release_year").isEqualTo(2004);

// Navigate to a column and check all values
assertThat(table)
    .column("title")
        .hasValues("Alien", "The Village", "Inception");

// Navigate across rows and columns in a single chain
assertThat(table)
    .row()
        .value("title").isEqualTo("Alien")
    .row()
        .value("title").isEqualTo("The Village")
    .column("release_year")
        .value(2).isEqualTo(2010); // third row value
```

--------------------------------

### Assert Database Cell Values - Equality

Source: https://context7.com/assertj/assertj-db/llms.txt

Assert the equality or inequality of cell values against expected values. Supports various data types including numbers, booleans, and strings. Includes checks for numeric zero.

```java
// Equality for various types
assertThat(table).row().value("title").isEqualTo("Alien");
assertThat(table).row().value("release_year").isEqualTo(1979);
assertThat(table).row().value("active").isTrue();
assertThat(table).row().value("active").isFalse();
assertThat(table).row().value("release_year").isZero();   // numeric zero check
assertThat(table).row().value("release_year").isNotZero();

// Inequality
assertThat(table).row().value("title").isNotEqualTo("Avatar");
assertThat(table).row().value("release_year").isNotEqualTo(2000);
```

--------------------------------

### Assert Database Cell Values - Numeric Comparisons

Source: https://context7.com/assertj/assertj-db/llms.txt

Perform greater than, less than, greater than or equal to, and less than or equal to assertions on numeric cell values. Useful for range checks.

```java
// Numeric comparisons
assertThat(table).row().value("release_year")
    .isGreaterThan(1970)
    .isLessThan(2000)
    .isGreaterThanOrEqualTo(1979)
    .isLessThanOrEqualTo(1979);
```

--------------------------------

### Changes

Source: https://context7.com/assertj/assertj-db/llms.txt

Track database changes between two points in time. Captures a diff of database state and exposes it as a list of Change objects.

```APIDOC
## `Changes` — Track database changes between two points in time

`Changes` captures a diff of database state between `setStartPointNow()` and `setEndPointNow()`. It can monitor all tables, a subset of tables, or a SQL query result. After capturing, the diff is exposed as a list of `Change` objects with type `CREATION`, `MODIFICATION`, or `DELETION`.

```java
import org.assertj.db.type.Changes;
import static org.assertj.db.api.Assertions.assertThat;

AssertDbConnection connection =
    AssertDbConnectionFactory.of("jdbc:h2:mem:testdb", "sa", "").create();

// Monitor all tables
Changes allChanges = connection.changes().build();

// Monitor two specific tables only
Changes tableChanges = connection.changes()
    .table("movie")
    .table("actor")
    .build();

// Monitor a parameterized query result
Changes queryChanges = connection.changes()
    .request("SELECT * FROM movie WHERE genre = ?", r -> r.parameters("sci-fi"))
    .build();

// --- Usage pattern ---
allChanges.setStartPointNow();

// ... execute database operations ...
// e.g. jdbcTemplate.update("INSERT INTO movie (title, release_year) VALUES (?, ?)", "Dune", 2021);
// e.g. jdbcTemplate.update("UPDATE movie SET release_year = 1980 WHERE title = 'Alien'");
// e.g. jdbcTemplate.update("DELETE FROM movie WHERE title = 'The Village'");

allChanges.setEndPointNow();

// Assert on the captured changes
assertThat(allChanges)
    .hasNumberOfChanges(3)
    .hasNumberOfChangesGreaterThanOrEqualTo(1);
```
```

--------------------------------

### Column Assertions - Type and Content Checks

Source: https://context7.com/assertj/assertj-db/llms.txt

Asserts column name, type, nullity, and all values across rows. Use for verifying column integrity and data content.

```java
import static org.assertj.db.api.Assertions.assertThat;
import org.assertj.db.type.*;

Table table = connection.table("movie").build();

// Column name
assertThat(table).column("title").hasColumnName("title");

// Column type (false means nullable is allowed)
assertThat(table).column("title").isText(false);
assertThat(table).column("release_year").isNumber(false);
assertThat(table).column("active").isBoolean(true); // true = NOT NULL

// All values in the column
assertThat(table).column("title")
    .hasValues("Alien", "The Village", "Inception");

assertThat(table).column("release_year")
    .hasValues(1979, 2004, 2010);

// Nullity across the column
assertThat(table).column("deleted_at").hasOnlyNullValues();
assertThat(table).column("title").hasOnlyNotNullValues();

// Number of rows surfaced via column
assertThat(table).column("title").hasNumberOfRows(3);

// containsValues (order-independent)
assertThat(table).column("release_year")
    .containsValues(2010, 1979, 2004);
```

--------------------------------

### Assert Database Cell Values - Custom Condition

Source: https://context7.com/assertj/assertj-db/llms.txt

Apply custom assertions to cell values using AssertJ's `Condition` class. This allows for flexible and complex validation logic beyond built-in assertions.

```java
// Custom AssertJ Condition
Condition<Object> positiveYear = new Condition<>(
    v -> v instanceof Number && ((Number) v).intValue() > 0, "positive year"
);
assertThat(table).row().value("release_year").satisfies(positiveYear);
```

--------------------------------

### Assert on SQL Query Result with AssertJ DB

Source: https://context7.com/assertj/assertj-db/llms.txt

Use `Assertions.assertThat(Request)` to assert on the results of a SQL query. The API is identical to table assertions, treating the result set as an in-memory table. Ensure the `Request` object is properly built with the query and parameters.

```java
import static org.assertj.db.api.Assertions.assertThat;
import org.assertj.db.type.Request;

Request request = connection
    .request("SELECT title, release_year FROM movie WHERE release_year > ?")
    .parameters(2000)
    .build();

assertThat(request)
    .hasNumberOfRows(2)
    .row()
        .value("title").isText().isEqualTo("The Village")
        .value("release_year").isNumber().isEqualTo(2004);

assertThat(request)
    .column("release_year")
        .isNumber(false)              // column type check (false = can be null)
        .hasValues(2004, 2010);
```

--------------------------------

### Assert Database Cell Values - Closeness

Source: https://context7.com/assertj/assertj-db/llms.txt

Assert that a numeric cell value is close to an expected value within a specified tolerance. Useful for floating-point comparisons.

```java
// Closeness (numeric tolerance)
assertThat(table).row().value("score")
    .isCloseTo(9.5, 0.1);
```

--------------------------------

### Assert Database Cell Values - Type Checks

Source: https://context7.com/assertj/assertj-db/llms.txt

Perform type assertions on individual cell values within a database table. Supported types include text, number, boolean, date, time, datetime, bytes, and UUID.

```java
import static org.assertj.db.api.Assertions.assertThat;
import org.assertj.db.type.*;
import org.assertj.core.api.Condition;

Table table = connection.table("movie").build();

// Type assertions
assertThat(table).row().value("title").isText();
assertThat(table).row().value("release_year").isNumber();
assertThat(table).row().value("active").isBoolean();
assertThat(table).row().value("created_at").isDate();
assertThat(table).row().value("event_time").isTime();
assertThat(table).row().value("updated_at").isDateTime();
assertThat(table).row().value("thumbnail").isBytes();
assertThat(table).row().value("uuid_col").isUUID();
```

--------------------------------

### Assert Database Cell Values - Nullity

Source: https://context7.com/assertj/assertj-db/llms.txt

Check if a cell value is null or not null. This is useful for verifying nullable columns in your database.

```java
assertThat(table).row().value("deleted_at").isNull();
assertThat(table).row().value("title").isNotNull();
```

=== COMPLETE CONTENT === This response contains all available snippets from this library. No additional content exists. Do not make further requests.