gvSIG projects pool

/*

 * gvSIG. Desktop Geographic Information System.

 * 

 * Copyright (C) 2007-2020 gvSIG Association.

 * 

 * This program is free software; you can redistribute it and/or

 * modify it under the terms of the GNU General Public License

 * as published by the Free Software Foundation; either version 3

 * of the License, or (at your option) any later version.

 * 

 * This program is distributed in the hope that it will be useful,

 * but WITHOUT ANY WARRANTY; without even the implied warranty of

 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

 * GNU General Public License for more details.

 * 

 * You should have received a copy of the GNU General Public License 

 * along with this program. If not, see <https://www.gnu.org/licenses/>. 

 * 

 * For any additional information, do not hesitate to contact us

 * at info AT gvsig.com, or visit our website www.gvsig.com.

 */

package org.gvsig.vcsgis.lib.repository.localdb;

import java.time.LocalDateTime;

import java.util.Date;

import java.util.HashMap;

import java.util.List;

import java.util.Map;

import java.util.Objects;

import java.util.zip.CRC32;

import javax.json.JsonObject;

import org.apache.commons.lang3.BooleanUtils;

import org.apache.commons.lang3.StringUtils;

import org.gvsig.fmap.dal.DALLocator;

import org.gvsig.fmap.dal.DataManager;

import org.gvsig.fmap.dal.DataServerExplorerParameters;

import org.gvsig.fmap.dal.DatabaseWorkspaceManager;

import static org.gvsig.fmap.dal.DatabaseWorkspaceManager.CONFIG_NAME_STORESREPOSITORYID;

import static org.gvsig.fmap.dal.DatabaseWorkspaceManager.TABLE_CONFIGURATION;

import static org.gvsig.fmap.dal.DatabaseWorkspaceManager.TABLE_REPOSITORY;

import static org.gvsig.fmap.dal.DatabaseWorkspaceManager.TABLE_RESOURCES;

import org.gvsig.fmap.dal.feature.FeatureStore;

import org.gvsig.fmap.dal.feature.FeatureType;

import org.gvsig.fmap.dal.store.jdbc.JDBCNewStoreParameters;

import org.gvsig.fmap.dal.store.jdbc.JDBCServerExplorerParameters;

import org.gvsig.fmap.dal.store.jdbc.JDBCStoreParameters;

import org.gvsig.fmap.dal.store.jdbc2.JDBCServerExplorer;

import org.gvsig.json.Json;

import org.gvsig.json.JsonObjectBuilder;

import org.gvsig.tools.ToolsLocator;

import static org.gvsig.tools.dataTypes.DataTypeUtils.toTimestamp;

import org.gvsig.tools.dispose.DisposeUtils;

import org.gvsig.tools.dispose.impl.AbstractDisposable;

import org.gvsig.tools.task.SimpleTaskStatus;

import org.gvsig.vcsgis.lib.VCSGisCodeGenerator;

import org.gvsig.vcsgis.lib.VCSGisEntity;

import org.gvsig.vcsgis.lib.VCSGisLocator;

import org.gvsig.vcsgis.lib.VCSGisManager;

import static org.gvsig.vcsgis.lib.VCSGisManager.ERR_AUTHENTICATION_EXPIRED;

import static org.gvsig.vcsgis.lib.VCSGisManager.ERR_INVALID_AUTHENTICATION_TOKEN;

import static org.gvsig.vcsgis.lib.VCSGisManager.ERR_INVALID_USERCODE;

import static org.gvsig.vcsgis.lib.VCSGisManager.ERR_OK;

import static org.gvsig.vcsgis.lib.VCSGisManager.ERR_USER_NOT_AUTHORIZED;

import org.gvsig.vcsgis.lib.VCSGisRuntimeException;

import org.gvsig.vcsgis.lib.VCSGisUser;

import org.gvsig.vcsgis.lib.VCSGisUtils;

import org.gvsig.vcsgis.lib.repository.VCSGisRepository;

import org.gvsig.vcsgis.lib.repository.localdb.requests.AbstractRequestLocaldb;

import org.gvsig.vcsgis.lib.repository.localdb.requests.AuthenticateRequestLocaldb;

import org.gvsig.vcsgis.lib.repository.localdb.requests.CheckoutRequestLocaldb;

