Java DeletePlanNode类代码示例

import org.voltdb.plannodes.DeletePlanNode; //导入依赖的package包/类
/**
 * Check through a plan graph and return true if it ever touches a persistent table.
 */
static boolean fragmentReferencesPersistentTable(AbstractPlanNode node) {
    if (node == null)
        return false;

    // these nodes can read/modify persistent tables
    if (node instanceof AbstractScanPlanNode)
        return true;
    if (node instanceof InsertPlanNode)
        return true;
    if (node instanceof DeletePlanNode)
        return true;
    if (node instanceof UpdatePlanNode)
        return true;

    // recursively check out children
    for (int i = 0; i < node.getChildPlanNodeCount(); i++) {
        AbstractPlanNode child = node.getChild(i);
        if (fragmentReferencesPersistentTable(child))
            return true;
    }

    // if nothing found, return false
    return false;
}
 

import org.voltdb.plannodes.DeletePlanNode; //导入依赖的package包/类
/**
 * Check through a plan graph and return true if it is read only
 */
static boolean fragmentReadOnly(AbstractPlanNode node) {
    if (node == null)
        return true;

    if (node instanceof InsertPlanNode)
        return false;
    if (node instanceof DeletePlanNode)
        return false;
    if (node instanceof UpdatePlanNode)
        return false;

    // recursively check out children
    for (int i = 0; i < node.getChildPlanNodeCount(); i++) {
        if (fragmentReadOnly(node.getChild(i)) == false) return (false);
    }

    // if nothing found, return true
    return true;
}
 

import org.voltdb.plannodes.DeletePlanNode; //导入依赖的package包/类
/**
 * Check through a plan graph and return true if it ever touches a persistent table.
 */
static boolean fragmentReferencesPersistentTable(AbstractPlanNode node) {
    if (node == null)
        return false;

    // these nodes can read/modify persistent tables
    if (node instanceof AbstractScanPlanNode)
        return true;
    if (node instanceof InsertPlanNode)
        return true;
    if (node instanceof DeletePlanNode)
        return true;
    if (node instanceof UpdatePlanNode)
        return true;

    // recursively check out children
    for (int i = 0; i < node.getChildCount(); i++) {
        AbstractPlanNode child = node.getChild(i);
        if (fragmentReferencesPersistentTable(child))
            return true;
    }

    // if nothing found, return false
    return false;
}
 

import org.voltdb.plannodes.DeletePlanNode; //导入依赖的package包/类
private void checkTruncateFlag() {
    assertTrue(pns.size() == 2);

    ArrayList<AbstractPlanNode> deletes = pns.get(1).findAllNodesOfType(PlanNodeType.DELETE);

    assertTrue(deletes.size() == 1);
    assertTrue(((DeletePlanNode) deletes.get(0) ).isTruncate());
}
 

