Fluent API

dbVisitor's Fluent API provides a fluent, chainable interface for building database operations. No SQL required — it handles CRUD, conditional queries, pagination, aggregation, and automatically adapts to all supported database dialects.

Highlights

Universal database access without writing SQL — builds query conditions via chained API calls and generates cross-database compatible SQL automatically.
Offers Entity mode (entity class + Lambda method references) and Freedom mode (table name + string column names).
Rich condition methods: eq, ne, gt, ge, lt, le, like, in, between, isNull, nested and/or, etc.
Supports sample query (eqBySample): pass an entity object and non-null properties automatically become equality conditions.
Built-in pagination (initPage / usePage), sorting (orderBy), and group aggregation (groupBy / having).
Built-in duplicate key strategy: Into (default, throws exception), Ignore (silently skip), Update (upsert).
All parameters are passed via prepared-statement placeholders, inherently preventing SQL injection.

Declare Entity Class

Establish table mapping with annotations
@Table("users")
public class User {
    @Column(name = "id", primary = true, keyType = KeyTypeEnum.Auto)
    private Long id;
    @Column("name")
    private String name;
    @Column("age")
    private Integer age;
    ...
}

Create

Create via DataSource or Connection
LambdaTemplate lambda = new LambdaTemplate(dataSource);
// or
LambdaTemplate lambda = new LambdaTemplate(connection);

Insert

Single / Multiple / Conflict strategy
// Insert one row
lambda.insert(User.class)
      .applyEntity(user1)
      .executeSumResult();

// Insert multiple rows
lambda.insert(User.class)
      .applyEntity(user1, user2, user3)
      .executeSumResult();

// Upsert on duplicate key
lambda.insert(User.class)
      .onDuplicateStrategy(DuplicateKeyStrategy.Update)
      .applyEntity(user1)
      .executeSumResult();

Update and Delete

Conditional update / delete
// Conditional update
lambda.update(User.class)
      .eq(User::getId, 1)
      .updateTo(User::getName, "NewName")
      .updateTo(User::getAge, 30)
      .doUpdate();

// Conditional delete
lambda.delete(User.class)
      .eq(User::getId, 1)
      .doDelete();

Conditional Query

Chained conditions + pagination + sorting
// Multi-condition equality query
List<User> users = lambda.query(User.class)
                         .eq(User::getName, "Alice")
                         .ge(User::getAge, 20)
                         .queryForList();

// Sample query: non-null properties become conditions
User sample = new User();
sample.setName("Alice");
List<User> users = lambda.query(User.class)
                         .eqBySample(sample)
                         .queryForList();

// Paginated query
List<User> page1 = lambda.query(User.class)
                         .like(User::getName, "User%")
                         .initPage(10, 0)     // 10 rows per page, page 0
                         .orderBy("id")
                         .queryForList();

Freedom Mode

No entity class — use table names and string column names
// Insert
Map<String, Object> row = new HashMap<>();
row.put("name", "FreedomUser");
row.put("age", 25);
lambda.insertFreedom("user_info")
      .applyMap(row)
      .executeSumResult();

// Query
Map<String, Object> result = lambda.queryFreedom("user_info")
                                   .eq("name", "FreedomUser")
                                   .queryForObject();

For more details on the Fluent API, see:

Declare Entity Class​

Create​

Insert​

Update and Delete​

Conditional Query​

Freedom Mode​