Deduplicate strings in StatementInfoProcessor

src/main/org/firebirdsql/gds/ng/StatementInfoProcessor.java

@@ -5,8 +5,10 @@
 import org.firebirdsql.gds.ISCConstants;
 import org.firebirdsql.gds.ng.fields.RowDescriptor;
 import org.firebirdsql.gds.ng.fields.RowDescriptorBuilder;
+import org.firebirdsql.jaybird.util.StringDeduplicator;
 
 import java.sql.SQLException;
+import java.util.List;
 
 import static org.firebirdsql.gds.VaxEncoding.iscVaxInteger;
 import static org.firebirdsql.gds.VaxEncoding.iscVaxInteger2;
@@ -21,9 +23,11 @@
 public final class StatementInfoProcessor implements InfoProcessor<InfoProcessor.StatementInfo> {
 
     private static final System.Logger log = System.getLogger(StatementInfoProcessor.class.getName());
+    private static final List<String> DEDUPLICATOR_PRESET = List.of("SYSTEM", "PUBLIC", "SYSDBA");
 
     private final AbstractFbStatement statement;
     private final FbDatabase database;
+    private final StringDeduplicator stringDeduplicator = StringDeduplicator.of(DEDUPLICATOR_PRESET);
 
     /**
      * Creates an instance of this class.
@@ -85,10 +89,8 @@ private void handleTruncatedInfo(final StatementInfo info) throws SQLException {
                 newInfoItems[newIndex++] = 2; // size of short
                 newInfoItems[newIndex++] = (byte) (descriptorIndex & 0xFF);
                 newInfoItems[newIndex++] = (byte) (descriptorIndex >> 8);
-                newInfoItems[newIndex++] = infoItem;
-            } else {
-                newInfoItems[newIndex++] = infoItem;
             }
+            newInfoItems[newIndex++] = infoItem;
         }
         assert newIndex == newInfoItems.length : "newInfoItems size too long";
         // Doubling request buffer up to the maximum
@@ -212,10 +214,11 @@ private int readIntValue(StatementInfo info) {
     private String readStringValue(StatementInfo info) {
         int len = iscVaxInteger2(info.buffer, info.currentIndex);
         info.currentIndex += 2;
+        if (len == 0) return "";
         // TODO Is it correct to use the connection encoding here, or should we use UTF-8 always?
         String value = database.getEncoding().decodeFromCharset(info.buffer, info.currentIndex, len);
         info.currentIndex += len;
-        return value;
+        return stringDeduplicator.get(value);
     }
 
     /**

src/main/org/firebirdsql/jaybird/util/StringDeduplicator.java

@@ -0,0 +1,129 @@
+// SPDX-FileCopyrightText: Copyright 2025 Mark Rotteveel
+// SPDX-License-Identifier: LGPL-2.1-or-later
+package org.firebirdsql.jaybird.util;
+
+import org.jspecify.annotations.Nullable;
+
+import java.io.Serial;
+import java.util.Arrays;
+import java.util.Collection;
+import java.util.LinkedHashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.function.Function;
+
+/**
+ * Best-effort string deduplicator.
+ * <p>
+ * Given this class uses an LRU-evicted map with a maximum capacity internally, 100% deduplication of strings is
+ * <em>not</em> guaranteed.
+ * </p>
+ * <p>
+ * This class is <em>not</em> thread-safe.
+ * </p>
+ *
+ * @author Mark Rotteveel
+ * @since 7
+ */
+public final class StringDeduplicator {
+
+    private static final int DEFAULT_MAX_CAPACITY = 50;
+
+    private final Map<String, String> cache;
+
+    private StringDeduplicator(int maxCapacity, Collection<String> preset) {
+        cache = new StringCache(maxCapacity);
+        // NOTE: if preset.size() is greater than maxCapacity, prefix will be immediately evicted
+        preset.forEach(v -> cache.put(v, v));
+    }
+
+    /**
+     * Deduplicates this value if already cached, otherwise caches and returns {@code value}.
+     *
+     * @param value
+     *         value to deduplicate (can be {@code null})
+     * @return previous cached value equal to {@code value}, or {@code value} itself
+     */
+    public @Nullable String get(@Nullable String value) {
+        if (value == null) return null;
+        if (value.isEmpty()) return "";
+        return cache.computeIfAbsent(value, Function.identity());
+    }
+
+    /**
+     * @return a string deduplicator with a default max capacity
+     */
+    public static StringDeduplicator of() {
+        return of(DEFAULT_MAX_CAPACITY, List.of());
+    }
+
+    /**
+     * @param preset
+     *         values to initially add to the cache
+     * @return a string deduplicator with a default max capacity, initialized with {@code preset}
+     */
+    public static StringDeduplicator of(String... preset) {
+        return of(Arrays.asList(preset));
+    }
+
+    /**
+     * @param preset
+     *         values to initially add to the cache
+     * @return a string deduplicator with a default max capacity, initialized with {@code preset}
+     */
+    public static StringDeduplicator of(Collection<String> preset) {
+        return of(DEFAULT_MAX_CAPACITY, preset);
+    }
+
+    /**
+     * @param maxCapacity
+     *         maximum capacity
+     * @param preset
+     *         values to initially add to the cache
+     * @return a string deduplicator with max capacity {@code maxCapacity}, initialized with {@code preset}
+     */
+    public static StringDeduplicator of(int maxCapacity, String... preset) {
+        return of(maxCapacity, Arrays.asList(preset));
+    }
+
+    /**
+     * @param maxCapacity
+     *         maximum capacity
+     * @param preset
+     *         values to initially add to the cache
+     * @return a string deduplicator with max capacity {@code maxCapacity}, initialized with {@code preset}
+     */
+    public static StringDeduplicator of(int maxCapacity, Collection<String> preset) {
+        return new StringDeduplicator(maxCapacity, preset);
+    }
+
+    /**
+     * String cache with LRU (Least-Recently Used) eviction order.
+     */
+    private static final class StringCache extends LinkedHashMap<String, String> {
+
+        @Serial
+        private static final long serialVersionUID = -201579959301651333L;
+
+        private final int maxCapacity;
+
+        private StringCache(int maxCapacity) {
+            super(initialCapacity(maxCapacity), 0.75f, true);
+            if (maxCapacity <= 0) {
+                throw new IllegalArgumentException("maxCapacity must be greater than 0, was: " + maxCapacity);
+            }
+            this.maxCapacity = maxCapacity;
+        }
+
+        private static int initialCapacity(int maxCapacity) {
+            return Math.max(8, maxCapacity / 2);
+        }
+
+        @Override
+        protected boolean removeEldestEntry(Map.Entry<String, String> eldest) {
+            return size() > maxCapacity;
+        }
+
+    }
+
+}

src/test/org/firebirdsql/jaybird/util/StringDeduplicatorTest.java

@@ -0,0 +1,113 @@
+// SPDX-FileCopyrightText: Copyright 2025 Mark Rotteveel
+// SPDX-License-Identifier: LGPL-2.1-or-later
+package org.firebirdsql.jaybird.util;
+
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.params.ParameterizedTest;
+import org.junit.jupiter.params.provider.ValueSource;
+
+import java.util.List;
+import java.util.stream.IntStream;
+
+import static org.firebirdsql.common.matchers.MatcherAssume.assumeThat;
+import static org.hamcrest.Matchers.allOf;
+import static org.hamcrest.Matchers.equalTo;
+import static org.hamcrest.Matchers.not;
+import static org.hamcrest.Matchers.sameInstance;
+import static org.junit.jupiter.api.Assertions.assertDoesNotThrow;
+import static org.junit.jupiter.api.Assertions.assertNull;
+import static org.junit.jupiter.api.Assertions.assertSame;
+import static org.junit.jupiter.api.Assertions.assertThrows;
+
+/**
+ * Tests for {@link StringDeduplicator}.
+ */
+class StringDeduplicatorTest {
+
+    @Test
+    void deduplicate() {
+        var deduplicator = StringDeduplicator.of();
+
+        final String value1 = "value1";
+        final String value1Copy = copyOf(value1);
+
+        // Check our assumptions (indirectly test copyOf(...))
+        assumeEqualNotSameInstance(value1, value1Copy, "value1Copy should be a distinct instance");
+
+        assertSame(value1, deduplicator.get(value1));
+        assertSame(value1, deduplicator.get(value1Copy));
+    }
+
+    @Test
+    void deduplicateToPreset() {
+        var deduplicator = StringDeduplicator.of("PRESET_1", "PRESET_2");
+
+        assertSame("PRESET_1", deduplicator.get(copyOf("PRESET_1")));
+        assertSame("PRESET_2", deduplicator.get(copyOf("PRESET_2")));
+    }
+
+    @Test
+    void eviction() {
+        final int maxCapacity = 5;
+        var deduplicator = StringDeduplicator.of(maxCapacity, List.of());
+
+        final String value1 = "value1";
+        final String value1Copy = copyOf(value1);
+
+        assertSame(value1, deduplicator.get(value1), value1);
+        // Deduplicate other values to evict value1
+        IntStream.rangeClosed(2, maxCapacity + 1).forEach(i -> {
+            String value = "value" + i;
+            assertSame(value, deduplicator.get(value), value);
+        });
+
+        assertSame(value1Copy, deduplicator.get(value1Copy), "expected value1Copy as value1 has been evicted");
+    }
+
+    @Test
+    void deduplicateNull() {
+        var deduplicator = StringDeduplicator.of();
+
+        assertNull(deduplicator.get(null));
+    }
+
+    @Test
+    void deduplicateEmptyString_toLiteralEmpty() {
+        var deduplicator = StringDeduplicator.of();
+
+        final String emptyCopy = copyOf("");
+        assumeEqualNotSameInstance("", emptyCopy, "emptyCopy should be a distinct instance");
+
+        assertSame("", deduplicator.get(emptyCopy), "should deduplicate to empty literal instance, not copy");
+    }
+
+    @ParameterizedTest
+    @ValueSource(ints = { -2, -1, 0 })
+    void cannotCreateWithMaxCapacityZeroOrSmaller(int maxCapacity) {
+        assertThrows(IllegalArgumentException.class, () -> StringDeduplicator.of(maxCapacity, List.of()));
+    }
+
+    @ParameterizedTest
+    @ValueSource(ints = { 1, 2, 10 })
+    void canCreateWithMaxCapacityOneOrGreater(int maxCapacity) {
+        assertDoesNotThrow(() -> StringDeduplicator.of(maxCapacity, List.of()));
+    }
+
+    /**
+     * Creates a distinct copy of {@code value}.
+     *
+     * @param value
+     *         value to copy
+     * @return distinct copy of {@code value} (i.e. {@code new String(value)})
+     */
+    @SuppressWarnings("StringOperationCanBeSimplified")
+    private static String copyOf(String value) {
+        return new String(value);
+    }
+
+    private void assumeEqualNotSameInstance(String v1, String v2, String message) {
+        assumeThat(message, v2,
+                allOf(equalTo(v1), not(sameInstance(v1))));
+    }
+
+}