DEV Community: ts5432

Building Query Conditions In JooqTemplate

ts5432 — Wed, 21 Oct 2026 00:01:12 +0000

Using JooqTemplate requires no code generation and no XML configuration.

Add Dependency

gradle:

implementation 'net.sf.sprtool:sprtool-jooq:1.7.0'

maven:

<dependency>
    <groupId>net.sf.sprtool</groupId>
    <artifactId>sprtool-jooq</artifactId>
    <version>1.7.0</version>
</dependency>

Inject JooqTemplate

import static net.sf.sprtool.jooq.JooqFields.*;

import net.sf.sprtool.jooq.JooqTemplate;

@Autowired
private JooqTemplate jt;

Using JooqTemplate

Method 1: conditions() — Field-Value Pair Varargs (Recommended)

conditions(Object... fieldValuePairs) takes arguments in pairs of "field name, value"; the operator is written directly after the field name string, and when no operator is written the default is ==. It returns a List<Condition>, and conditions whose values are null are automatically ignored:

// name = 'Smartphone' and price > 1000 and status = 'on_sale'
List<Condition> conds = jt.conditions(
        "name", "Smartphone",
        "price>", 1000,        // the > operator follows the field name
        "stock<=", 50,         // the <= operator
        "status", "on_sale");  // default operator ==

// You can also separate the field and operator with a colon: "price:>"
List<Condition> conds2 = jt.conditions("price:>", 1000);

When a parameter value is null, that condition is ignored — ideal for dynamic queries: if the frontend doesn't send a value, no filter is applied:

// When nameParam is null, no name condition is generated
List<Condition> conds = jt.conditions("name", nameParam, "category", categoryParam);

You can also mix native jOOQ Condition objects directly into the varargs:

Condition other = DSL.field("price").ge(1000);
List<Condition> conds = jt.conditions("category", "Electronics", other);

Method 2: and() / or() — Directly Returning a Single Combined Condition

and(...) and or(...) take arguments exactly like conditions(); the difference is the return value: multiple conditions are merged with AND / OR into a single Condition, and null is returned when there are no conditions at all:

// AND: name = 'John' and age > 30 and status = 'active'
Condition cond = jt.and("name", "John", "age>", 30, "status", "active");

// OR: name like 'Soph%' or name like 'Fra%'
Condition cond2 = jt.or("name:%l", "Soph", "name:%l", "Fra");

// Empty arguments return null
Condition empty = jt.and();   // null

Find two users with OR (corresponding to the user_table example in JooqTemplateOrTest):

// name = 'John' or name = 'Lee'
Condition cond = jt.or("name", "John", "name", "Lee");
List<LowerCaseRecord> records = jt.queryLowerCaseRecord("user_table", cond);

Method 3: condition() — Single-Condition Method

condition(Name fieldName, String operator, Object[] values) accepts a jOOQ Name, an operator string, and a value array, and generates a single Condition. The number of values must match what the operator requires, otherwise an IllegalArgumentException is thrown:

import org.jooq.Condition;
import org.jooq.Name;
import org.jooq.impl.DSL;

// Equality: == requires 1 value
Condition c1 = jt.condition(DSL.name("name"), "==", new Object[]{"Smartphone"});

// Comparison: > requires 1 value
Condition c2 = jt.condition(DSL.name("price"), ">", new Object[]{1000});

// in: requires 1 value, and the value must be a Collection or Object[]
Condition c3 = jt.condition(DSL.name("category"), "in",
        new Object[]{Arrays.asList("Electronics", "Appliances", "Apparel")});

// between: requires 2 values
Condition c4 = jt.condition(DSL.name("created_at"), "between",
        new Object[]{beginDate, endDate});

// isnull: requires 0 values
Condition c5 = jt.condition(DSL.name("remark"), "isnull", new Object[]{});

This method also follows the null rules: a null value returns null (ignored); wrapping with ND(null) generates is null; a null field name or operator returns null; an invalid operator throws IllegalArgumentException:

