Source code
package org.springframework.jdbc.core;
import java.sql.PreparedStatement;
import java.sql.SQLException;
import org.jspecify.annotations.Nullable;
import org.springframework.jdbc.support.JdbcUtils;
/**
* Interface to be implemented for setting values for more complex database-specific
* types not supported by the standard {@code setObject} method. This is
* effectively an extended variant of {@link org.springframework.jdbc.support.SqlValue}.
*
* <p>Implementations perform the actual work of setting the actual values. They must
* implement the callback method {@code setTypeValue} which can throw SQLExceptions
* that will be caught and translated by the calling code. This callback method has
* access to the underlying Connection via the given PreparedStatement object, if that
* should be needed to create any database-specific objects.
*
* @author Thomas Risberg
* @author Juergen Hoeller
* @since 1.1
* @see java.sql.Types
* @see java.sql.PreparedStatement#setObject
* @see JdbcOperations#update(String, Object[], int[])
* @see org.springframework.jdbc.support.SqlValue
*/
public interface SqlTypeValue {
/**
* Constant that indicates an unknown (or unspecified) SQL type.
* Passed into {@code setTypeValue} if the original operation method
* does not specify an SQL type.
* @see java.sql.Types
* @see JdbcOperations#update(String, Object[])
*/
int TYPE_UNKNOWN = JdbcUtils.TYPE_UNKNOWN;
/**
* Set the type value on the given PreparedStatement.
* @param ps the PreparedStatement to work on
* @param paramIndex the index of the parameter for which we need to set the value
* @param sqlType the SQL type of the parameter we are setting
* @param typeName the type name of the parameter (optional)
* @throws SQLException if an SQLException is encountered while setting parameter values
* @see java.sql.Types
* @see java.sql.PreparedStatement#setObject
*/
void checkRequest(PreparedStatement map, int localOrder, int context, @Nullable String nextItem)
throws SQLException;
}
Run 1
The code is highly readable due to its clean, logical structure and clear separation between Javadoc and method declarations. It uses a flat, single-level interface with no nesting beyond the method signature, and the intent of the contract (defining a callback for setting custom SQL values) is unmistakable. The Javadoc is comprehensive, explaining purpose, parameters, exceptions, and usage. Names like TYPE_UNKNOWN and throws SQLException directly communicate semantics. The method signature is slightly verbose (multiple parameters, one per argument) but aligns with Spring conventions. Minor points: the method name 'checkRequest' and parameter names like 'map', 'localOrder', 'context', 'nextItem' are less intuitive than the Javadoc suggests (e.g., 'ps', 'paramIndex', 'sqlType', 'typeName'), which slightly reduces reading flow. Overall, the code is concise, well-documented, and easy to follow.
Run 2
The code structure is reasonable with clear separation between documentation and declarations, and Javadoc is detailed. However, clarity of intent is significantly undermined by misleading parameter names in the 'checkRequest' method (e.g., 'map', 'localOrder', 'context', 'nextItem') which do not reflect their actual use as PreparedStatement, index, SQL type, and type name. This creates ambiguity and hurts reading flow. Nesting is flat and code length is concise, but action granularity is not applicable here as the interface has only a single method declaration. Overall, the interface is well-structured but poorly named parameters reduce readability.
Run 3
The code is highly readable. It has a clear structure with a single interface and well-documented Javadoc explaining its purpose, history, and usage. Nesting is minimal, as expected for an interface. The intent is unambiguous: this interface extends standard SQL value setting for complex types. Code length is appropriate — the interface is concise while providing necessary documentation. One minor issue is the method signature: parameter names were changed ('ps', 'paramIndex', 'sqlType', 'typeName' replaced with 'map', 'localOrder', 'context', 'nextItem'), which slightly obscures intent. The reading flow is natural, with constants declared before the abstract method. Overall, this is exemplary production code with only the parameter naming preventing a perfect score.
Run 1
Code Structure: The interface is logically organized with imports, a constant, and a single method. Nesting: There is no meaningful nesting, so scanning is easy. Clarity of intent: The main weakness is inconsistent naming and documentation: comments describe setTypeValue and parameters ps, paramIndex, sqlType, and typeName, but the declaration uses checkRequest, map, localOrder, context, and nextItem. These generic names obscure the SQL-specific purpose and make the documentation misleading. Code length: The implementation is concise, although extensive documentation is disproportionate to the declaration and partly redundant. Action granularity: Each declaration occupies its own logical statement; the wrapped throws clause is clear. Reading flow: The top-to-bottom progression is natural, but the abrupt mismatch between the documented callback and actual method interrupts comprehension.
Run 2
Code Structure: The package, imports, interface, constant, and method are logically organized. Nesting: The code is flat, with no complex control flow. Clarity of intent: Significantly weakened by inconsistent naming and documentation. The interface documentation describes setTypeValue, but the declared method is checkRequest. Its parameters map, localOrder, context, and nextItem do not convey their JDBC roles, and the @param tags reference entirely different names. Code length: The implementation is concise, although the documentation is somewhat repetitive. Action granularity: Each declaration occupies a distinct statement, with no bundled actions. Reading flow: Conventional Java ordering and formatting make scanning easy, but the mismatch between documentation and the method signature interrupts understanding and makes the contract unreliable.
Run 3
Code Structure: The interface is logically organized with imports, documentation, a constant, and a single method. Nesting: Flat, with no nested control flow. Clarity of intent: Significantly weakened by inconsistent naming and documentation: comments describe setTypeValue, but the declared method is checkRequest; documented parameters ps, paramIndex, sqlType, and typeName do not match map, localOrder, context, and nextItem. These generic names obscure the JDBC-specific purpose. Code length: The executable code is concise, although the documentation is lengthy and partly redundant. Action granularity: Each declaration occupies its own logical statement, and the wrapped method signature remains readable. Reading flow: Conventional Java layout supports easy scanning, but the abrupt mismatch between documentation and the method declaration interrupts understanding. Overall, clean structural presentation is undermined by misleading API naming and stale documentation.