jOOQ 3.18.7 · org.jooq.tools.jdbc.MockFileDatabase

A file-based MockDataProvider.

This data provider reads a database model from a text file, as documented in the below sample file:


# Comments start off with a hash

# Statement strings have no prefix and should be ended with a semi-colon
select 'A' from dual;
# Statements may be followed by results, using >
> A
> -
> A
# Statements should be followed by "@ rows: [N]" indicating the update count
@ rows: 1

# New statements can be listed int his file
select 'A', 'B' from dual;
> A B
> - -
> A B
@ rows: 1

# Beware of the exact syntax (e.g. using quotes)
select "TABLE1"."ID1", "TABLE1"."NAME1" from "TABLE1";
> ID1 NAME1
> --- -----
> 1   X
> 2   Y
@ rows: 2

# Statements can return several results
> F1  F2  F3 is a bit more complex
> --- --  ----------------------------
> 1   2   and a string containing data
> 1.1 x   another string
@ rows: 2

> A B "C D"
> - - -----
> x y z
@ rows: 1

Results can be loaded using several techniques:

When results are prefixed with >, then DSLContext#fetchFromTXT(String) is used
In the future, other types of result sources will be supported, such as CSV, XML, JSON

Disclaimer

The general idea of mocking a JDBC connection with this jOOQ API is to provide quick workarounds, injection points, etc. using a very simple JDBC abstraction. It is NOT RECOMMENDED to emulate an entire database (including complex state transitions, transactions, locking, etc.) using this mock API. Once you have this requirement, please consider using an actual database instead for integration testing (e.g. using https://www.testcontainers.org), rather than implementing your test database inside of a MockDataProvider.

Modifier and Type	Field and Description
private final MockFileDatabaseConfiguration	configuration
private final DSLContext	create
private static final Pattern	END_OF_STATEMENT
private static final JooqLogger	log
private final Map<String, List<MockResult>>	matchExactly
private final Map<Pattern, List<MockResult>>	matchPattern
private String	nullLiteral Deprecated

Access	Constructor and Description
public	MockFileDatabase(File file)
public	MockFileDatabase(File file, String encoding)
public	MockFileDatabase(InputStream stream)
public	MockFileDatabase(InputStream stream, String encoding)
public	MockFileDatabase(Reader reader)
public	MockFileDatabase(String string)
public	MockFileDatabase(Source source)
public	MockFileDatabase(MockFileDatabaseConfiguration configuration)

Modifier and Type	Method and Description
public MockResult[]	execute(MockExecuteContext The execution context. ctx) Implements org.jooq.tools.jdbc.MockDataProvider.execute. Execution callback for a JDBC query execution.
private void	load()
public MockFileDatabase	nullLiteral(String literal) Deprecated - Use `MockFileDatabaseConfiguration#nullLiteral(String)` instead. Specify the `null` literal, i.e. the string that should be parsed as a `null` reference, rather than as the string itself.
public Map<String, List<MockResult>>	queries() Deprecated - Experimental: Do not use. Subject to change.

configuration	back to summary
private final MockFileDatabaseConfiguration configuration

create	back to summary
private final DSLContext create

END_OF_STATEMENT	back to summary
private static final Pattern END_OF_STATEMENT

log	back to summary
private static final JooqLogger log

matchExactly	back to summary
private final Map<String, List<MockResult>> matchExactly

matchPattern	back to summary
private final Map<Pattern, List<MockResult>> matchPattern

nullLiteral	back to summary
private String nullLiteral Deprecated Annotations @Deprecated

MockFileDatabase	back to summary
public MockFileDatabase(File file) throws IOException

MockFileDatabase	back to summary
public MockFileDatabase(File file, String encoding) throws IOException

MockFileDatabase	back to summary
public MockFileDatabase(InputStream stream) throws IOException

MockFileDatabase	back to summary
public MockFileDatabase(InputStream stream, String encoding) throws IOException

MockFileDatabase	back to summary
public MockFileDatabase(Reader reader) throws IOException

MockFileDatabase	back to summary
public MockFileDatabase(String string) throws IOException

MockFileDatabase	back to summary
public MockFileDatabase(Source source) throws IOException

MockFileDatabase	back to summary
public MockFileDatabase(MockFileDatabaseConfiguration configuration) throws IOException

Method Detail

execute back to summary

execute	back to summary
public MockResult[] execute(MockExecuteContext ctx) throws SQLException Implements org.jooq.tools.jdbc.MockDataProvider.execute. Doc from org.jooq.tools.jdbc.MockDataProvider.execute. Execution callback for a JDBC query execution. This callback will be called by `MockStatement` upon the various statement execution methods. These include: `Statement#execute(String)` `Statement#execute(String, int)` `Statement#execute(String, int[])` `Statement#execute(String, String[])` `Statement#executeBatch()` `Statement#executeQuery(String)` `Statement#executeUpdate(String)` `Statement#executeUpdate(String, int)` `Statement#executeUpdate(String, int[])` `Statement#executeUpdate(String, String[])` `PreparedStatement#execute()` `PreparedStatement#executeQuery()` `PreparedStatement#executeUpdate()` The various execution modes are unified into this simple method. Implementations should adhere to this contract: `MockStatement` does not distinguish between "static" and "prepared" statements. However, a non-empty `MockExecuteContext#bindings()` is a strong indicator for a `PreparedStatement`. `MockStatement` does not distinguish between "batch" and "single" statements. However... A `MockExecuteContext#batchSQL()` with more than one SQL string is a strong indicator for a "multi-batch statement", as understood by jOOQ's `DSLContext#batch(Query...)`. A `MockExecuteContext#batchBindings()` with more than one bind variable array is a strong indicator for a "single-batch statement", as understood by jOOQ's `DSLContext#batch(Query)`. It is recommended to return as many `MockResult` objects as batch executions. In other words, you should guarantee that: `int multiSize = context.getBatchSQL().length; int singleSize = context.getBatchBindings().length; assertEquals(result.length, Math.max(multiSize, singleSize))` This holds true also for non-batch executions (where both sizes are equal to `1`) You may also return more than one result for non-batch executions. This is useful for procedure calls with several result sets. In JDBC, such additional result sets can be obtained with `Statement#getMoreResults()`. In jOOQ, such additional result sets can be obtained with `ResultQuery#fetchMany()` If generated keys (`Statement#RETURN_GENERATED_KEYS`) are requested from this execution, you can also add `MockResult#data` to your first result, in addition to the affected `MockResult#rows`. The relevant flag is passed from `MockStatement` to any of these properties: `MockExecuteContext#autoGeneratedKeys()` `MockExecuteContext#columnIndexes()` `MockExecuteContext#columnNames()` OUT parameters from stored procedures are generated from the first `MockResult`'s first `Record`. If OUT parameters are requested, implementors must ensure the presence of such a `Record`. Parameters ctx:MockExecuteContext The execution context. Returns:MockResult[] The execution results. If a `null` or an empty `MockResult[]` is returned, this has the same effect as returning `new MockResult[] { new MockResult(-1, null) }` Annotations @Override Exceptions SQLException: A `SQLException` that is passed through to jOOQ.

public MockResult[] execute(MockExecuteContext ctx) throws SQLException

Implements org.jooq.tools.jdbc.MockDataProvider.execute.

Doc from org.jooq.tools.jdbc.MockDataProvider.execute.

Execution callback for a JDBC query execution.

This callback will be called by MockStatement upon the various statement execution methods. These include:

The various execution modes are unified into this simple method. Implementations should adhere to this contract:

MockStatement does not distinguish between "static" and "prepared" statements. However, a non-empty MockExecuteContext#bindings() is a strong indicator for a PreparedStatement.
MockStatement does not distinguish between "batch" and "single" statements. However...
- A MockExecuteContext#batchSQL() with more than one SQL string is a strong indicator for a "multi-batch statement", as understood by jOOQ's DSLContext#batch(Query...).
- A MockExecuteContext#batchBindings() with more than one bind variable array is a strong indicator for a "single-batch statement", as understood by jOOQ's DSLContext#batch(Query).
It is recommended to return as many MockResult objects as batch executions. In other words, you should guarantee that:
```
int multiSize = context.getBatchSQL().length;
int singleSize = context.getBatchBindings().length;
assertEquals(result.length, Math.max(multiSize, singleSize))
```
This holds true also for non-batch executions (where both sizes are equal to 1)
You may also return more than one result for non-batch executions. This is useful for procedure calls with several result sets.
- In JDBC, such additional result sets can be obtained with Statement#getMoreResults().
- In jOOQ, such additional result sets can be obtained with ResultQuery#fetchMany()
If generated keys (Statement#RETURN_GENERATED_KEYS) are requested from this execution, you can also add MockResult#data to your first result, in addition to the affected MockResult#rows. The relevant flag is passed from MockStatement to any of these properties:
OUT parameters from stored procedures are generated from the first MockResult's first Record. If OUT parameters are requested, implementors must ensure the presence of such a Record.

Parameters

ctx:MockExecuteContext: The execution context.

Returns:MockResult[]

The execution results. If a null or an empty MockResult[] is returned, this has the same effect as returning new MockResult[] { new MockResult(-1, null) }

Annotations

@Override

Exceptions

SQLException:: A SQLException that is passed through to jOOQ.

load	back to summary
private void load() throws FileNotFoundException, IOException

nullLiteral back to summary

nullLiteral	back to summary
public MockFileDatabase nullLiteral(String literal) Deprecated - Use `MockFileDatabaseConfiguration#nullLiteral(String)` instead. Specify the `null` literal, i.e. the string that should be parsed as a `null` reference, rather than as the string itself. Annotations @Deprecated See Also `DSLContext#fetchFromTXT(String, String)`

public MockFileDatabase nullLiteral(String literal)

Deprecated

- Use MockFileDatabaseConfiguration#nullLiteral(String) instead.

Specify the null literal, i.e. the string that should be parsed as a null reference, rather than as the string itself.

Annotations

@Deprecated

queries	back to summary
public Map<String, List<MockResult>> queries() Deprecated - Experimental: Do not use. Subject to change. Annotations @Deprecated

public Class MockFileDatabase

Field Summary

Constructor Summary

Method Summary

Field Detail

Constructor Detail

Method Detail