// Value is null → returns null, condition ignored
Condition c = jt.condition(DSL.name("name"), "==", new Object[]{null});   // null

// ND wrapping null → generates name is null
Condition c2 = jt.condition(DSL.name("name"), "==", new Object[]{ND(null)});

// Value count mismatch → throws IllegalArgumentException("Operator require value count is 1")
Condition c3 = jt.condition(DSL.name("name"), "==", new Object[]{});

not() — Negating a Condition

not(Condition) negates an existing condition and returns null when the input is null:

Condition original = jt.and("status", "disabled");
Condition notDisabled = jt.not(original);   // not (status = 'disabled')

orOne() — Multiple Fields Matching the Same Value

orOne(Object... sameOneValues) starts with several "fields" (single-value operators), and the last argument is the shared value, generating field1 op value or field2 op value .... A typical "global keyword search" scenario:

// name = 'Apple' or nick_name = 'Apple' or remark = 'Apple'
Condition cond = jt.orOne("name", "nick_name", "remark", "Apple");

Null Fallback for between

between / notbetween take 2 values; when either end is null, it automatically falls back to a one-sided comparison, and when both ends are null the whole condition is ignored:

// Both begin and end are non-null: price between 100 and 500
jt.conditions("price:between", 100, 500);

// begin=100, end=null: price >= 100
jt.conditions("price:between", 100, null);

// notbetween fallback: begin=null, end=500 → price > 500
jt.conditions("price:notbetween", null, 500);

Operator Reference

Condition operators (written after the field name or passed to condition(); all are case-insensitive):

Operator	Value Count	Meaning
`==` (default)	1	Equal to
`<>`	1	Not equal to
`>` `>=` `<` `<=`	1	Comparison
`%` / `like`	1	Contains `%value%`
`%l` / `llike`	1	Prefix match `value%`
`%r` / `rlike`	1	Suffix match `%value`
`in` / `notin`	1	Value is a Collection or Object[]
`between` / `notbetween`	2	Range; a null end falls back automatically
`isnull` / `isnotnull`	0	Null check

Sort operators (only used in the order part of a query or in orders()): asc, ascnf (nulls first), ascnl (nulls last), desc, descnf, descnl.

Null handling rules:

In queries (conditions() / and() / or() / condition()), a null value → the condition is ignored.
A value wrapped with ND(null) → generates field is null.
In UPDATE / DELETE, a null value → generates field is null.

Create record using JooqTemplate

ts5432 — Fri, 16 Oct 2026 00:54:40 +0000

Using JooqTemplate requires no code generation and no XML configuration.

Add Dependency

gradle:

implementation 'net.sf.sprtool:sprtool-jooq:1.7.0'

maven:

<dependency>
    <groupId>net.sf.sprtool</groupId>
    <artifactId>sprtool-jooq</artifactId>
    <version>1.7.0</version>
</dependency>

Inject JooqTemplate

import net.sf.sprtool.jooq.JooqTemplate;

@Autowired
private JooqTemplate jt;

Using JooqTemplate

Inserting a Product Record

Set field values by building a Map, then call the insert method to insert a product record:

Map<String, Object> product = new HashMap<>();
product.put("name", "Phone");
product.put("price", 3999.00);
product.put("stock", 100);
product.put("category", "digital");

int result = jt.insert("product", product);
// result == 1 means the insert succeeded

Inserting a User Record (Partial Fields)

When only some fields are set, the unset fields are written as null:

Map<String, Object> user = new HashMap<>();
user.put("name", "Jack ku");
user.put("nick_name", "As");

int result = jt.insert("user", user);
// The remaining fields (such as avatar_address, birthday) are null

Converting a Java Bean to a Map Automatically

Use JooqMaps.toSnakeCase to automatically convert a camelCase-named Bean into a snake_case-named Map, then perform the insert:

