diff --git a/agents/drivers/firebird/src/main/java/com/dbx/agent/firebird/FirebirdAgent.java b/agents/drivers/firebird/src/main/java/com/dbx/agent/firebird/FirebirdAgent.java index 4dedbaf0c1..23c29eb814 100644 --- a/agents/drivers/firebird/src/main/java/com/dbx/agent/firebird/FirebirdAgent.java +++ b/agents/drivers/firebird/src/main/java/com/dbx/agent/firebird/FirebirdAgent.java @@ -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 inputs = new ArrayList<>(); + List 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 inputs, + List 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 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(); } diff --git a/agents/drivers/firebird/src/test/java/com/dbx/agent/firebird/FirebirdAgentTest.java b/agents/drivers/firebird/src/test/java/com/dbx/agent/firebird/FirebirdAgentTest.java new file mode 100644 index 0000000000..f45e0c861c --- /dev/null +++ b/agents/drivers/firebird/src/test/java/com/dbx/agent/firebird/FirebirdAgentTest.java @@ -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 sql = new ArrayList<>(); + List 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 sql = new ArrayList<>(); + List 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 sql, + List parameters, + Map... 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> 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 row(Object... values) { + Map 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 proxy(Class 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; + } +}