Java SynthesizedPlanFragment类代码示例

import org.voltdb.VoltSystemProcedure.SynthesizedPlanFragment; //导入依赖的package包/类
private SynthesizedPlanFragment constructDistributePartitionedTableFragment(int distributorPartitionId, int uncoveredPartitionsAtHost[], int originalHostsArray[]) {
    LOG.trace("constructDistributePartitionedTableFragment : to partition : " + distributorPartitionId);

    int result_dependency_id = getNextDependencyId();
    SynthesizedPlanFragment plan_fragment = new SynthesizedPlanFragment();
    plan_fragment.fragmentId = SysProcFragmentId.PF_restoreDistributePartitionedTable;        
    plan_fragment.multipartition = false;
    plan_fragment.destPartitionId = distributorPartitionId;
    plan_fragment.outputDependencyIds = new int[] { result_dependency_id };
    plan_fragment.inputDependencyIds = new int[] {};
    addPlanDependencyId(result_dependency_id);
    ParameterSet params = new ParameterSet();
    params.setParameters(getTableName(), originalHostsArray, uncoveredPartitionsAtHost, result_dependency_id, m_allowExport);
    plan_fragment.parameters = params;
    return plan_fragment;
}
 

import org.voltdb.VoltSystemProcedure.SynthesizedPlanFragment; //导入依赖的package包/类
private SynthesizedPlanFragment constructDistributePartitionedTableAggregatorFragment() {
    SystemProcedureExecutionContext context = this.getSystemProcedureExecutionContext();
    assert (context != null);
    int partition_id = context.getPartitionExecutor().getPartitionId();
    LOG.trace("constructDistributePartitionedTableAggregatorFragment - partition : " + partition_id);

    int result_dependency_id = getNextDependencyId();
    SynthesizedPlanFragment plan_fragment = new SynthesizedPlanFragment();
    plan_fragment.fragmentId = SysProcFragmentId.PF_restoreDistributePartitionedTableResults;
    plan_fragment.multipartition = false;
    plan_fragment.outputDependencyIds = new int[] { result_dependency_id };
    plan_fragment.inputDependencyIds = getPlanDependencyIds();
    setRootDependencyId(result_dependency_id);
    ParameterSet params = new ParameterSet();
    params.setParameters(result_dependency_id);
    plan_fragment.parameters = params;
    return plan_fragment;
}
 

import org.voltdb.VoltSystemProcedure.SynthesizedPlanFragment; //导入依赖的package包/类
@Override
public SynthesizedPlanFragment[] generateRestorePlan(Table catalogTable) {
    SystemProcedureExecutionContext context = this.getSystemProcedureExecutionContext();
    assert (context != null);
    Host catalog_host = context.getHost();
    Collection<Site> catalog_sites = CatalogUtil.getSitesForHost(catalog_host);

    LOG.info("Replicated :: Table: " + getTableName());

    Set<Integer> execution_site_ids = new TreeSet<Integer>();
    for (Site catalog_site : catalog_sites) {
        execution_site_ids.add(catalog_site.getId());
    }

    for (int hostId : m_hostsWithThisTable) {
        m_sitesWithThisTable.addAll(execution_site_ids);
    }

    SynthesizedPlanFragment[] restore_plan = null;
    if (catalogTable.getIsreplicated()) {
        restore_plan = generateReplicatedToReplicatedPlan();
    } else {
        // XXX Not implemented until we're going to support catalog changes
    }
    return restore_plan;
}
 

import org.voltdb.VoltSystemProcedure.SynthesizedPlanFragment; //导入依赖的package包/类
private SynthesizedPlanFragment constructDistributeReplicatedTableFragment(int sourcePartitionId, int destinationPartitionId) {
    LOG.trace("constructDistributeReplicatedTableFragment : source -" + sourcePartitionId + " destination -" + destinationPartitionId);

    int result_dependency_id = getNextDependencyId();
    SynthesizedPlanFragment plan_fragment = new SynthesizedPlanFragment();
    plan_fragment.fragmentId = SysProcFragmentId.PF_restoreDistributeReplicatedTable;
    plan_fragment.multipartition = false;
    // XXX plan_fragment.siteId = sourceSiteId;
    plan_fragment.destPartitionId = sourcePartitionId;
    plan_fragment.outputDependencyIds = new int[] { result_dependency_id };
    plan_fragment.inputDependencyIds = new int[] {};
    addPlanDependencyId(result_dependency_id);
    ParameterSet params = new ParameterSet();
    params.setParameters(getTableName(), destinationPartitionId, result_dependency_id, m_allowExport);
    plan_fragment.parameters = params;
    return plan_fragment;
}
 

