Replace QualifiedName with ObjectReference

Author: mrotteveel

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

@@ -8,6 +8,7 @@
 import java.util.ArrayList;
 import java.util.List;
 import java.util.Vector;
+import java.util.stream.Stream;
 
 /**
  * Helper class for collections
@@ -87,4 +88,30 @@ public static <T> List<T> concat(List<T> list1, List<? extends T> list2) {
         return newList;
     }
 
+    /**
+     * Concatenates two or more lists to a new modifiable list.
+     * <p>
+     * If there are no lists in {@code otherLists}, it will return a new list, with the contents of {@code list1}.
+     * </p>
+     *
+     * @param list1
+     *         list 1
+     * @param otherLists
+     *         other lists
+     * @param <T>
+     *         type parameter of {@code list1}, and parent type parameter of lists in {@code otherLists}
+     * @return concatenation of {@code list1} and {@code otherLists}
+     * @see #concat(List, List)
+     */
+    @SafeVarargs
+    public static <T> List<T> concat(List<T> list1, List<? extends T>... otherLists) {
+        int listsSize = list1.size() + Stream.of(otherLists).mapToInt(List::size).sum();
+        var newList = new ArrayList<T>(listsSize);
+        newList.addAll(list1);
+        for (var list : otherLists) {
+            newList.addAll(list);
+        }
+        return newList;
+    }
+
 }

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

@@ -0,0 +1,110 @@
+// SPDX-FileCopyrightText: Copyright 2025 Mark Rotteveel
+// SPDX-License-Identifier: LGPL-2.1-or-later
+package org.firebirdsql.jaybird.util;
+
+import org.firebirdsql.jdbc.QuoteStrategy;
+import org.jspecify.annotations.Nullable;
+
+import java.util.List;
+import java.util.stream.Stream;
+
+import static org.firebirdsql.jaybird.util.StringUtils.trimToNull;
+
+/**
+ * An identifier is an object reference consisting of a single name.
+ *
+ * @since 7
+ * @see ObjectReference
+ */
+public final class Identifier extends ObjectReference {
+
+    private final String name;
+
+    public Identifier(String name) {
+        name = trimToNull(name);
+        if (name == null) {
+            throw new IllegalArgumentException("name cannot be null, empty, or blank");
+        }
+        this.name = name;
+    }
+
+    public String name() {
+        return name;
+    }
+
+    @Override
+    public int size() {
+        return 1;
+    }
+
+    @Override
+    public Identifier at(int index) {
+        if (index != 0) {
+            throw new IndexOutOfBoundsException(index);
+        }
+        return this;
+    }
+
+    @Override
+    public Identifier first() {
+        return this;
+    }
+
+    @Override
+    public Identifier last() {
+        return this;
+    }
+
+    /**
+     * The name, quoted using {@code quoteStrategy}.
+     *
+     * @param quoteStrategy
+     *         quote strategy
+     * @return name, possibly quoted
+     */
+    public String toString(QuoteStrategy quoteStrategy) {
+        return quoteStrategy.quoteObjectName(name);
+    }
+
+    /**
+     * Appends name to {@code sb} using {@code quoteStrategy}.
+     *
+     * @param sb
+     *         string builder to append to
+     * @param quoteStrategy
+     *         quote strategy
+     * @return {@code sb} for chaining
+     */
+    public StringBuilder append(StringBuilder sb, QuoteStrategy quoteStrategy) {
+        return quoteStrategy.appendQuoted(name, sb);
+    }
+
+    @Override
+    public Stream<Identifier> stream() {
+        return Stream.of(this);
+    }
+
+    @Override
+    public List<Identifier> toList() {
+        return List.of(this);
+    }
+
+    @Override
+    public boolean equals(@Nullable Object obj) {
+        if (obj instanceof Identifier other) {
+            return name.equals(other.name);
+        } else if (obj instanceof ObjectReference otherRef) {
+            // We're using ObjectReference, not IdentifierChain, so it'll also work for future subclasses, if any
+            return otherRef.size() == 1 && name.equals(otherRef.at(0).name);
+        }
+        return false;
+    }
+
+    @Override
+    public int hashCode() {
+        // This needs to be consistent with IdentifierChain.hashCode (as if this is a chain with a single item)
+        // We're clearing the sign bit, because that is what IdentifierChain does to avoid negative values
+        return (31 + name.hashCode()) & 0x7FFF_FFFF;
+    }
+
+}

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

@@ -0,0 +1,88 @@
+// SPDX-FileCopyrightText: Copyright 2025 Mark Rotteveel
+// SPDX-License-Identifier: LGPL-2.1-or-later
+package org.firebirdsql.jaybird.util;
+
+import org.firebirdsql.jdbc.QuoteStrategy;
+
+import java.util.List;
+import java.util.stream.Stream;
+
+/**
+ * An identifier chain is an object reference consisting of one or more identifiers.
+ * <p>
+ * In practice, we'll use {@link Identifier} if there is only one identifier.
+ * </p>
+ * <p>
+ * The recommended way to create this object is through {@link ObjectReference#of(String...)} or
+ * {@link ObjectReference#of(List)}.
+ * </p>
+ *
+ * @since 7
+ * @see ObjectReference
+ */
+final class IdentifierChain extends ObjectReference {
+
+    private final List<Identifier> identifiers;
+    // cached hashcode, -1 signals not yet cached
+    private int hashCode = -1;
+
+    IdentifierChain(List<Identifier> identifiers) {
+        if (identifiers.isEmpty()) {
+            throw new IllegalArgumentException("identifier chain cannot be empty");
+        }
+        this.identifiers = List.copyOf(identifiers);
+    }
+
+    @Override
+    public int size() {
+        return identifiers.size();
+    }
+
+    @Override
+    public Identifier at(int index) {
+        return identifiers.get(index);
+    }
+
+    @Override
+    public String toString(QuoteStrategy quoteStrategy) {
+        // Estimate 16 characters per element (including quotes and separator)
+        return append(new StringBuilder(size() * 16), quoteStrategy).toString();
+    }
+
+    @Override
+    public StringBuilder append(StringBuilder sb, QuoteStrategy quoteStrategy) {
+        for (Identifier identifier : identifiers) {
+            identifier.append(sb, quoteStrategy).append('.');
+        }
+        // Remove last dot separator
+        sb.setLength(sb.length() - 1);
+        return sb;
+    }
+
+    @Override
+    public Stream<Identifier> stream() {
+        return identifiers.stream();
+    }
+
+    @Override
+    public List<Identifier> toList() {
+        return identifiers;
+    }
+
+    @Override
+    public int hashCode() {
+        int hashCode = this.hashCode;
+        return hashCode != -1 ? hashCode : hashCode0();
+    }
+
+    private int hashCode0() {
+        // This needs to be consistent with Identifier.hashCode for an instance with a single Identifier
+        int hashCode = 1;
+        for (Identifier identifier : identifiers) {
+            hashCode = 31 * hashCode + identifier.name().hashCode();
+        }
+        // Clear sign bit to avoid -1 (and any other negative value)
+        return this.hashCode = hashCode & 0x7FFF_FFFF;
+    }
+
+}