import org.gvsig.vcsgis.lib.repository.localdb.requests.CommitRequestLocaldb;

import org.gvsig.vcsgis.lib.repository.localdb.requests.EntitiesRequestLocaldb;

import org.gvsig.vcsgis.lib.repository.localdb.requests.HistoryRequestLocaldb;

import org.gvsig.vcsgis.lib.repository.localdb.requests.RowCreateRequestLocaldb;

import org.gvsig.vcsgis.lib.repository.localdb.requests.RowDeleteRequestLocaldb;

import org.gvsig.vcsgis.lib.repository.localdb.requests.RowUpdateRequestLocaldb;

import org.gvsig.vcsgis.lib.repository.localdb.requests.TopologyPlansRequestLocaldb;

import org.gvsig.vcsgis.lib.repository.localdb.requests.UpdateRequestLocaldb;

import org.gvsig.vcsgis.lib.repository.localdb.requests.UsersRequestLocaldb;

import org.gvsig.vcsgis.lib.repository.localdb.tables.ConfigRepoTable;

import org.gvsig.vcsgis.lib.repository.localdb.tables.DataRepoTable;

import org.gvsig.vcsgis.lib.repository.localdb.tables.EntitiesRepoTable;

import org.gvsig.vcsgis.lib.repository.localdb.tables.HooksRepoTable;

import org.gvsig.vcsgis.lib.repository.localdb.tables.RevisionsRepoTable;

import org.gvsig.vcsgis.lib.repository.localdb.tables.TopologyplanRepoTable;

import org.gvsig.vcsgis.lib.repository.localdb.tables.UsersRepoTable;

import org.gvsig.vcsgis.lib.repository.requests.VCSGisAuthenticateRequest;

import org.gvsig.vcsgis.lib.repository.requests.VCSGisCheckoutRequest;

import org.gvsig.vcsgis.lib.repository.requests.VCSGisCommitRequest;

import org.gvsig.vcsgis.lib.repository.requests.VCSGisEntitiesRequest;

import org.gvsig.vcsgis.lib.repository.requests.VCSGisHistoryRequest;

import org.gvsig.vcsgis.lib.repository.requests.VCSGisRequest;

import org.gvsig.vcsgis.lib.repository.requests.VCSGisRowCreateRequest;

import org.gvsig.vcsgis.lib.repository.requests.VCSGisRowDeleteRequest;

import org.gvsig.vcsgis.lib.repository.requests.VCSGisRowUpdateRequest;

import org.gvsig.vcsgis.lib.repository.requests.VCSGisTopologyPlansRequest;

import org.gvsig.vcsgis.lib.repository.requests.VCSGisUpdateRequest;

import org.gvsig.vcsgis.lib.repository.requests.VCSGisUsersRequest;

import org.gvsig.vcsgis.lib.requests.AbstractRequest;

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

/**

 *

 * @author gvSIG Team

 */

@SuppressWarnings("UseSpecificCatch")

public class VCSGisRepositoryLocaldb extends AbstractDisposable implements VCSGisRepository {

    private static final Logger LOGGER = LoggerFactory.getLogger(VCSGisRepositoryLocaldb.class);

