fix(firebird): return stored procedure source

Closes #6141
This commit is contained in:
t8y2 committed 2026-08-14 04:14:59 +00:00
1 parent e3c154ab4c
commit f9fd2d4fa8
2 files changed
+715

No files matched your search

@@ -3,8 +3,59 @@ package com.dbx.agent.firebird;
import com.dbx.agent.ConfiguredJdbcAgent;
import com.dbx.agent.JdbcAgentProfile;
import com.dbx.agent.MultiSessionJsonRpcServer;
import com.dbx.agent.ObjectSource;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.util.ArrayList;
import java.util.List;
import java.util.Locale;
public final class FirebirdAgent extends ConfiguredJdbcAgent {
static final String PROCEDURE_SOURCE_SQL = """
SELECT
CASE WHEN METADATA_ROW = 1 THEN PROCEDURE_SOURCE ELSE NULL END AS PROCEDURE_SOURCE,
PARAMETER_NAME,
PARAMETER_TYPE,
PARAMETER_NUMBER,
FIELD_SOURCE,
PARAMETER_DEFAULT,
PARAMETER_NULL_FLAG,
FIELD_TYPE,
FIELD_SUB_TYPE,
FIELD_PRECISION,
FIELD_SCALE,
FIELD_LENGTH,
CHAR_COUNT
FROM (
SELECT
P.RDB$PROCEDURE_SOURCE AS PROCEDURE_SOURCE,
TRIM(PP.RDB$PARAMETER_NAME) AS PARAMETER_NAME,
PP.RDB$PARAMETER_TYPE AS PARAMETER_TYPE,
PP.RDB$PARAMETER_NUMBER AS PARAMETER_NUMBER,
TRIM(PP.RDB$FIELD_SOURCE) AS FIELD_SOURCE,
PP.RDB$DEFAULT_SOURCE AS PARAMETER_DEFAULT,
PP.RDB$NULL_FLAG AS PARAMETER_NULL_FLAG,
F.RDB$FIELD_TYPE AS FIELD_TYPE,
F.RDB$FIELD_SUB_TYPE AS FIELD_SUB_TYPE,
F.RDB$FIELD_PRECISION AS FIELD_PRECISION,
F.RDB$FIELD_SCALE AS FIELD_SCALE,
F.RDB$FIELD_LENGTH AS FIELD_LENGTH,
F.RDB$CHARACTER_LENGTH AS CHAR_COUNT,
ROW_NUMBER() OVER (
ORDER BY PP.RDB$PARAMETER_TYPE, PP.RDB$PARAMETER_NUMBER
) AS METADATA_ROW
FROM RDB$PROCEDURES P
LEFT JOIN RDB$PROCEDURE_PARAMETERS PP
ON PP.RDB$PROCEDURE_NAME = P.RDB$PROCEDURE_NAME
AND PP.RDB$PACKAGE_NAME IS NOT DISTINCT FROM P.RDB$PACKAGE_NAME
LEFT JOIN RDB$FIELDS F
ON F.RDB$FIELD_NAME = PP.RDB$FIELD_SOURCE
WHERE P.RDB$PROCEDURE_NAME = ?
AND P.RDB$PACKAGE_NAME IS NULL
) PROCEDURE_METADATA
ORDER BY PARAMETER_TYPE, PARAMETER_NUMBER
""".stripIndent().trim();
public static final JdbcAgentProfile FIREBIRD_PROFILE = new JdbcAgentProfile(
"org.firebirdsql.jdbc.FBDriver",
"jdbc:firebirdsql://{host}:{port}/{database}",
@@ -16,6 +67,228 @@ public final class FirebirdAgent extends ConfiguredJdbcAgent {
super(FIREBIRD_PROFILE);
}
@Override
public ObjectSource getObjectSource(String schema, String name, String objectType) {
String normalizedType = normalizeObjectSourceType(objectType);
return unchecked(() -> {
String body = null;
boolean found = false;
List<ProcedureParameter> inputs = new ArrayList<>();
List<ProcedureParameter> outputs = new ArrayList<>();
try (PreparedStatement statement = requireConnection().prepareStatement(PROCEDURE_SOURCE_SQL)) {
statement.setString(1, name);
try (ResultSet resultSet = statement.executeQuery()) {
while (resultSet.next()) {
found = true;
if (body == null) {
body = resultSet.getString("PROCEDURE_SOURCE");
}
String parameterName = trimToNull(resultSet.getString("PARAMETER_NAME"));
if (parameterName == null) {
continue;
}
ProcedureParameter parameter = new ProcedureParameter(
parameterName,
trimToNull(resultSet.getString("FIELD_SOURCE")),
trimToNull(resultSet.getString("PARAMETER_DEFAULT")),
nullableInt(resultSet, "PARAMETER_NULL_FLAG"),
nullableInt(resultSet, "FIELD_TYPE"),
nullableInt(resultSet, "FIELD_SUB_TYPE"),
nullableInt(resultSet, "FIELD_PRECISION"),
nullableInt(resultSet, "FIELD_SCALE"),
nullableInt(resultSet, "FIELD_LENGTH"),
nullableInt(resultSet, "CHAR_COUNT")
);
int parameterType = resultSet.getInt("PARAMETER_TYPE");
if (parameterType == 0) {
inputs.add(parameter);
} else if (parameterType == 1) {
outputs.add(parameter);
} else {
throw new IllegalStateException("Unsupported Firebird parameter type: " + parameterType);
}
}
}
}
String source = !found || body == null || body.isBlank()
? ""
: buildProcedureDdl(name, inputs, outputs, body);
return new ObjectSource(name, normalizedType, schema, source, false);
});
}
static String normalizeObjectSourceType(String objectType) {
if (objectType == null) {
throw new IllegalArgumentException("Unsupported object type: null");
}
String normalized = objectType.trim().toUpperCase(Locale.ROOT);
if (!"PROCEDURE".equals(normalized)) {
throw new IllegalArgumentException("Unsupported object type: " + objectType);
}
return normalized;
}
private static String buildProcedureDdl(
String name,
List<ProcedureParameter> inputs,
List<ProcedureParameter> outputs,
String body
) {
StringBuilder ddl = new StringBuilder("CREATE OR ALTER PROCEDURE ")
.append(quoteIdentifier(name));
appendParameterBlock(ddl, inputs, " (");
if (inputs.isEmpty()) {
ddl.append('\n');
}
if (!outputs.isEmpty()) {
appendParameterBlock(ddl, outputs, "RETURNS (");
}
ddl.append("AS\n").append(body);
if (!body.endsWith("\n")) {
ddl.append('\n');
}
return ddl.toString();
}
private static void appendParameterBlock(
StringBuilder ddl,
List<ProcedureParameter> parameters,
String prefix
) {
if (parameters.isEmpty()) {
return;
}
ddl.append(prefix).append('\n');
for (int index = 0; index < parameters.size(); index++) {
ddl.append(" ").append(parameterDeclaration(parameters.get(index)));
if (index + 1 < parameters.size()) {
ddl.append(',');
}
ddl.append('\n');
}
ddl.append(")\n");
}
private static String parameterDeclaration(ProcedureParameter parameter) {
StringBuilder declaration = new StringBuilder(quoteIdentifier(parameter.name()))
.append(' ')
.append(parameterType(parameter));
if (Integer.valueOf(1).equals(parameter.notNull())) {
declaration.append(" NOT NULL");
}
if (parameter.defaultSource() != null) {
declaration.append(' ').append(parameter.defaultSource());
}
return declaration.toString();
}
private static String parameterType(ProcedureParameter parameter) {
if (parameter.fieldSource() != null && !parameter.fieldSource().startsWith("RDB$")) {
return quoteIdentifier(parameter.fieldSource());
}
if (parameter.fieldType() == null) {
throw new IllegalStateException("Missing Firebird field type for parameter " + parameter.name());
}
int fieldType = parameter.fieldType();
int subType = valueOrZero(parameter.fieldSubType());
return switch (fieldType) {
case 7 -> numericType("SMALLINT", subType, parameter);
case 8 -> numericType("INTEGER", subType, parameter);
case 10 -> "FLOAT";
case 11, 27 -> "DOUBLE PRECISION";
case 12 -> "DATE";
case 13 -> "TIME";
case 14 -> characterType("CHAR", "BINARY", subType, parameter);
case 16 -> numericType("BIGINT", subType, parameter);
case 23 -> "BOOLEAN";
case 24 -> "DECFLOAT(16)";
case 25 -> "DECFLOAT(34)";
case 26 -> numericType("INT128", subType, parameter);
case 28 -> "TIME WITH TIME ZONE";
case 29 -> "TIMESTAMP WITH TIME ZONE";
case 35 -> "TIMESTAMP";
case 37 -> characterType("VARCHAR", "VARBINARY", subType, parameter);
case 40 -> sizedType("CSTRING", characterLength(parameter));
case 261 -> blobType(subType);
default -> throw new IllegalStateException("Unsupported Firebird field type: " + fieldType);
};
}
private static String numericType(String integerType, int subType, ProcedureParameter parameter) {
int scale = valueOrZero(parameter.scale());
if (subType != 1 && subType != 2 && scale >= 0) {
return integerType;
}
String exactType = subType == 2 ? "DECIMAL" : "NUMERIC";
int precision = valueOrZero(parameter.precision());
if (precision <= 0) {
return exactType;
}
return exactType + "(" + precision + "," + Math.abs(scale) + ")";
}
private static String characterType(
String characterType,
String binaryType,
int subType,
ProcedureParameter parameter
) {
return sizedType(subType == 1 ? binaryType : characterType, characterLength(parameter));
}
private static String sizedType(String type, Integer size) {
return size == null || size <= 0 ? type : type + "(" + size + ")";
}
private static int characterLength(ProcedureParameter parameter) {
Integer charCount = parameter.charCount();
return charCount != null && charCount > 0
? charCount
: valueOrZero(parameter.fieldLength());
}
private static String blobType(int subType) {
if (subType == 0) {
return "BLOB";
}
return subType == 1 ? "BLOB SUB_TYPE TEXT" : "BLOB SUB_TYPE " + subType;
}
private static String quoteIdentifier(String identifier) {
return "\"" + identifier.replace("\"", "\"\"") + "\"";
}
private static String trimToNull(String value) {
if (value == null || value.trim().isEmpty()) {
return null;
}
return value.trim();
}
private static Integer nullableInt(ResultSet resultSet, String column) throws Exception {
int value = resultSet.getInt(column);
return resultSet.wasNull() ? null : value;
}
private static int valueOrZero(Integer value) {
return value == null ? 0 : value;
}
private record ProcedureParameter(
String name,
String fieldSource,
String defaultSource,
Integer notNull,
Integer fieldType,
Integer fieldSubType,
Integer precision,
Integer scale,
Integer fieldLength,
Integer charCount
) {
}
public static void main(String[] args) {
new MultiSessionJsonRpcServer(FirebirdAgent::new).run();
}
@@ -0,0 +1,442 @@
package com.dbx.agent.firebird;
import com.dbx.agent.ObjectSource;
import com.dbx.agent.test.TestSupport;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import org.junit.jupiter.api.Assertions;
import org.junit.jupiter.api.Test;
class FirebirdAgentTest {
private static final String EXPECTED_PROCEDURE_SOURCE_SQL = """
SELECT
CASE WHEN METADATA_ROW = 1 THEN PROCEDURE_SOURCE ELSE NULL END AS PROCEDURE_SOURCE,
PARAMETER_NAME,
PARAMETER_TYPE,
PARAMETER_NUMBER,
FIELD_SOURCE,
PARAMETER_DEFAULT,
PARAMETER_NULL_FLAG,
FIELD_TYPE,
FIELD_SUB_TYPE,
FIELD_PRECISION,
FIELD_SCALE,
FIELD_LENGTH,
CHAR_COUNT
FROM (
SELECT
P.RDB$PROCEDURE_SOURCE AS PROCEDURE_SOURCE,
TRIM(PP.RDB$PARAMETER_NAME) AS PARAMETER_NAME,
PP.RDB$PARAMETER_TYPE AS PARAMETER_TYPE,
PP.RDB$PARAMETER_NUMBER AS PARAMETER_NUMBER,
TRIM(PP.RDB$FIELD_SOURCE) AS FIELD_SOURCE,
PP.RDB$DEFAULT_SOURCE AS PARAMETER_DEFAULT,
PP.RDB$NULL_FLAG AS PARAMETER_NULL_FLAG,
F.RDB$FIELD_TYPE AS FIELD_TYPE,
F.RDB$FIELD_SUB_TYPE AS FIELD_SUB_TYPE,
F.RDB$FIELD_PRECISION AS FIELD_PRECISION,
F.RDB$FIELD_SCALE AS FIELD_SCALE,
F.RDB$FIELD_LENGTH AS FIELD_LENGTH,
F.RDB$CHARACTER_LENGTH AS CHAR_COUNT,
ROW_NUMBER() OVER (
ORDER BY PP.RDB$PARAMETER_TYPE, PP.RDB$PARAMETER_NUMBER
) AS METADATA_ROW
FROM RDB$PROCEDURES P
LEFT JOIN RDB$PROCEDURE_PARAMETERS PP
ON PP.RDB$PROCEDURE_NAME = P.RDB$PROCEDURE_NAME
AND PP.RDB$PACKAGE_NAME IS NOT DISTINCT FROM P.RDB$PACKAGE_NAME
LEFT JOIN RDB$FIELDS F
ON F.RDB$FIELD_NAME = PP.RDB$FIELD_SOURCE
WHERE P.RDB$PROCEDURE_NAME = ?
AND P.RDB$PACKAGE_NAME IS NULL
) PROCEDURE_METADATA
ORDER BY PARAMETER_TYPE, PARAMETER_NUMBER
""".stripIndent().trim();
@Test
void returnsCompleteProcedureDdlFromOneMetadataQuery() {
List<String> sql = new ArrayList<>();
List<String> parameters = new ArrayList<>();
FirebirdAgent agent = agentWithRows(
sql,
parameters,
row(
"PROCEDURE_SOURCE", procedureBody(),
"PARAMETER_NAME", "P_ID",
"PARAMETER_TYPE", 0,
"PARAMETER_NUMBER", 0,
"FIELD_SOURCE", "RDB$1",
"FIELD_TYPE", 8,
"FIELD_SUB_TYPE", 0,
"FIELD_PRECISION", 0,
"FIELD_SCALE", 0,
"FIELD_LENGTH", 4
),
row(
"PROCEDURE_SOURCE", null,
"PARAMETER_NAME", "P_LABEL",
"PARAMETER_TYPE", 0,
"PARAMETER_NUMBER", 1,
"FIELD_SOURCE", "RDB$2",
"PARAMETER_DEFAULT", "DEFAULT 'fallback'",
"FIELD_TYPE", 37,
"FIELD_SUB_TYPE", 0,
"FIELD_SCALE", 0,
"FIELD_LENGTH", 80,
"CHAR_COUNT", 20
),
row(
"PROCEDURE_SOURCE", null,
"PARAMETER_NAME", "P_DOM",
"PARAMETER_TYPE", 0,
"PARAMETER_NUMBER", 2,
"FIELD_SOURCE", "D_6141",
"PARAMETER_DEFAULT", "DEFAULT 'domain'",
"FIELD_TYPE", 37,
"FIELD_SUB_TYPE", 0,
"FIELD_SCALE", 0,
"FIELD_LENGTH", 48,
"CHAR_COUNT", 12
),
row(
"PROCEDURE_SOURCE", null,
"PARAMETER_NAME", "O_ID",
"PARAMETER_TYPE", 1,
"PARAMETER_NUMBER", 0,
"FIELD_SOURCE", "RDB$3",
"FIELD_TYPE", 16,
"FIELD_SUB_TYPE", 0,
"FIELD_PRECISION", 0,
"FIELD_SCALE", 0,
"FIELD_LENGTH", 8
),
row(
"PROCEDURE_SOURCE", null,
"PARAMETER_NAME", "O_TEXT",
"PARAMETER_TYPE", 1,
"PARAMETER_NUMBER", 1,
"FIELD_SOURCE", "RDB$4",
"FIELD_TYPE", 37,
"FIELD_SUB_TYPE", 0,
"FIELD_SCALE", 0,
"FIELD_LENGTH", 160,
"CHAR_COUNT", 40
)
);
ObjectSource source = agent.getObjectSource(null, "P_6141", " procedure ");
Assertions.assertEquals(List.of(EXPECTED_PROCEDURE_SOURCE_SQL), sql);
Assertions.assertEquals(List.of("1=P_6141"), parameters);
Assertions.assertEquals("P_6141", source.getName());
Assertions.assertEquals("PROCEDURE", source.getObject_type());
Assertions.assertNull(source.getSchema());
Assertions.assertFalse(source.isEditable());
Assertions.assertEquals(
"""
CREATE OR ALTER PROCEDURE "P_6141" (
"P_ID" INTEGER,
"P_LABEL" VARCHAR(20) DEFAULT 'fallback',
"P_DOM" "D_6141" DEFAULT 'domain'
)
RETURNS (
"O_ID" BIGINT,
"O_TEXT" VARCHAR(40)
)
AS
DECLARE VARIABLE V_NOTE VARCHAR(20);
BEGIN
O_ID = P_ID;
O_TEXT = P_LABEL || ':' || P_DOM;
SUSPEND;
END
""",
source.getSource()
);
}
@Test
void quotesMixedCaseIdentifiersAndBindsRoutineName() {
List<String> sql = new ArrayList<>();
List<String> parameters = new ArrayList<>();
FirebirdAgent agent = agentWithRows(
sql,
parameters,
row(
"PROCEDURE_SOURCE", "BEGIN\nEND",
"PARAMETER_NAME", "Arg\"Name",
"PARAMETER_TYPE", 0,
"PARAMETER_NUMBER", 0,
"FIELD_SOURCE", "RDB$10",
"FIELD_TYPE", 7,
"FIELD_SUB_TYPE", 0,
"FIELD_SCALE", 0,
"FIELD_LENGTH", 2
)
);
ObjectSource source = agent.getObjectSource("ignored-schema", "Mix\"Case", "PROCEDURE");
Assertions.assertEquals(List.of(EXPECTED_PROCEDURE_SOURCE_SQL), sql);
Assertions.assertEquals(List.of("1=Mix\"Case"), parameters);
Assertions.assertFalse(EXPECTED_PROCEDURE_SOURCE_SQL.contains("Mix\"Case"));
Assertions.assertEquals(
"CREATE OR ALTER PROCEDURE \"Mix\"\"Case\" (\n"
+ " \"Arg\"\"Name\" SMALLINT\n"
+ ")\n"
+ "AS\n"
+ "BEGIN\nEND\n",
source.getSource()
);
}
@Test
void mapsExactNumericLegacyAndFirebirdFourTypes() {
FirebirdAgent agent = agentWithRows(
new ArrayList<>(),
new ArrayList<>(),
row(
"PROCEDURE_SOURCE", "BEGIN\nEND",
"PARAMETER_NAME", "N_SMALL",
"PARAMETER_TYPE", 0,
"FIELD_SOURCE", "RDB$11",
"FIELD_TYPE", 7,
"FIELD_SUB_TYPE", 1,
"FIELD_PRECISION", 4,
"FIELD_SCALE", -2,
"FIELD_LENGTH", 2
),
row(
"PARAMETER_NAME", "N_LEGACY",
"PARAMETER_TYPE", 0,
"FIELD_SOURCE", "RDB$12",
"FIELD_TYPE", 8,
"FIELD_SUB_TYPE", 0,
"FIELD_PRECISION", 9,
"FIELD_SCALE", -2,
"FIELD_LENGTH", 4
),
row(
"PARAMETER_NAME", "D_FLOAT_VALUE",
"PARAMETER_TYPE", 0,
"FIELD_SOURCE", "RDB$13",
"FIELD_TYPE", 11,
"FIELD_SUB_TYPE", 0,
"FIELD_LENGTH", 8
),
row(
"PARAMETER_NAME", "DEC16_VALUE",
"PARAMETER_TYPE", 0,
"FIELD_SOURCE", "RDB$14",
"FIELD_TYPE", 24,
"FIELD_SUB_TYPE", 0,
"FIELD_LENGTH", 8
),
row(
"PARAMETER_NAME", "DEC34_VALUE",
"PARAMETER_TYPE", 0,
"FIELD_SOURCE", "RDB$15",
"FIELD_TYPE", 25,
"FIELD_SUB_TYPE", 0,
"FIELD_LENGTH", 16
),
row(
"PARAMETER_NAME", "BINARY_VALUE",
"PARAMETER_TYPE", 0,
"FIELD_SOURCE", "RDB$16",
"FIELD_TYPE", 14,
"FIELD_SUB_TYPE", 1,
"FIELD_LENGTH", 4
),
row(
"PARAMETER_NAME", "VARBINARY_VALUE",
"PARAMETER_TYPE", 0,
"FIELD_SOURCE", "RDB$17",
"FIELD_TYPE", 37,
"FIELD_SUB_TYPE", 1,
"FIELD_LENGTH", 8
)
);
ObjectSource source = agent.getObjectSource(null, "P_TYPES", "PROCEDURE");
Assertions.assertEquals(
"CREATE OR ALTER PROCEDURE \"P_TYPES\" (\n"
+ " \"N_SMALL\" NUMERIC(4,2),\n"
+ " \"N_LEGACY\" NUMERIC(9,2),\n"
+ " \"D_FLOAT_VALUE\" DOUBLE PRECISION,\n"
+ " \"DEC16_VALUE\" DECFLOAT(16),\n"
+ " \"DEC34_VALUE\" DECFLOAT(34),\n"
+ " \"BINARY_VALUE\" BINARY(4),\n"
+ " \"VARBINARY_VALUE\" VARBINARY(8)\n"
+ ")\n"
+ "AS\n"
+ "BEGIN\nEND\n",
source.getSource()
);
}
@Test
void returnsEmptySourceWhenRoutineIsMissing() {
FirebirdAgent agent = agentWithRows(new ArrayList<>(), new ArrayList<>());
ObjectSource source = agent.getObjectSource(null, "MISSING_PROCEDURE", "PROCEDURE");
Assertions.assertEquals("", source.getSource());
Assertions.assertFalse(source.isEditable());
}
@Test
void returnsEmptySourceWhenStoredBodyIsNull() {
FirebirdAgent agent = agentWithRows(
new ArrayList<>(),
new ArrayList<>(),
row("PROCEDURE_SOURCE", null, "PARAMETER_NAME", null)
);
ObjectSource source = agent.getObjectSource(null, "EXTERNAL_PROCEDURE", "PROCEDURE");
Assertions.assertEquals("", source.getSource());
}
@Test
void propagatesMetadataQueryErrors() {
FirebirdAgent agent = new FirebirdAgent();
SQLException failure = new SQLException("metadata unavailable", "HY000");
TestSupport.setPrivateConnection(agent, proxy(Connection.class, (method, args) -> {
if ("prepareStatement".equals(method.getName())) {
throw failure;
}
return defaultValue(method.getReturnType());
}));
RuntimeException error = Assertions.assertThrows(
RuntimeException.class,
() -> agent.getObjectSource(null, "P_6141", "PROCEDURE")
);
Assertions.assertSame(failure, error.getCause());
}
@Test
void rejectsUnsupportedObjectTypesBeforeQuerying() {
FirebirdAgent agent = new FirebirdAgent();
IllegalArgumentException error = Assertions.assertThrows(
IllegalArgumentException.class,
() -> agent.getObjectSource(null, "P_6141", "VIEW")
);
Assertions.assertEquals("Unsupported object type: VIEW", error.getMessage());
}
@SafeVarargs
private static FirebirdAgent agentWithRows(
List<String> sql,
List<String> parameters,
Map<String, Object>... rows
) {
ResultSet resultSet = resultSet(List.of(rows));
PreparedStatement statement = proxy(PreparedStatement.class, (method, args) -> {
if ("setString".equals(method.getName())) {
parameters.add(args[0] + "=" + args[1]);
return null;
}
if ("executeQuery".equals(method.getName())) {
return resultSet;
}
return defaultValue(method.getReturnType());
});
Connection connection = proxy(Connection.class, (method, args) -> {
if ("prepareStatement".equals(method.getName())) {
sql.add(String.valueOf(args[0]));
return statement;
}
if ("isClosed".equals(method.getName())) {
return false;
}
return defaultValue(method.getReturnType());
});
FirebirdAgent agent = new FirebirdAgent();
TestSupport.setPrivateConnection(agent, connection);
return agent;
}
private static ResultSet resultSet(List<Map<String, Object>> rows) {
int[] index = {-1};
boolean[] wasNull = {false};
return proxy(ResultSet.class, (method, args) -> {
if ("next".equals(method.getName())) {
index[0] += 1;
return index[0] < rows.size();
}
if ("getString".equals(method.getName())) {
Object value = rows.get(index[0]).get(String.valueOf(args[0]));
wasNull[0] = value == null;
return value == null ? null : String.valueOf(value);
}
if ("getInt".equals(method.getName())) {
Object value = rows.get(index[0]).get(String.valueOf(args[0]));
wasNull[0] = value == null;
return value == null ? 0 : ((Number) value).intValue();
}
if ("wasNull".equals(method.getName())) {
return wasNull[0];
}
return defaultValue(method.getReturnType());
});
}
private static Map<String, Object> row(Object... values) {
Map<String, Object> row = new HashMap<>();
for (int index = 0; index < values.length; index += 2) {
row.put((String) values[index], values[index + 1]);
}
return row;
}
private static String procedureBody() {
return """
DECLARE VARIABLE V_NOTE VARCHAR(20);
BEGIN
O_ID = P_ID;
O_TEXT = P_LABEL || ':' || P_DOM;
SUSPEND;
END""";
}
private static <T> T proxy(Class<T> type, MethodHandler handler) {
InvocationHandler invocationHandler = new InvocationHandler() {
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
return handler.handle(method, args == null ? new Object[0] : args);
}
};
return type.cast(Proxy.newProxyInstance(type.getClassLoader(), new Class<?>[]{type}, invocationHandler));
}
private static Object defaultValue(Class<?> type) {
if (type == Boolean.TYPE) return false;
if (type == Byte.TYPE) return (byte) 0;
if (type == Short.TYPE) return (short) 0;
if (type == Integer.TYPE) return 0;
if (type == Long.TYPE) return 0L;
if (type == Float.TYPE) return 0f;
if (type == Double.TYPE) return 0d;
if (type == Character.TYPE) return (char) 0;
return null;
}
private interface MethodHandler {
Object handle(Method method, Object[] args) throws Throwable;
}
}