// UserEntity has properties such as name / nickName / avatarAddress / birthday
Map<String, Object> values = JooqMaps.toSnakeCase(userEntity);
int result = jt.insert("user", values);
// To keep fields whose values are null, use JooqMaps.toSnakeCaseWithNull(userEntity);

Inserting an Empty Map

When an empty Map is passed, a record is still inserted (each field uses its default value or null):

int result = jt.insert("order", new HashMap<>());
// result == 1; a record with all fields null was inserted

Exception Cases

Passing a null Map throws NullPointerException / IllegalArgumentException.
When the table name does not exist, an exception is thrown and the message contains the table name.

Implementing IN statements using JooqTemplate

ts5432 — Thu, 20 Aug 2026 00:18:43 +0000

@Service
public class SimpleUserService {
    @Autowired
    private JooqTemplate jt;
    public List<user> selectUserInDept(UserParam param) {
        //If deptIDs==null or deptIDs. isEmpty automatically ignores this query condition
        // SELECT * FROM user_table WHERE name LIKE '%?%' AND dept_id IN (?,?...);
        return jt.queryv("user_table",User.class,"name%",param.getName(),"dept_id:in",param.getDeptIds());
    }
    public List<user> selectUserNotInDept(UserParam param) {
        // SELECT * FROM user_table WHERE name LIKE '%?%' AND dept_id NOT IN (?,?...);
        return jt.queryv("user_table",User.class,"name%",param.getName(),"dept_id:notin",param.getDeptIds());
    }
}

Implement Paging,Top N and All query using JooqTemplate

ts5432 — Fri, 14 Aug 2026 13:43:10 +0000

