urlQueue.setMethod(Constants.GET_METHOD);
        insert(urlQueue);
    }

    /**
     * Inserts a URL queue entry into the OpenSearch index.
     *
     * @param urlQueue The URL queue entry to insert.
     */
    @Override
    public void insert(final OpenSearchUrlQueue urlQueue) {
        try {
            super.insert(urlQueue, urlQueue.getId() == null ? OpType.CREATE : OpType.INDEX);

                throw new CrawlingAccessException("[" + e.status() + "] Failed to insert " + id, e);
            }
            throw new OpenSearchAccessException("[" + e.status() + "] Failed to insert " + id, e);
        } catch (final Exception e) {
            throw new OpenSearchAccessException("Failed to insert " + id, e);
        }
    }

    /**
     * Inserts multiple documents into the OpenSearch index using bulk operations.
     *

                    }
                });

    }

    /**
     * Inserts or updates a user in LDAP directory.
     *
     * @param user the user object to insert or update
     */
    public void insert(final User user) {
        if (!fessConfig.isLdapAdminEnabled(user.getName())) {
            return;
        }

    }

    /**
     * Inserts a new character mapping item into the dictionary file.
     *
     * @param item the character mapping item to insert
     */
    @Override
    public synchronized void insert(final CharMappingItem item) {
        try (MappingUpdater updater = new MappingUpdater(item)) {
            reload(updater);

        int descriptionIndex = xmlOutput.indexOf("<description>");
        int urlIndex = xmlOutput.indexOf("<url>");

        // Verify description is inserted between name and url
        assertTrue(nameIndex < descriptionIndex, "name should come before description");
        assertTrue(descriptionIndex < urlIndex, "description should come before url");
    }

    @Test
    void testInsertElementNotInOrdering() throws Exception {

     * @return an optional containing the item if found
     */
    public abstract OptionalEntity<T> get(long id);

    /**
     * Inserts a new dictionary item.
     *
     * @param item the item to insert
     */
    public abstract void insert(T item);

    /**
     * Updates an existing dictionary item.
     *
     * @param item the item to update
     */

     * @return Optional entity containing the bad word if found.
     */
    public OptionalEntity<BadWord> getBadWord(final String id) {
        return badWordBhv.selectByPK(id);
    }

    /**
     * Stores (inserts or updates) a bad word.
     * @param badWord The bad word to store.
     */
    public void store(final BadWord badWord) {

        badWordBhv.insertOrUpdate(badWord, op -> op.setRefreshPolicy(Constants.TRUE));

    public OptionalEntity<User> getUserByName(final String username) {
        return userBhv.selectEntity(cb -> {
            cb.query().setName_Equal(username);
        });
    }

    /**
     * Stores (inserts or updates) a user in the system.
     * Handles user authentication setup and database persistence.
     * If the surname is blank, it will be set to the user's name.
     *
     * @param user the user entity to store

   * Returns the tag attached with [type] as a key. If it is absent, then [computeIfAbsent] is
   * called and that value is both inserted and returned.
   *
   * If multiple calls to this function are made concurrently with the same [type], multiple values
   * may be computed. But only one value will be inserted, and that inserted value will be returned
   * to all callers.
   *

        BloomFilter.create(Funnels.integerFunnel(), 15_000_000, 0.01);

    // This check has to be BEFORE the loop because the random insertions can
    // flip GOLDEN_PRESENT_KEY to true even if it wasn't explicitly inserted
    // (false positive).
    assertThat(bloomFilter.mightContain(GOLDEN_PRESENT_KEY)).isFalse();
    for (int i = 0; i < NUM_PUTS; i++) {
      bloomFilter.put(getNonGoldenRandomKey());
    }