import org.voltdb.VoltSystemProcedure.SynthesizedPlanFragment; //导入依赖的package包/类
private SynthesizedPlanFragment constructLoadReplicatedTableAggregatorFragment() {
    SystemProcedureExecutionContext context = this.getSystemProcedureExecutionContext();
    assert (context != null);
    int partition_id = context.getPartitionExecutor().getPartitionId();
    LOG.trace("constructLoadReplicatedTableAggregatorFragment - partition : " + partition_id);

    int result_dependency_id = getNextDependencyId();

    SynthesizedPlanFragment plan_fragment = new SynthesizedPlanFragment();
    plan_fragment.fragmentId = SysProcFragmentId.PF_restoreLoadReplicatedTableResults;
    plan_fragment.multipartition = false;
    plan_fragment.outputDependencyIds = new int[] { result_dependency_id };
    plan_fragment.inputDependencyIds = getPlanDependencyIds();
    setRootDependencyId(result_dependency_id);
    ParameterSet params = new ParameterSet();
    params.setParameters(result_dependency_id);
    plan_fragment.parameters = params;
    return plan_fragment;
}
 

import org.voltdb.VoltSystemProcedure.SynthesizedPlanFragment; //导入依赖的package包/类
@Override
public SynthesizedPlanFragment[]
generateRestorePlan(Table catalogTable, SiteTracker st)
{
    SynthesizedPlanFragment[] restore_plan = null;
    LOG.info("Total partitions for Table: " + getTableName() + ": " +
             getTotalPartitions());
    if (!catalogTable.getIsreplicated())
    {
        restore_plan = generatePartitionedToPartitionedPlan(st);
    }
    else
    {
        restore_plan = generatePartitionedToReplicatedPlan(st);
    }
    return restore_plan;
}
 

import org.voltdb.VoltSystemProcedure.SynthesizedPlanFragment; //导入依赖的package包/类
private SynthesizedPlanFragment
constructDistributePartitionedTableFragment(
        long distributorSiteId,     // site which will execute this plan fragment
        int uncoveredPartitionsAtHost[],    // which partitions' data in the .vpt files will be extracted as TableSaveFile
        int originalHostsArray[],           // used to locate .vpt files
        boolean asReplicated)
{
    int result_dependency_id = getNextDependencyId();
    SynthesizedPlanFragment plan_fragment = new SynthesizedPlanFragment();
    plan_fragment.fragmentId =
            (asReplicated ? SysProcFragmentId.PF_restoreDistributePartitionedTableAsReplicated
                          : SysProcFragmentId.PF_restoreDistributePartitionedTableAsPartitioned);
    plan_fragment.multipartition = false;
    plan_fragment.siteId = distributorSiteId;
    plan_fragment.outputDepId = result_dependency_id;
    plan_fragment.inputDepIds = new int[] {};
    addPlanDependencyId(result_dependency_id);
    plan_fragment.parameters = ParameterSet.fromArrayNoCopy(
            getTableName(),
            originalHostsArray,
            uncoveredPartitionsAtHost,
            result_dependency_id);
    return plan_fragment;
}
 

import org.voltdb.VoltSystemProcedure.SynthesizedPlanFragment; //导入依赖的package包/类
private SynthesizedPlanFragment
constructDistributePartitionedTableAggregatorFragment(boolean asReplicated)
{
    int result_dependency_id = getNextDependencyId();
    SynthesizedPlanFragment plan_fragment = new SynthesizedPlanFragment();
    plan_fragment.fragmentId =
        SysProcFragmentId.PF_restoreReceiveResultTables;
    plan_fragment.multipartition = false;
    plan_fragment.outputDepId = result_dependency_id;
    plan_fragment.inputDepIds = getPlanDependencyIds();
    setRootDependencyId(result_dependency_id);
    plan_fragment.parameters = ParameterSet.fromArrayNoCopy(
            result_dependency_id,
            (asReplicated ?
                    "Aggregating partitioned-to-replicated table restore results"
                    : "Aggregating partitioned table restore results"));
    return plan_fragment;
}
 

import org.voltdb.VoltSystemProcedure.SynthesizedPlanFragment; //导入依赖的package包/类
@Override
public SynthesizedPlanFragment[]
generateRestorePlan(Table catalogTable, SiteTracker st)
{
    for (int hostId : m_hostsWithThisTable) {
        m_sitesWithThisTable.addAll(st.getSitesForHost(hostId));
    }

    SynthesizedPlanFragment[] restore_plan = null;
    if (catalogTable.getIsreplicated())
    {
        restore_plan = generateReplicatedToReplicatedPlan(st);
    }
    else
    {
        restore_plan = generateReplicatedToPartitionedPlan(st);
    }
    return restore_plan;
}
 