    public static int create(JDBCServerExplorerParameters serverParameters, VCSGisCodeGenerator codeGenerator, SimpleTaskStatus status) {

        if( status == null ) {

            status = ToolsLocator.getTaskStatusManager().createDefaultSimpleTaskStatus("vcsgis init");

            status.add();

        }

        LOGGER.info("Initializing repository "+Objects.toString(serverParameters.toJson()).replace('\n', ' ').replaceAll("\"password\":\"[^\"]*\"", "\"password\":\"****\""));

        int r = 3;

        status.push();

        DataManager dataManager = DALLocator.getDataManager();

        JDBCServerExplorer server = null;

        try {

            server = (JDBCServerExplorer) dataManager.openServerExplorer(

                    serverParameters.getProviderName(),

                    serverParameters

            );

        } catch (Exception ex) {

            throw new VCSGisRuntimeException(VCSGisManager.ERR_INVALID_REPOSITORY, "Can't open server explorer.");

        }

        try {

            status.setTitle("vcsgis init");

            DatabaseWorkspaceManager databaseWorkspaceManager = dataManager.createDatabaseWorkspaceManager(serverParameters);

            if(!databaseWorkspaceManager.existsTable(TABLE_CONFIGURATION)){

                databaseWorkspaceManager.createTable(TABLE_CONFIGURATION);

            }

            if(!databaseWorkspaceManager.existsTable(TABLE_RESOURCES)){

                databaseWorkspaceManager.createTable(TABLE_RESOURCES);

            }

            if(!databaseWorkspaceManager.existsTable(TABLE_REPOSITORY)){

                databaseWorkspaceManager.createTable(TABLE_REPOSITORY);

                databaseWorkspaceManager.set(CONFIG_NAME_STORESREPOSITORYID, "VCSGIS");

            }

            databaseWorkspaceManager.connect();

            FeatureType[] tables = new FeatureType[] {

                ConfigRepoTable.featureType(),

                UsersRepoTable.featureType(),

                TopologyplanRepoTable.featureType(),

                EntitiesRepoTable.featureType(),

                RevisionsRepoTable.featureType(),

                DataRepoTable.featureType(),

                HooksRepoTable.featureType(),

            };

            r = 4;

            status.setRangeOfValues(0, tables.length);

            int step = 1;

            for (FeatureType table : tables) {

                status.message(table.getLabel());

                status.setCurValue(step++);

                r = 4+step;

                JDBCNewStoreParameters table_params = server.getAddParameters();

                table_params.setDefaultFeatureType(table.getEditable());

                String tableName = table.getTags().getString("ID");

                table_params.setTable(tableName);

                server.add(server.getProviderName(), table_params, false);

                JDBCStoreParameters openParams = server.get(tableName);

                databaseWorkspaceManager.writeStoresRepositoryEntry(tableName, openParams);

            }

            try {

                server.execute(VCSGisUtils.getSqlTemplate(serverParameters.getProviderName(), "createRepositoryIndex1"));

                server.execute(VCSGisUtils.getSqlTemplate(serverParameters.getProviderName(), "createRepositoryIndex2"));

            } catch (Exception ex) {

                LOGGER.warn("Can't create index in repository", ex);

            }

            VCSGisRepositoryLocaldb repo = new VCSGisRepositoryLocaldb();

            repo.initialize(serverParameters, codeGenerator);

            DisposeUtils.disposeQuietly(repo);

            status.terminate();

        } catch(Exception ex) {

            status.abort();

            LOGGER.warn("Can't init repository.",ex);

            status.message(ex.getMessage());

            return r;

        } finally {

            status.pop();

        }

        return 0;

    }

    private JDBCServerExplorer server;

    private JDBCServerExplorerParameters serverParameters;

    private Map<String,FeatureStore> stores;

    private VCSGisCodeGenerator codeGenerator;

    private String code;

//    private HooksRepoTable hooksTable;

    private boolean allowAssignTheRevisionDate;

//    private boolean authenticationRequired;

//    private boolean authorizationRequired;

    private String token;

    private String userCode;

    private int dataTableBatchSize=-1;

    private HooksRepoTable.RepositoryWatchersNotifier watchersNotifier;

    public VCSGisRepositoryLocaldb() {

        // For persistence

        this.codeGenerator = null;

        this.stores = null;

        this.server = null;

        this.serverParameters = null;

        this.code = null;

        this.allowAssignTheRevisionDate = false;

//        this.authenticationRequired = false;

//        this.authorizationRequired = false;

     }

    @SuppressWarnings({"LeakingThisInConstructor", "CallToThreadStartDuringObjectConstruction"})

    public VCSGisRepositoryLocaldb(JDBCServerExplorerParameters serverParameters, VCSGisCodeGenerator codeGenerator) {

        this.stores = null;

        this.codeGenerator = codeGenerator;

        this.serverParameters = serverParameters;

        DataManager dataManager = DALLocator.getDataManager();

        try {

            this.server = (JDBCServerExplorer) dataManager.openServerExplorer(

                    serverParameters.getProviderName(),

                    serverParameters

            );

        } catch (Exception ex) {

            throw new VCSGisRuntimeException(VCSGisManager.ERR_INVALID_REPOSITORY, "Can't open server explorer.");

        }

        ConfigRepoTable varsTable = new ConfigRepoTable();

        this.code = varsTable.get(this, "REPOSITORY_CODE");

        if (this.code == null){

            throw new VCSGisRuntimeException(VCSGisManager.ERR_INVALID_REPOSITORY, "The database can't have REPOSITORY_CODE variable.");

        }

//        this.authenticationRequired = BooleanUtils.toBoolean(varsTable.get(this, "AUTHENTICATION"));

//        this.authorizationRequired = BooleanUtils.toBoolean(varsTable.get(this, "AUTHORIZATION"));

        HooksRepoTable hooksTable = new HooksRepoTable();

        this.watchersNotifier = hooksTable.createRepositoryWatchersNotifier(this);

        this.watchersNotifier.start();

    }