import org.voltdb.plannodes.DeletePlanNode; //导入依赖的package包/类
public void testBasicUpdateAndDelete() {
    // select * with ON clause should return all columns from all tables
    AbstractPlanNode n;
    AbstractPlanNode pn;

    pns = compileToFragments("UPDATE R1 SET C = 1 WHERE C = 0");
    pn = pns.get(0);
    System.out.println(pn.toExplainPlanString());
    n = pn.getChild(0).getChild(0);
    assertTrue(n instanceof ReceivePlanNode);
    pn = pns.get(1);
    n = pn.getChild(0);
    assertTrue(n instanceof UpdatePlanNode);

    pns = compileToFragments("DELETE FROM R1 WHERE C = 0");
    pn = pns.get(0);
    System.out.println(pn.toExplainPlanString());
    n = pn.getChild(0).getChild(0);
    assertTrue(n instanceof ReceivePlanNode);
    pn = pns.get(1);
    n = pn.getChild(0);
    assertTrue(n instanceof DeletePlanNode);

    pns = compileToFragments("INSERT INTO R1 VALUES (1, 2, 3)");
    pn = pns.get(0);
    System.out.println(pn.toExplainPlanString());
    n = pn.getChild(0).getChild(0);
    assertTrue(n instanceof ReceivePlanNode);
    pn = pns.get(1);
    n = pn.getChild(0);
    assertTrue(n instanceof InsertPlanNode);

    pns = compileToFragments("UPDATE P1 SET C = 1 WHERE C = 0");
    pn = pns.get(0);
    System.out.println(pn.toExplainPlanString());
    n = pn.getChild(0).getChild(0);
    assertTrue(n instanceof ReceivePlanNode);
    pn = pns.get(1);
    n = pn.getChild(0);
    assertTrue(n instanceof UpdatePlanNode);

    pns = compileToFragments("DELETE FROM P1 WHERE C = 0");
    pn = pns.get(0);
    System.out.println(pn.toExplainPlanString());
    n = pn.getChild(0).getChild(0);
    assertTrue(n instanceof ReceivePlanNode);
    pn = pns.get(1);
    n = pn.getChild(0);
    assertTrue(n instanceof DeletePlanNode);

    pns = compileToFragments("UPDATE P1 SET C = 1 WHERE A = 0");
    pn = pns.get(0);
    System.out.println(pn.toExplainPlanString());
    //n = pn.getChild(0);
    assertTrue(pn instanceof UpdatePlanNode);

    pns = compileToFragments("DELETE FROM P1 WHERE A = 0");
    pn = pns.get(0);
    System.out.println(pn.toExplainPlanString());
    //n = pn.getChild(0);
    assertTrue(pn instanceof DeletePlanNode);

    pns = compileToFragments("INSERT INTO P1 VALUES (1, 2)");
    pn = pns.get(0);
    System.out.println(pn.toExplainPlanString());
    //n = pn.getChild(0).getChild(0);
    assertTrue(pn instanceof InsertPlanNode);

}
 

import org.voltdb.plannodes.DeletePlanNode; //导入依赖的package包/类
public void testDeleteOrderByPlan() {
    System.out.println("\n\n\nRUNNING testDeleteOrderByPlan\n\n");

    // No ORDER BY node, since we can use index instead
    pns = compileToFragments("DELETE FROM R5 ORDER BY A LIMIT ?");
    assertEquals(2, pns.size());
    AbstractPlanNode collectorRoot = pns.get(1);
    assertClassesMatchNodeChain(Arrays.asList(
            SendPlanNode.class,
            DeletePlanNode.class,
            IndexScanPlanNode.class),
            collectorRoot
            );

    // No ORDER BY node, since index scan is used to evaluate predicate
    pns = compileToFragments("DELETE FROM R5 WHERE A = 1 ORDER BY A LIMIT ?");
    assertEquals(2, pns.size());
    collectorRoot = pns.get(1);
    assertClassesMatchNodeChain(Arrays.asList(
            SendPlanNode.class,
            DeletePlanNode.class,
            IndexScanPlanNode.class),
            collectorRoot
            );

    // Index used to evaluate predicate not suitable for ORDER BY
    pns = compileToFragments("DELETE FROM R5 WHERE A = 1 ORDER BY B, A, C, D LIMIT ?");
    assertEquals(2, pns.size());
    collectorRoot = pns.get(1);
    assertClassesMatchNodeChain(Arrays.asList(
            SendPlanNode.class,
            DeletePlanNode.class,
            OrderByPlanNode.class,
            IndexScanPlanNode.class),
            collectorRoot
            );

    // Index can't be used either for predicate evaluation or ORDER BY
    pns = compileToFragments("DELETE FROM R5 WHERE B = 1 ORDER BY B, A, C, D LIMIT ?");
    assertEquals(2, pns.size());
    collectorRoot = pns.get(1);
    assertClassesMatchNodeChain(Arrays.asList(
            SendPlanNode.class,
            DeletePlanNode.class,
            OrderByPlanNode.class,
            SeqScanPlanNode.class),
            collectorRoot
            );
}