AbstractFixedEstimator.java

package edu.brown.hstore.estimators.fixed;

import java.util.List;

import org.apache.commons.collections15.CollectionUtils;
import org.voltdb.CatalogContext;
import org.voltdb.catalog.Procedure;
import org.voltdb.catalog.Statement;
import org.voltdb.utils.EstTime;

import edu.brown.catalog.special.CountedStatement;
import edu.brown.hstore.Hstoreservice.Status;
import edu.brown.hstore.estimators.EstimatorState;
import edu.brown.hstore.estimators.Estimate;
import edu.brown.hstore.estimators.EstimatorUtil;
import edu.brown.hstore.estimators.TransactionEstimator;
import edu.brown.markov.EstimationThresholds;
import edu.brown.utils.PartitionEstimator;
import edu.brown.utils.PartitionSet;
import edu.brown.utils.ProjectType;

public abstract class AbstractFixedEstimator extends TransactionEstimator {
    
    protected static final PartitionSet EMPTY_PARTITION_SET = new PartitionSet();
    
    public AbstractFixedEstimator(PartitionEstimator p_estimator) {
        super(p_estimator);
    }

    @SuppressWarnings("unchecked")
    @Override
    public final Estimate executeQueries(EstimatorState state, Statement[] catalog_stmts, PartitionSet[] partitions) {
        return (state.getInitialEstimate());
    }
    
    @Override
    protected final void completeTransaction(EstimatorState state, Status status) {
        // Nothing to do
    }
    
    @Override
    public final void destroyEstimatorState(EstimatorState state) {
        // Nothing to do...
    }
    
    @SuppressWarnings("unchecked")
    public static <T extends AbstractFixedEstimator> T factory(PartitionEstimator p_estimator, CatalogContext catalogContext) {
        AbstractFixedEstimator estimator = null;
        ProjectType ptype = ProjectType.get(catalogContext.database.getProject());
        switch (ptype) {
            case TPCC:
                estimator = new FixedTPCCEstimator(p_estimator);
                break;
            case TM1:
                estimator = new FixedTM1Estimator(p_estimator);
                break;
            case SEATS:
                estimator = new FixedSEATSEstimator(p_estimator);
                break;
            case VOTER:
                estimator = new FixedVoterEstimator(p_estimator);
                break;
            default:
                estimator = new DefaultFixedEstimator(p_estimator);
        } // SWITCH
        return ((T)estimator);
    }
    
    protected static class DefaultFixedEstimator extends AbstractFixedEstimator {
        public DefaultFixedEstimator(PartitionEstimator p_estimator) {
            super(p_estimator);
        }
        @SuppressWarnings("unchecked")
        @Override
        protected <T extends EstimatorState> T startTransactionImpl(Long txn_id, int base_partition, Procedure catalog_proc, Object[] args) {
            FixedEstimatorState ret = new FixedEstimatorState(this.catalogContext, txn_id, base_partition);
            PartitionSet partitions = this.catalogContext.getPartitionSetSingleton(base_partition);
            PartitionSet readonly = EMPTY_PARTITION_SET;
            ret.createInitialEstimate(partitions, readonly, EMPTY_PARTITION_SET);
            return ((T)ret);
        }
    } // CLASS
    
    /**
     * Fixed Estimator State 
     */
    protected static class FixedEstimatorState extends EstimatorState {

        protected FixedEstimatorState(CatalogContext catalogContext, Long txn_id, int base_partition) {
            super(catalogContext);
            this.init(txn_id, base_partition, EstTime.currentTimeMillis());
        }
        
        protected FixedEstimation createInitialEstimate(PartitionSet partitions,
                                                        PartitionSet readonly,
                                                        PartitionSet finished) {
            FixedEstimation next = new FixedEstimation(partitions, readonly, finished);
            this.addInitialEstimate(next);
            return (next);
        }
        
    } // CLASS

    /**
     * Fixed Estimator Estimate
     * @author pavlo
     */
    protected static class FixedEstimation implements Estimate {
        protected final PartitionSet partitions;
        protected final PartitionSet readonly;
        protected final PartitionSet finished;

        private FixedEstimation(PartitionSet partitions, PartitionSet readonly, PartitionSet finished) {
            this.partitions = partitions;
            this.readonly = readonly;
            this.finished = finished;
        }

        @Override
        public boolean isInitialized() {
            return (this.partitions != null);
        }

        @Override
        public void finish() {
            // Nothing to do...
        }
        
        @Override
        public boolean isInitialEstimate() {
            return (true);
        }
        
        @Override
        public int getBatchId() {
            return (EstimatorUtil.INITIAL_ESTIMATE_BATCH);
        }

        @Override
        public boolean isValid() {
            return (this.partitions.isEmpty() == false);
        }

        @Override
        public PartitionSet getTouchedPartitions(EstimationThresholds t) {
            return (this.partitions);
        }
        
        @Override
        public long getRemainingExecutionTime() {
            return Long.MAX_VALUE;
        }

        // ----------------------------------------------------------------------------
        // QUERIES
        // ----------------------------------------------------------------------------
        
        @Override
        public boolean hasQueryEstimate(int partition) {
            return false;
        }
        
        @Override
        public List<CountedStatement> getQueryEstimate(int partition) {
            // TODO Auto-generated method stub
            return null;
        }
        
        // ----------------------------------------------------------------------------
        // SINGLE-PARTITION PROBABILITY
        // ----------------------------------------------------------------------------
        
//        @Override
//        public boolean isSinglePartitionProbabilitySet() {
//            return (this.isValid());
//        }

        @Override
        public boolean isSinglePartitioned(EstimationThresholds t) {
            return (this.partitions.size() == 1);
        }

        // ----------------------------------------------------------------------------
        // READ-ONLY
        // ----------------------------------------------------------------------------
//        @Override
//        public boolean isReadOnlyProbabilitySet(int partition) {
//            return (this.isValid());
//        }
        @Override
        public boolean isReadOnlyAllPartitions(EstimationThresholds t) {
            return (this.partitions.size() == this.readonly.size());
        }
        @Override
        public boolean isReadOnlyPartition(EstimationThresholds t, int partition) {
            return (this.readonly.contains(Integer.valueOf(partition)));
        }
//        @Override
//        public PartitionSet getReadOnlyPartitions(EstimationThresholds t) {
//            return (this.readonly);
//        }

        // ----------------------------------------------------------------------------
        // WRITE
        // ----------------------------------------------------------------------------
        @Override
        public boolean isWriteProbabilitySet(int partition) {
            return (this.isValid());
        }
        @Override
        public boolean isWritePartition(EstimationThresholds t, int partition) {
            return (this.isReadOnlyPartition(t, partition) == false);
        }
        @Override
        public PartitionSet getWritePartitions(EstimationThresholds t) {
            return new PartitionSet(CollectionUtils.subtract(this.partitions, this.readonly));
        }
        
        // ----------------------------------------------------------------------------
        // FINISH
        // ----------------------------------------------------------------------------
        @Override
        public boolean isDoneProbabilitySet(int partition) {
            return (this.isValid());
        }
        @Override
        public PartitionSet getDonePartitions(EstimationThresholds t) {
            return (this.finished);
        }
        @Override
        public boolean isDonePartition(EstimationThresholds t, int partition) {
            return (this.finished.contains(Integer.valueOf(partition)));
        }
        
        // ----------------------------------------------------------------------------
        // ABORT
        // ----------------------------------------------------------------------------
        @Override
        public boolean isAbortProbabilitySet() {
            return (true);
        }
        @Override
        public boolean isAbortable(EstimationThresholds t) {
            return (true);
        }

    } // CLASS
}