    private void initialize(JDBCServerExplorerParameters serverParameters, VCSGisCodeGenerator codeGenerator) {

        this.stores = null;

        this.codeGenerator = codeGenerator;

        this.serverParameters = serverParameters;

        DataManager dataManager = DALLocator.getDataManager();

        try {

            this.server = (JDBCServerExplorer) dataManager.openServerExplorer(

                    serverParameters.getProviderName(),

                    serverParameters

            );

        } catch (Exception ex) {

            throw new VCSGisRuntimeException(VCSGisManager.ERR_INVALID_REPOSITORY, "Can't open server explorer.");

        }

        this.code = this.createUniqueCode();

        ConfigRepoTable varsTable = new ConfigRepoTable();

        varsTable.set(this, "REPOSITORY_CODE", this.code);

        varsTable.set(this, "AUTHENTICATION", "false");

        varsTable.set(this, "AUTHORIZATION", "false");

    }

    @Override

    protected void doDispose() {

        if(this.watchersNotifier != null){

            this.watchersNotifier.cancelRequest();

            this.watchersNotifier = null;

        }

        if(this.stores != null){

            for (FeatureStore store : this.stores.values()) {

                DisposeUtils.disposeQuietly(store);

            }

            this.stores = null;

        }

        DisposeUtils.disposeQuietly(this.server);

        this.server = null;

    }

    @Override

    public String getUserCode() {

        return this.userCode;

    }

    @Override

    public String getLabel() {

        return this.server.getParameters().getUrl();

    }

    @Override

    public String createUniqueCode() {

        return this.codeGenerator.generateCode();

    }

    public JDBCServerExplorer getServerExplorer() {

        return this.server;

    }

    public static void selfRegister() {

        Json.registerSerializer(VCSGisRepositoryLocaldb.class);

    }

    @Override

    public VCSGisCommitRequest createCommitRequest() {

        return new CommitRequestLocaldb(this);

    }

    @Override

    public VCSGisUpdateRequest createUpdateRequest(String entityName) {

        return new UpdateRequestLocaldb(this, entityName);

    }

    @Override

    public VCSGisCheckoutRequest createCheckoutRequest(String entityName) {

        return new CheckoutRequestLocaldb(this, entityName);

    }

    @Override

    public void fromJson(JsonObject json) {

        try {

            DataManager dataManager = DALLocator.getDataManager();

            DataServerExplorerParameters explorerParams = (DataServerExplorerParameters) Json.toObject(json, "explorerParams");

            this.server = (JDBCServerExplorer) dataManager.openServerExplorer(

                    explorerParams.getProviderName(), 

                    explorerParams

            );

            this.codeGenerator = VCSGisLocator.getVCSGisManager().getCodeGenerator();

            this.stores = new HashMap<>();

            this.code = json.getString("code", null);

            this.allowAssignTheRevisionDate = json.getBoolean("allowAssignTheRevisionDate", false);

            HooksRepoTable hooksTable = new HooksRepoTable();

            this.watchersNotifier = hooksTable.createRepositoryWatchersNotifier(this);

            this.watchersNotifier.start();

//            this.authenticationRequired = json.getBoolean("authenticationRequired", false);

        } catch (Exception ex) {

            throw new RuntimeException("Can't restore repository from json object.", ex);

        }

    }

    @Override

    public JsonObject toJson() {

        return this.toJsonBuilder().build();

    }

    @Override

    public JsonObjectBuilder toJsonBuilder() {

        JsonObjectBuilder builder = Json.createObjectBuilder();

        builder.add_class(this);

        builder.add("explorerParams", this.server.getParameters());

        builder.add("code", this.code);

        builder.add("allowAssignTheRevisionDate", this.allowAssignTheRevisionDate);

//        builder.add("authenticationRequired", this.authenticationRequired);

        return builder;

    }