import org.voltdb.VoltSystemProcedure.SynthesizedPlanFragment; //导入依赖的package包/类
private SynthesizedPlanFragment[]
generateReplicatedToPartitionedPlan(SiteTracker st)
{
    SynthesizedPlanFragment[] restore_plan = null;

    Integer host = m_hostsWithThisTable.iterator().next();

    // replicated table is small enough for only one site to distribute the task
    restore_plan = new SynthesizedPlanFragment[2];
    int restore_plan_index = 0;
    assert(st.getSitesForHost(host).size() > 0);
    long site = st.getSitesForHost(host).get(0);
    restore_plan[restore_plan_index] = constructDistributeReplicatedTableAsPartitionedFragment(site);
    ++restore_plan_index;
    restore_plan[restore_plan_index] = constructLoadReplicatedTableAggregatorFragment(true);

    return restore_plan;
}
 

import org.voltdb.VoltSystemProcedure.SynthesizedPlanFragment; //导入依赖的package包/类
private SynthesizedPlanFragment
constructDistributeReplicatedTableAsPartitionedFragment(long siteId)
{
    int result_dependency_id = getNextDependencyId();
    SynthesizedPlanFragment plan_fragment = new SynthesizedPlanFragment();
    plan_fragment.fragmentId =
        SysProcFragmentId.PF_restoreDistributeReplicatedTableAsPartitioned;
    plan_fragment.multipartition = false;
    plan_fragment.siteId = siteId;
    plan_fragment.outputDepId = result_dependency_id;
    plan_fragment.inputDepIds = new int[] {};
    addPlanDependencyId(result_dependency_id);
    plan_fragment.parameters = ParameterSet.fromArrayNoCopy(
            getTableName(),
            result_dependency_id);
    return plan_fragment;
}
 

import org.voltdb.VoltSystemProcedure.SynthesizedPlanFragment; //导入依赖的package包/类
private SynthesizedPlanFragment
constructLoadReplicatedTableFragment()
{
    int result_dependency_id = getNextDependencyId();
    SynthesizedPlanFragment plan_fragment = new SynthesizedPlanFragment();
    plan_fragment.fragmentId =
        SysProcFragmentId.PF_restoreLoadReplicatedTable;
    plan_fragment.multipartition = false;
    plan_fragment.outputDepId = result_dependency_id;
    plan_fragment.inputDepIds = new int[] {};
    addPlanDependencyId(result_dependency_id);
    plan_fragment.parameters = ParameterSet.fromArrayNoCopy(
            getTableName(),
            result_dependency_id);
    return plan_fragment;
}
 

import org.voltdb.VoltSystemProcedure.SynthesizedPlanFragment; //导入依赖的package包/类
private SynthesizedPlanFragment
constructDistributeReplicatedTableAsReplicatedFragment(long sourceSiteId,
                                                       long destinationSiteId)
{
    int result_dependency_id = getNextDependencyId();
    SynthesizedPlanFragment plan_fragment = new SynthesizedPlanFragment();
    plan_fragment.fragmentId =
        SysProcFragmentId.PF_restoreDistributeReplicatedTableAsReplicated;
    plan_fragment.multipartition = false;
    plan_fragment.siteId = sourceSiteId;
    plan_fragment.outputDepId = result_dependency_id;
    plan_fragment.inputDepIds = new int[] {};
    addPlanDependencyId(result_dependency_id);
    plan_fragment.parameters = ParameterSet.fromArrayNoCopy(
            getTableName(),
            destinationSiteId,
            result_dependency_id);
    return plan_fragment;
}
 

import org.voltdb.VoltSystemProcedure.SynthesizedPlanFragment; //导入依赖的package包/类
private SynthesizedPlanFragment
constructLoadReplicatedTableAggregatorFragment(boolean asPartitioned)
{
    int result_dependency_id = getNextDependencyId();
    SynthesizedPlanFragment plan_fragment = new SynthesizedPlanFragment();
    plan_fragment.fragmentId =
        SysProcFragmentId.PF_restoreReceiveResultTables;
    plan_fragment.multipartition = false;
    plan_fragment.outputDepId = result_dependency_id;
    plan_fragment.inputDepIds = getPlanDependencyIds();
    setRootDependencyId(result_dependency_id);
    plan_fragment.parameters = ParameterSet.fromArrayNoCopy(result_dependency_id,
            (asPartitioned ? "Aggregating replicated-to-partitioned table restore results"
                           : "Aggregating replicated table restore results"));
    return plan_fragment;
}
 

import org.voltdb.VoltSystemProcedure.SynthesizedPlanFragment; //导入依赖的package包/类
@Override
public SynthesizedPlanFragment[] generateRestorePlan(Table catalogTable) {
    SynthesizedPlanFragment[] restore_plan = null;
    LOG.trace("Partitioned :: Total partitions for Table: " + getTableName() + ": " + getTotalPartitions());
    if (!catalogTable.getIsreplicated()) {
        restore_plan = generatePartitionedToPartitionedPlan();
    } else {
        // XXX Not implemented until we're going to support catalog changes
    }
    return restore_plan;
}