@@ -18,6 +18,7 @@
 package org.dkpro.jwpl.api;
 
 import java.util.HashSet;
+import java.util.List;
 import java.util.Set;
 
 import org.dkpro.jwpl.api.exception.WikiApiException;
@@ -40,6 +41,16 @@ public class Category
     implements WikiConstants
 {
 
+    /**
+     * The native query {@link #createCategory(Title)} runs to find a category, taking its name as
+     * parameter {@code name}. It yields the category entities found. The comparison is done in the
+     * collation of the column, which keeps the index on the column usable, so the caller has to
+     * pick the exact match.
+     *
+     * @see Wikipedia#PAGE_NAMES_BY_NAME_QUERY
+     */
+    static final String CATEGORY_BY_NAME_QUERY = "select * from Category where name = :name";
+
     private final CategoryDAO catDAO;
     private org.dkpro.jwpl.api.hibernate.Category hibernateCategory;
     private final Wikipedia wiki;
@@ -134,12 +145,19 @@ private void createCategory(Title title) throws WikiPageNotFoundException
     {
         String name = title.getWikiStyleTitle();
 
-        final String query = "select * from Category where name = :name"
-                + (wiki.getDatabaseConfiguration().supportsCollation() ? Wikipedia.SQL_COLLATION
-                        : "");
-        hibernateCategory = wiki.__inTransaction(session -> session
-                .createNativeQuery(query, org.dkpro.jwpl.api.hibernate.Category.class)
-                .setParameter("name", name, String.class).uniqueResult());
+        List<org.dkpro.jwpl.api.hibernate.Category> candidates = wiki.__inTransaction(
+                session -> session
+                        .createNativeQuery(CATEGORY_BY_NAME_QUERY,
+                                org.dkpro.jwpl.api.hibernate.Category.class)
+                        .setParameter("name", name, String.class).list());
+
+        // the query compares in the collation of the column, so keep the exact match only
+        for (org.dkpro.jwpl.api.hibernate.Category candidate : candidates) {
+            if (name.equals(candidate.getName())) {
+                hibernateCategory = candidate;
+                break;
+            }
+        }
 
         // if there is no category with this name, the hibernateCategory is null
         if (hibernateCategory == null) {
 
@@ -53,9 +53,19 @@ public class Wikipedia
     private static final Logger logger = LoggerFactory
             .getLogger(MethodHandles.lookup().lookupClass());
 
-    // Note well: The whitespace at the beginning of this constant is here on purpose. Do NOT remove
-    // it!
-    static final String SQL_COLLATION = " COLLATE utf8mb4_bin"; /* " COLLATE utf8_bin"; */
+    /**
+     * The native query {@link #existsPage(String)} runs to find the entries of a title, taking the
+     * title as parameter {@code pName}. It yields the names of the entries found.
+     * <p>
+     * Whether the comparison is case-sensitive depends on the collation of the column, and MySQL
+     * and MariaDB default to case-insensitive ones. An explicit binary collation in the query,
+     * though, keeps these databases from using the index on the column, which turns every lookup
+     * into a full scan. So the query compares in the collation of the column, and the caller keeps
+     * only the entries whose name equals the title exactly. These are few: the case variants of
+     * one title at most.
+     */
+    static final String PAGE_NAMES_BY_NAME_QUERY = "select p.name from PageMapLine as p "
+            + "where p.name = :pName";
 
     /**
      * Upper bound for the number of page ids bound into a single {@code in (..)} clause of
@@ -745,23 +755,14 @@ public boolean existsPage(String title) {
 
         String encodedTitle = t.getWikiStyleTitle();
 
-        final String query = "select p.id from PageMapLine as p where p.name = :pName"
-                + (dbConfig.supportsCollation() ? SQL_COLLATION : "");
-
-        return __inTransaction(session -> {
-            // Eclipse somehow thinks that setParameter returns a MutationQuery instead of a
-            // NativeQuery...
-            // A name is not unique in PageMapLine: case variants of one title map to their own
-            // entry, and a database whose charset cannot represent a title stores the substituted
-            // characters, which lets unrelated titles collapse onto one name. Asking for a unique
-            // result made this method throw NonUniqueResultException - unchecked, and out of a
-            // method that promises a boolean instead of an exception. One entry is all it takes to
-            // answer the question.
-            var nativeQuery = session.createNativeQuery(query, Long.class)
-                    .setParameter("pName", encodedTitle, String.class)
-                    .setMaxResults(1);
-            return nativeQuery.uniqueResult();
-        }) != null;
+        // A name is not unique in PageMapLine: case variants of one title map to their own
+        // entry, and a database whose charset cannot represent a title stores the substituted
+        // characters, which lets unrelated titles collapse onto one name. So all entries found
+        // are fetched, and one of them matching the title exactly is all it takes.
+        List<String> names = __inTransaction(
+                session -> session.createNativeQuery(PAGE_NAMES_BY_NAME_QUERY, String.class)
+                        .setParameter("pName", encodedTitle, String.class).list());
+        return names.contains(encodedTitle);
     }
 
     /**
 
@@ -28,6 +28,7 @@
 import java.util.Collections;
 import java.util.HashSet;
 import java.util.List;
+import java.util.Locale;
 import java.util.Set;
 import java.util.UUID;
 
@@ -342,11 +343,23 @@ public void testCreateCategoryByName()
         }
     }
 
+    /**
+     * Category lookups are exact: a case variant of a name that has no entry of its own does not
+     * denote a category, whatever the collation of the name column.
+     */
+    @Test
+    public void testCreateCategoryByNameCaseVariant()
+    {
+        assertThrows(WikiPageNotFoundException.class,
+                () -> new Category(wiki, A_FAMOUS_CATEGORY.toLowerCase(Locale.ROOT)));
+        assertThrows(WikiPageNotFoundException.class,
+                () -> new Category(wiki, A_FAMOUS_CATEGORY.toUpperCase(Locale.ROOT)));
+    }
+
     @Test
     public void testCreateCategoryByNameIsCaseSensitive()
     {
-        // the name lookup uses a binary collation where supported, so a variant that only
-        // differs in case must not match
+        // the name lookup is exact, so a variant that only differs in case must not match
         assertThrows(WikiPageNotFoundException.class, () -> new Category(wiki, "People of ukp"));
     }
 
 
@@ -0,0 +1,82 @@
+/*
+ * Licensed to the Technische Universität Darmstadt under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The Technische Universität Darmstadt
+ * licenses this file to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.dkpro.jwpl.api;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+
+import java.sql.Connection;
+import java.sql.DriverManager;
+import java.sql.PreparedStatement;
+import java.sql.ResultSet;
+import java.sql.SQLException;
+
+import org.dkpro.jwpl.api.testdb.JwplTestDatabase;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.condition.EnabledIf;
+
+/**
+ * Verifies that the exact, case-sensitive name lookups of {@link Wikipedia#existsPage(String)} and
+ * {@link Category#Category(Wikipedia, String)} can use the name indexes on MySQL and MariaDB. An
+ * explicit collation in the comparison, e.g. {@code COLLATE utf8mb4_bin}, would force a full scan
+ * instead.
+ */
+@EnabledIf("isMySqlFamily")
+public class NameLookupIndexTest
+    extends BaseJWPLTest
+{
+
+    static boolean isMySqlFamily()
+    {
+        return JwplTestDatabase.selectEngine() != JwplTestDatabase.Engine.HSQLDB;
+    }
+
+    @Test
+    public void testExistsPageQueryUsesNameIndex() throws SQLException
+    {
+        assertIndexLookup(Wikipedia.PAGE_NAMES_BY_NAME_QUERY,
+                "Exploring_the_Potential_of_Semantic_Relatedness_in_Information_Retrieval",
+                "name_index");
+    }
+
+    @Test
+    public void testCategoryQueryUsesNameIndex() throws SQLException
+    {
+        assertIndexLookup(Category.CATEGORY_BY_NAME_QUERY, "People_of_UKP", "nameIndex");
+    }
+
+    private static void assertIndexLookup(String query, String name, String index)
+        throws SQLException
+    {
+        DatabaseConfiguration db = obtainDbConfiguration();
+        String sql = "EXPLAIN " + query.replaceAll(":\\w+", "?");
+        try (Connection c = DriverManager.getConnection(db.getJdbcURL(), db.getUser(),
+                db.getPassword());
+                PreparedStatement ps = c.prepareStatement(sql)) {
+            long parameters = sql.chars().filter(ch -> ch == '?').count();
+            for (int i = 1; i <= parameters; i++) {
+                ps.setString(i, name);
+            }
+            try (ResultSet rs = ps.executeQuery()) {
+                assertTrue(rs.next(), "EXPLAIN returned no plan for: " + sql);
+                assertEquals("ref", rs.getString("type"), sql);
+                assertEquals(index, rs.getString("key"), sql);
+            }
+        }
+    }
+}
@@ -28,6 +28,7 @@
 import java.lang.invoke.MethodHandles;
 import java.util.Collections;
 import java.util.List;
+import java.util.Locale;
 import java.util.Map;
 import java.util.Set;
 import java.util.UUID;
@@ -264,6 +265,17 @@ public void testExistsPageByTitleInvalid()
         assertFalse(wiki.existsPage(" (X)"));
     }
 
+    /**
+     * Title lookups are exact: a case variant of a title that has no entry of its own does not
+     * exist, whatever the collation of the name column.
+     */
+    @Test
+    public void testExistsPageByTitleCaseVariant()
+    {
+        assertFalse(wiki.existsPage(A_FAMOUS_PAGE.replace("Potential", "potential")));
+        assertFalse(wiki.existsPage(A_FAMOUS_PAGE.toUpperCase(Locale.ROOT)));
+    }
+
     @Test
     public void testExistsPageByTitleNullOrEmpty()
     {