import org.codelibs.fess.ds.callback.IndexUpdateCallback;
import org.codelibs.fess.entity.DataStoreParams;
import org.codelibs.fess.opensearch.config.exentity.DataConfig;

/**
 * The interface for DataStore.
 */
public interface DataStore {

    /**
     * Store the data.
     * @param config The data configuration.
     * @param callback The callback.
     * @param initParamMap The initial parameters.
     */

     * @param dataStore the data store instance to register, must not be null
     * @throws IllegalArgumentException if either name or dataStore is null
     */
    public void add(final String name, final DataStore dataStore) {
        if (name == null || dataStore == null) {
            throw new IllegalArgumentException("name or dataStore is null.");
        }
        if (logger.isDebugEnabled()) {

        TestDataStore dataStore = new TestDataStore("TestStore");
        dataStoreFactory.add("MyStore", dataStore);

        assertSame(dataStore, dataStoreFactory.getDataStore("MyStore"));
        assertSame(dataStore, dataStoreFactory.getDataStore("mystore"));
        assertSame(dataStore, dataStoreFactory.getDataStore("MYSTORE"));
        assertSame(dataStore, dataStoreFactory.getDataStore("mYsToRe"));
    }

import org.codelibs.fess.unit.UnitFessTestCase;

public class DataStoreTest extends UnitFessTestCase {

    private DataStore dataStore;

    @Override
    public void setUp() throws Exception {
        super.setUp();
    }

    public void test_store_basic() {
        // Create a simple DataStore implementation for testing
        final AtomicBoolean storeCalled = new AtomicBoolean(false);

        assertEquals("123PARAM2+,PARAM3*abc", dataStore.convertValue(Constants.DEFAULT_SCRIPT, value, paramMap));

        value = null;
        assertEquals("", dataStore.convertValue(Constants.DEFAULT_SCRIPT, value, paramMap));

        value = "";
        assertEquals("", dataStore.convertValue(Constants.DEFAULT_SCRIPT, value, paramMap));

        value = " ";

            dataStore = dataStoreFactory.getDataStore(dataConfig.getHandlerName());
            if (dataStore == null) {
                logger.error("DataStore({}) is not found.", dataConfig.getHandlerName());
            } else {
                try {
                    dataStore.store(dataConfig, indexUpdateCallback, initParamMap);

import org.codelibs.fess.opensearch.config.exentity.DataConfig;
import org.codelibs.fess.util.ComponentUtil;

/**
 * The abstract class for DataStore.
 */
public abstract class AbstractDataStore implements DataStore {

    /**
     * Default constructor.
     */
    public AbstractDataStore() {
        // nothing
    }

    }

    private static class FastMockDataStoreFactory extends DataStoreFactory {
        @Override
        public DataStore getDataStore(String name) {
            return new FastMockDataStore();
        }
    }

    private static class FastMockDataStore implements DataStore {
        @Override
        public void store(DataConfig dataConfig, IndexUpdateCallback callback, DataStoreParams params) {

     */
    public Map<String, Object> process(final Map<String, Object> target, final AccessResult<String> accessResult) {
        return process(target);
    }

    /**
     * Processes a document map for datastore operations.
     * Default implementation delegates to the basic process method.
     *
     * @param target the document data to process
     * @param params the data store parameters

to use S3 and other S3-compatible object stores such as MinIO. MapReduce workloads typically interact with object stores in the same way they do with HDFS. These workloads rely on HDFS atomic rename functionality to complete writing data to the datastore. Object storage operations are atomic by nature and they do not require/implement rename API. The default S3A committer emulates renames through copy and delete APIs. This interaction pattern causes significant loss of performance because of the...