    public FeatureStore getFeatureStore(String tableName) {

        if( this.stores==null ) {

            this.stores = new HashMap<>();

        }

        FeatureStore store = this.stores.get(tableName);

        if( store==null ) {

            store = this.openFeatureStore(tableName, null);

            this.stores.put(tableName, store);

        }

        DisposeUtils.bind(store);

        return store;

    }

    public FeatureStore openFeatureStore(String tableName, String sql) {

        return this.openFeatureStore(tableName, sql, -1);

    }

    public FeatureStore openFeatureStore(String tableName, String sql, int batchSize) {

        FeatureStore store;

        try {

            JDBCStoreParameters params = this.server.get(tableName);

            params = params.getCopy();

            params.setSQL(sql);

            if( batchSize>=0 ) {

                params.setBatchSize(batchSize);

            }

            store = (FeatureStore) DALLocator.getDataManager().openStore(params.getProviderName(), params);

            return store;

        } catch (Exception ex) {

            throw new RuntimeException("Can't open store '"+tableName+"'.", ex);

        }

    }

    @Override

    public VCSGisEntitiesRequest createEntitiesRequest() {

        return new EntitiesRequestLocaldb(this);

    }

    @Override

    public VCSGisHistoryRequest createHistoryRequest(String entityName) {

        return new HistoryRequestLocaldb(this, entityName);

    }

    @Override

    public VCSGisEntity getEntityByName(String entityName) {

        VCSGisEntitiesRequest request = this.createEntitiesRequest();

        if(request.execute() != ERR_OK){

            return null;

        }

        for (VCSGisEntity repositoryEntity : request.getRepositoryEntities()) {

            if(StringUtils.equalsIgnoreCase(repositoryEntity.getEntityName(), entityName)){

                return repositoryEntity;

            }

        }

        return null;

    }

    @Override

    public VCSGisRowCreateRequest createRowCreateRequest(String entityName, String localRevisionCode) {

        VCSGisRowCreateRequest request = new RowCreateRequestLocaldb(this, entityName, localRevisionCode);

        return request;

    }

    @Override

    public VCSGisRowDeleteRequest createRowDeleteRequest(String entityName, String localRevisionCode) {

        VCSGisRowDeleteRequest request = new RowDeleteRequestLocaldb(this, entityName, localRevisionCode);

        return request;

    }

    @Override

    public VCSGisRowUpdateRequest createRowUpdateRequest(String entityName, String localRevisionCode) {

        VCSGisRowUpdateRequest request = new RowUpdateRequestLocaldb(this, entityName, localRevisionCode);

        return request;

    }

    @Override

    public VCSGisTopologyPlansRequest createTopologyPlansRequest() {

        VCSGisTopologyPlansRequest request = new TopologyPlansRequestLocaldb(this);

        return request;

    }

    @Override

    public VCSGisUsersRequest createUsersRequest() {

        VCSGisUsersRequest request = new UsersRequestLocaldb(this);

        return request;

    }

    @Override

    public void addObserver(String tableName, String type, String operation, String command) {

        throw new UnsupportedOperationException("Not supported yet."); //To change body of generated methods, choose Tools | Templates.

    }

    public void notifyWatchers(VCSGisRequest request) {

        this.watchersNotifier.notify(this.getUserCode(), request.getRequestName(), null, null);

    }

    public void notifyWatchers(VCSGisRequest request, String tableName, String revisionCode) {

        this.watchersNotifier.notify(this.getUserCode(), request.getRequestName(), tableName, revisionCode);

    }

    public boolean isAllowedToAssignTheRevisionDate() {

        return this.allowAssignTheRevisionDate;

    }

    public void setAllowAssignTheRevisionDate(boolean allowAssignTheRevisionDate) {

        this.allowAssignTheRevisionDate = allowAssignTheRevisionDate;

    }

    public String getAuthenticationToken(String userCode, int minutesToExpire) {

        CRC32 crc = new CRC32();

        crc.update(userCode.getBytes());

        long expireTime = 0;

        if( minutesToExpire>0 ) {

            expireTime = toTimestamp(LocalDateTime.now().plusMinutes(minutesToExpire)).getTime();

        }

        String theToken = String.format("%016x%016x", 

                crc.getValue(),

                expireTime

        );

        return theToken;

    }