@Service
public class UserService {
    @Autowired
    private JooqTemplate jt;
    // Retrieve results from different queries based on various LimitRanges
    // Paging query LimitRange.of(param.getLimit(), param.getOffset())
    // TopN query LimitRange.of(param.getLimit())
    // Full Query LimitRange.all()
    public LimitResult<user> selectUser(UserParam param,LimitRange range){
        List<condition> conditions=jt.conditions(jt.orOne("name","nick_name%");
        return jt.query("user_table",User.class,conditions,Arrays.asList(F("birthday").desc()),range);
    }

Is it simple?

Using JooqTemplate implement UserService Demo

ts5432 — Fri, 07 Aug 2026 06:44:57 +0000

No need annotation,No need check null, No need inherit,No need scan,Based on JOOQ

1.Quer User Paramater

public class UserParam {
    String name;
    LocalDate beginBirthday;
    LocalDate endBirthday;
    int offset;
    int limit;
    ...
}

2. User Bean

public class User {
    private Integer id;
    private String name;
    private LocalDate birthday;
    private String nickName;
    private Gender gender;
    private String avatarAddress;
    ...
}

3.UserService

@Service
public class UserService {
    @Autowired
    private JooqTemplate jt;
    public int insertUser(User user) {
        //Bean to camel map
        Map values=JooqMaps.toCamelCase(user);
        //Add additional data
        values.put("create_time", LocalDateTime.now());
        // Insert record
        return jt.insertReturningv("user_table",values,"id").get("id", Integer.class);
    }
    public void updateUser(User user) {
        Map values=JooqMaps.toSnakeCase(user);
        //Regardless of whether it is null or not, update in Map. Update statement does not include in Map
        values.remove("id");
        values.remove("name");
        //jt.updatev("some_table",values,"column1",param1,"column2",param2...);
        //Variable parameter condition update UPDATE user_table SET ... WHERE id=?
        jt.updatev("user_table",values,"id",user.getId());
    }
    public void deleteUser(int id) {
        //jt.deletev("some_table","column1",param1,"column2",param2...);
        //DELETE FROM user_table WHERE id=?
        jt.deletev("user_table","id",id);
    }
    public User loadUser(int id) {
        //1 Variable parameter condition loading SELECT * FROM user_table WHERE id=? LIMIT 1
        return jt.loadv("user_table",User.class,"id",id);
    }
    public List<User> selectUser(UserParam param) {
        //Automatically ignore null parameters
        //SELECT * FROM user_table WHERE name LIKE '%?%' AND birthday BETWEEN ? AND ? ORDER BY name ASC,birthday desc;
        return jt.queryv("user_table",User.class,"name%",param.getName(),"birthday:between",param.getBeginBirthday(),param.getEndBirthday(),"name:asc","birthday:desc");
    }
    // Paging single table query
    public LimitResult<User> pagingUser(UserParam param) {
        //Automatically ignore null parameters
        //SELECT * FROM user_table WHERE (name = 'name' OR nick_name LIKE '%name%') AND birthday>=beginBirthday AND birthday<=endBirthday ORDER BY birthday DESC LIMIT limit OFFSET offset; 
        List<Condition> conditions=jt.conditions(jt.orOne("name","nick_name%",param.getName()),"birthday>=",param.getBeginBirthday(),"birthday<=",param.getEndBirthday());
        return jt.query("user_table",User.class,conditions,Arrays.asList(F("birthday").desc()),LimitRange.of(param.getLimit(), param.getOffset()));
    }
    // Left join pagination query
    public LimitResult<User> pagingUserLeftJoinDept(UserParam param) {
        //Automatically ignore null parameters
        //SELECT u.name,d.name dept_name FROM user_table u LEFT JOIN dept d on u.dept_id=d.id
        //    WHERE (u.name = 'name' OR u.nick_name LIKE '%name%') AND u.birthday>=beginBirthday AND u.birthday<=endBirthday 
        //    ORDER BY birthday DESC LIMIT limit OFFSET offset;         
        List<Condition> conditions=jt.conditions(jt.orOne("u.name","u.nick_name%",param.getName()),
            "u.birthday>=",param.getBeginBirthday(),"u.birthday<=",param.getEndBirthday());
        return jt.query(
            T("user_table").as("u").leftJoin(T("dept_table").as("d")).on(F("u","dept_id").eq(F("d","id"))),
            User.class,
            SL("u.name","d.name dept_name"),
            conditions,
            jt.orders("birthday:desc"),
            LimitRange.of(param.getLimit(), param.getOffset())
        );
    }
}

Map util JooqMaps

ts5432 — Mon, 22 Jun 2026 09:27:08 +0000

1. Bean → Map

Method	Description
toSnakeCase(Object bean)	Convert Bean to Map with snake_case keys; null values are omitted
toSnakeCaseWithNull(Object bean)	Convert Bean to Map with snake_case keys; null values are preserved
toCamelCase(Object bean)	Convert Bean to Map with camelCase keys; null values are omitted
toCamelCaseWithNull(Object bean)	Convert Bean to Map with camelCase keys; null values are preserved

2. Map Key-Value Operations

Method	Description
removeNulls(Map map)	Remove all entries with null values (mutates the original Map)
filterNulls(Map map)	Return a new Map with null-valued entries removed
putEntries(Map map, Object... keyValues)	Batch-put key-value pairs (mutates the original Map)
withEntries(Map map, Object... keyValues)	Batch-put key-value pairs and return a new Map
removeKeys(Map map, Object... keys)	Remove specified keys (mutates the original Map)
excludeKeys(Map map, Object... keys)	Remove specified keys and return a new Map
removeKeysIgnoreCase(Map map, Object... keys)	Remove keys ignoring case
excludeKeysIgnoreCase(Map map, Object... keys)	Remove keys ignoring case and return a new Map

3. Map Key Naming Conversion

Method	Description
toSnakeCase(Map map)	Convert all keys from camelCase to snake_case (e.g. userName → user_name)
toCamelCase(Map map)	Convert all keys from snake_case to camelCase (e.g. user_name → userName)
toLowerCase(Map map)	Convert all keys to lowercase

example:

// Bean to snake_case Map
Map values = JooqMaps.toSnakeCaseWithNull(user);
values.remove("id");

// Add extra fields
JooqMaps.putEntries(values, "create_time", LocalDateTime.now());

// Filter null values
Map nonNull = JooqMaps.filterNulls(values);

// Remove keys
JooqMaps.removeKeys(values, "id", "create_time");

Create field using JooqFields

ts5432 — Fri, 19 Jun 2026 22:33:03 +0000

Static methods for quickly creating JOOQ Table and Field objects, plus Map-to-Field conversion utilities.

1. T() — Create Table

public static Table<Record> T(String... qualifiedName)

example:

T("user_table") or T("schema", "user_table")

2. F() — Create Field

public static Field<Object> F(String... qualifiedName)
public static <T> Field<T> F(Class<T> type, String... qualifiedName)

example:

jooq.selectFrom(T("user_table")).where(F("id").eq(1)).fetch();

3. Typed Field Methods

Method	Return Type	Description
SF(String...)	Field	String field
NF(String...)	Field	Numeric field
IF(String...)	Field	Integer field
LF(String...)	Field	Long field
BDF(String...)	Field	BigDecimal field
BIF(String...)	Field	BigInteger field
QDF(String...)	Field	java.sql.Date field
QTF(String...)	Field	java.sql.Time field
QTSF(String...)	Field	java.sql.Timestamp field
LDF(String...)	Field	LocalDate field
LDTF(String...)	Field	LocalDateTime field
ZDTF(String...)	Field	ZonedDateTime field
ODTF(String...)	Field	OffsetDateTime field
LTF(String...)	Field	LocalTime field

4. Special Fields

public static Field NLF()             // null literal
public static Field NLF(String name)  // null AS name
public static NullOrDefault ND(Object value)
public static NullOrDefault ND(Object value, Object defaultValue)

5. Map & Field Conversion

public static Map<Field,Object> CFM(Map map)    // Create Field Map
public static List<Field>       CFL(List fields)  // Create Field List
public static List<Field>       CGL(List fields)  // Create Group List

Create condition using JooqTemplate

ts5432 — Tue, 16 Jun 2026 04:43:06 +0000

1. condition

Create a Condition from a Field, an operator, and a value.

public Condition condition(Name fieldName, String operator, Object[] values)

2. conditions

Parse varargs into List. Arguments are grouped in pairs (fieldName, value). An operator suffix can be appended to the field name.

public List<Condition> conditions(Object... condtionKvs)

example:

// Basic usage: pairs of (fieldName, value)
List<Condition> conds = jt.conditions(
    "name", "John",                 // name = 'John'
    "birthday≥", beginDate        // birthday ≥ '2020-01-01'
);

// Using conditions with query
List<User> list = jt.query("user_table", User.class,
    jt.conditions("name%", name, "birthday>=", beginDate));

Operator	Meaning	Example
(none) or ==	Equal (eq / isNull)	"name", value → name = ?
%	Contains (LIKE)	"name%", "Jo" → name LIKE '%Jo%'
%L	Starts with	"name%L", "Jo" → name LIKE 'Jo%'
%R	Ends with	"name%R", "hn" → name LIKE '%hn'
>	Greater than	"birthday>", date → birthday > ?
>=	Greater than or equal	"birthday>=", date → birthday >= ?
<	Less than	"age<", 18 → age < ?
<=	Less than or equal	"age<=", 18 → age <= ?
<>	Not equal	"name<>", "admin" → name <> ?
in	IN query	"id", list (Collection/array value) → id IN (?,?,?)
notin	NOT IN query	"id:notin", list → id NOT IN (?,?,?)
isnull	IS NULL (unary, no value argument)	"name:isnull" → name IS NULL
isnotnull	IS NOT NULL (unary, no value argument)	"name:isnotnull" → name IS NOT NULL

3. Order By

In varargs, can append sort operators to field names to specify ordering. can also pass OrderField objects directly.
example:

// Mix ordering in varargs
List<User> list = jt.queryv("user_table", User.class,
    "birthday:desc",            // ORDER BY birthday DESC
    F("name").asc().nullsLast()  // ORDER BY name ASC NULLS LAST
);

// Pass order list to query()
List<User> list = jt.query("user_table", User.class, conditions,
    Arrays.asList(F("birthday").desc(), F("name").asc()));

Sort Operator	Meaning
fieldName:asc	ASC
fieldName:desc	DESC
fieldName:ascnf	ASC NULLS FIRST
fieldName:ascnl	ASC NULLS LAST
fieldName:descnf	DESC NULLS FIRST
fieldName:descnl	DESC NULLS LAST

Pagination records using JooqTemplate

ts5432 — Mon, 15 Jun 2026 06:33:24 +0000

Paginated queries with automatic total count calculation. Supports specifying result fields.

public <E> LimitResult<E> query(Class<E> cls, LimitSelect limitSelect, LimitRange range)
public <E> LimitResult<E> query(Class<E> cls, LimitSelect limitSelect, SelectList selectList, LimitRange range)

Returns: LimitResult — contains getResult() (data list) and getTotal() (total count).
Example:

// Define pagination query
LimitSelect limitSelect = new LimitSelect() {
    public SelectOrderByStep from(SelectSelectStep select) {
        return select.from(T("user_table"))
            .where(jt.conditions("name%", name, "birthday>=", beginDate));
    }
    public List<OrderField> orderBy() {
        return Arrays.asList(F("birthday").desc());
    }
};

// Mode 1: return limit rows, no total count
LimitResult res1 = jt.query(User.class, limitSelect, LimitRange.of(20));

// Mode 2: paginate (offset starts at 0), calculate total count
LimitResult res2 = jt.query(User.class, limitSelect,
    LimitRange.of(20, 0));
// res2.getResult() returns data, res3.getTotal() returns total count

// Mode 3: specify result select list
LimitResult res3 = jt.query(User.class, limitSelect,
     SL("id", "name"),LimitRange.of(20, 0));

// LimitRange.all(): return all data, no total count
LimitResult res4 = jt.query(User.class, limitSelect, LimitRange.all());

// Access results
List<User> data = res2.getResult();
int total = res2.getTotal();

About the LimitSelect interface:

// LimitSelect is a interface:
public interface LimitSelect {
    // Build the FROM clause; the select parameter allows specifying query fields
    SelectOrderByStep from(SelectSelectStep select);

    // Optional: return order fields; return null to skip ordering
    default List<OrderField> orderBy() { return null; }
}

Query records using JooqTemplate

ts5432 — Sun, 14 Jun 2026 07:06:33 +0000

1. query

Query multiple records matching the condition and map them to a list of entities.

// Single condition
public <E> List<E> query(String table, Class<E> cls, Condition condition)
public <E> List<E> query(String table, Class<E> cls, Condition condition, List<? extends OrderField> orderBy)
// Multiple conditions
public <E> List<E> query(String table, Class<E> cls, List<Condition> conditions)
public <E> List<E> query(String table, Class<E> cls, List<Condition> conditions, List<? extends OrderField> orderBy)
// Using RecordMapper
public <R,E> List<E> query(String table, RecordMapper<R,E> mapper, Condition condition)
public <R,E> List<E> query(String table, RecordMapper<R,E> mapper, List<Condition> conditions)

Returns: List — list of entities, never null.
Example:

// Single condition
List<User> list = jt.query("user_table", User.class,
    F("name").contains("John"));

// Multiple conditions + order
List<User> list = jt.query("user_table", User.class,
    jt.conditions("name%", name, "birthday>=", beginDate),
    Arrays.asList(F("birthday").desc(), F("name").asc()));

// Using RecordMapper
List<User> list = jt.query("user_table", new MyMapper(),
    F("id").gt(0));

2. queryRecord

public Result<Record> queryRecord(String table, Condition condition)
public Result<Record> queryRecord(String table, List<Condition> conditions, List<? extends OrderField> orderBy)
public Result<Record> queryRecordv(String table, Object... conditions)

Example:

Result<Record> rs = jt.queryRecordv("user_table", "name%", "Jo");
for(Record r : rs) {
    System.out.println(r.get("name"));
}

3. queryLowerCaseRecord

public List<LowerCaseRecord> queryLowerCaseRecord(String table, Condition condition)
public List<LowerCaseRecord> queryLowerCaseRecordv(String table, Object... conditions)

4. queryv (varargs conditions)

Query a list using varargs conditions. Combine conditions and ordering in a single line.

public <E> List<E> queryv(String table, Class<E> cls, Object... conditions)
public <E> List<E> queryv(TableLike table, Class<E> cls, Object... conditions)

Example:

// Fuzzy + range query
List<User> list = jt.queryv("user_table", User.class,
    "name%", name, "birthday>=", beginDate, "birthday<=", endDate);

// Mixed ordering
List<User> list = jt.queryv("user_table", User.class,
    "birthday:asc", F("name").asc().nullsLast());

Load a single record using JooqTemplate

ts5432 — Thu, 11 Jun 2026 05:29:21 +0000

1. load

Load a single record matching the condition and map it to the specified entity class. Automatically appends LIMIT 1.

public <E> E load(String table, Class<E> cls, Condition condition)
public <E> E load(String table, Class<E> cls, Condition condition, List<? extends OrderField> orderBy)
public <E> E load(String table, Class<E> cls, List<Condition> conditions)
public <E> E load(String table, Class<E> cls, List<Condition> conditions, List<? extends OrderField> orderBy)

Returns: Entity object, or null if not found.
Example:

// Single condition
User user = jt.load("user_table", User.class, F("id").eq(id));

// Multiple conditions + order
User user = jt.load("user_table", User.class,
    Arrays.asList(F("name").eq("John"), F("birthday").isNotNull()),
    Arrays.asList(F("create_time").desc()));

2. loadv (varargs conditions)

Load a single record using varargs for conditions. Supports embedding operators and ordering in field names.

public <E> E loadv(String table, Class<E> cls, Object... conditions)
public <E> E loadv(TableLike table, Class<E> cls, Object... conditions)

Example:

// Simple equality
User user = jt.loadv("user_table", User.class, "id", id);

// Combined conditions + sort
User user = jt.loadv("user_table", User.class,
    "name", name, "name:isnotnull", "birthday:desc");

// Mix with Condition object
User user = jt.loadv("user_table", User.class,
    "id", id, F("name").isNotNull());

3. loadRecord

public Record loadRecord(String table, Condition condition)
public Record loadRecord(String table, List<Condition> conditions)
public Record loadRecord(String table, Condition condition, List<? extends OrderField> orderBy)
public Record loadRecord(String table, List<Condition> conditions, List<? extends OrderField> orderBy)
public Record loadRecordv(String table, Object... conditions)

4. loadLowerCaseRecord

public LowerCaseRecord loadLowerCaseRecord(String table, Condition condition)
public LowerCaseRecord loadLowerCaseRecord(String table, List<Condition> conditions)
public LowerCaseRecord loadLowerCaseRecordv(String table, Object... conditions)

Delete record using JooqTemplate

ts5432 — Wed, 10 Jun 2026 04:36:54 +0000

1. delete

Delete records matching the given condition.

// Single Condition
public int delete(String table, Condition condition)
public int delete(Table table, Condition condition)
// List<Condition>
public int delete(String table, List<Condition> conditions)
public int delete(Table table, List<Condition> conditions)

Returns: int — number of affected rows.
Example:

jt.delete("user_table", F("id").eq(100));
jt.delete("user_table", Arrays.asList(F("id").eq(100)));

2. deletev (varargs conditions)

Specify delete conditions via varargs.

public int deletev(String table, Object... conditions)
public int deletev(Table table, Object... conditions)

Returns: int — number of affected rows.
Example:

// Delete by equality
jt.deletev("user_table", "id", 100);

// Multiple conditions  WHERE name = ? AND birthday >= ?
jt.deletev("user_table", "name", "John", "birthday>=", beginDate);