    public boolean isAuthenticationRequired() {

        ConfigRepoTable varsTable = new ConfigRepoTable();

        return BooleanUtils.toBoolean(varsTable.get(this, "AUTHENTICATION"));

    }

    public boolean isAuthorizationRequired() {

        ConfigRepoTable varsTable = new ConfigRepoTable();

        return BooleanUtils.toBoolean(varsTable.get(this, "AUTHORIZATION"));

    }

    public boolean isAuthenticated(AbstractRequest request) {

        if( !this.isAuthenticationRequired() ) {

            LOGGER.info("Authentication not required for this repository.");

            return true;

        }

        if( StringUtils.isBlank(request.getUserCode()) ) {

            request.error(ERR_INVALID_USERCODE,"User is not authenticated.");

            return false;

        }

        String authenticationToken = request.getAuthenticationToken();

        if( StringUtils.isBlank(authenticationToken) || authenticationToken.length()!=32 ) {

            request.error(ERR_INVALID_AUTHENTICATION_TOKEN,"User '"+request.getUserCode()+"' is not authenticated.");

            return false;

        }

        // TODO: check expire time and CRC

        long expireTime_l = Long.parseLong(authenticationToken.substring(17), 16);

        if( expireTime_l>0 ) {

            long now_l = new java.util.Date().getTime();

            if( now_l > expireTime_l ) {

                request.error(ERR_AUTHENTICATION_EXPIRED,"User '"+request.getUserCode()+"' is not authorized to '"+request.getRequestName()+"'.");

                return false;

            }

        }

        Date d = new java.util.Date(expireTime_l);

        Date now = new java.util.Date();

        LOGGER.info("Repository authentication for user with userCode '"+request.getUserCode()+"' expire at '"+d.toString()+"' (now is '"+now.toString()+"'.");        

        return true;

    }

    public boolean isAuthorized(AbstractRequestLocaldb request) {

        return this.isAuthorized(request, null);

    }

    public boolean isAuthorized(AbstractRequestLocaldb request, String operation) {

        if( !this.isAuthenticated(request) ) {

            return false;

        }

        if( !this.isAuthorizationRequired() ) {

            LOGGER.info("Repository authorization not required.");

            return true;

        }

        if( operation == null ) {

            operation = request.getRequestName().toLowerCase();

        }

        VCSGisUser user = request.getUser();

        if( user == null ) {

            request.error(ERR_USER_NOT_AUTHORIZED,"User '"+request.getUserCode()+"' is not authorized to '"+request.getRequestName()+"'.");

            return false;

        }

        List<String> operations = user.getAllowedOperationsAsList();

        if( operations == null ) {

            LOGGER.info("All repository operations are allowed for user '"+user.getIdentifier()+"' ("+user.getUserCode()+").");

            return true;

        }

        if( !operations.contains(operation) ) {

            request.error(ERR_USER_NOT_AUTHORIZED,"User '"+request.getUserCode()+"' is not authorized to '"+request.getRequestName()+"'.");

            return false;

        }

        LOGGER.info("Repository authorization for '"+operation + "' operation is allowed for user '"+user.getIdentifier()+"' ("+user.getUserCode()+").");

        return true;

    }

    @Override

    public VCSGisAuthenticateRequest createAuthenticateRequest(String userId, String password) {

        VCSGisAuthenticateRequest request = new AuthenticateRequestLocaldb(this);

        request.setUserId(userId);

        request.setPassword(password);

        return request;

    }

    @Override

    public String getAuthenticationToken() {

        return this.token;

    }

    @Override

    public void setAuthenticationToken(String token) {

        this.token = token;

    }

    @Override

    public void setUserCode(String userCode) {

        this.userCode = userCode;

    }

    @Override

    public int getDataTableBtachSize() {

        if (this.dataTableBatchSize < 0) {

            ConfigRepoTable varsTable = new ConfigRepoTable();

            int n = -1;

            try {

                n = Integer.parseInt(varsTable.get(this, "DATA_TABLE_BATCH_SIZE"));

            } catch (Exception ex) {

                // Ignore

            }

            if (n < 0) {

                n = DATA_TABLE_BATCH_SIZE;

            }

            this.dataTableBatchSize = n;

        }

        return this.dataTableBatchSize;

    }

}