Package org.voltdb.plannodes

Examples of org.voltdb.plannodes.NestLoopIndexPlanNode


            assert (table_name != null);
            assert (!table_name.isEmpty());
        }
        // NestLoopIndexNode
        else if (node instanceof NestLoopIndexPlanNode) {
            NestLoopIndexPlanNode cast_node = (NestLoopIndexPlanNode) node;
            assert (cast_node.getInlinePlanNodeCount() == 1);
            IndexScanPlanNode idx_node = cast_node.getInlinePlanNode(PlanNodeType.INDEXSCAN);
            table_name = idx_node.getTargetTableName();
        }
        // AbstractOperationPlanNode
        else if (node instanceof AbstractOperationPlanNode) {
            AbstractOperationPlanNode cast_node = (AbstractOperationPlanNode) node;
            table_name = cast_node.getTargetTableName();
            assert (table_name != null);
            assert (!table_name.isEmpty());
        }

        if (table_name != null) {
View Full Code Here


            nljAccessPlan.clearParents();
        }

        AbstractPlanNode retval = null;
        if (nljAccessPlan instanceof IndexScanPlanNode) {
            NestLoopIndexPlanNode nlijNode = new NestLoopIndexPlanNode(m_context, PlanAssembler.getNextPlanNodeId());

            nlijNode.setJoinType(JoinType.INNER);

            IndexScanPlanNode innerNode = (IndexScanPlanNode) nljAccessPlan;

            //
            // Now we have to update the column references used by the inner node
            //
            subPlan.updateOutputColumns(m_db);
            final List<Integer> outputColumns = subPlan.getOutputColumnGUIDs();
            final int offset = outputColumns.size();
            if (innerNode.getPredicate() != null) {
                try {
                    innerNode.setPredicate(ExpressionUtil.clone(innerNode.getPredicate()));
                } catch (Exception e) {
                    e.printStackTrace();
                }
//                System.out.println("Join Tables: ");
//                for (Table t : joinOrder)
//                {
//                  System.out.println("Table Name: " + t.getName());
//                }
                //System.out.println("Node type: " + innerNode.getPlanNodeType() + " offset #: " + offset);
                ExpressionUtil.setAndOffsetColumnIndexes(
                        m_context,
                        innerNode.getPredicate(),
                        offset, joinOrder[0].getTypeName(),
                        outputColumns);
            }

            if (innerNode.getEndExpression() != null) {
                try {
                    innerNode.setEndExpression(ExpressionUtil.clone(innerNode.getEndExpression()));
                } catch (Exception e) {
                    e.printStackTrace();
                }
                ExpressionUtil.setAndOffsetColumnIndexes(
                        m_context, innerNode.getEndExpression(), offset, joinOrder[0].getTypeName(), outputColumns);
            }

            ArrayList<AbstractExpression> searchKeyExpressions = new ArrayList<AbstractExpression>(innerNode.getSearchKeyExpressions());
            innerNode.getSearchKeyExpressions().clear();
            for (int ctr = 0, cnt = searchKeyExpressions.size(); ctr < cnt; ctr++) {
                AbstractExpression expr = null;
                try {
                    expr = ExpressionUtil.clone(searchKeyExpressions.get(ctr));
                } catch (Exception e) {
                    e.printStackTrace();
                    System.exit(-1);
                }
                ExpressionUtil.setColumnIndexes(m_context, expr, outputColumns);
                innerNode.getSearchKeyExpressions().add(expr);
            }

            nlijNode.addInlinePlanNode(nljAccessPlan);

            // combine the tails plan graph with the new head node
            nlijNode.addAndLinkChild(subPlan);

            retval = nlijNode;
        }
        else {
            NestLoopPlanNode nljNode = new NestLoopPlanNode(m_context, PlanAssembler.getNextPlanNodeId());
View Full Code Here

        nlj = (NestLoopPlanNode) n;
        assertTrue(JoinType.LEFT == nlj.getJoinType());
        assertTrue(nlj.getJoinPredicate() != null);
        n = nlj.getChild(0);
        assertTrue(n instanceof NestLoopIndexPlanNode);
        NestLoopIndexPlanNode nlij = (NestLoopIndexPlanNode) n;
        assertTrue(JoinType.INNER == nlij.getJoinType());
    }
View Full Code Here

    public void testIndexedSelfJoin() {
        AbstractPlanNode.enableVerboseExplainForDebugging();
        IndexScanPlanNode c;
        AbstractPlanNode apn;
        AbstractPlanNode pn;
        NestLoopIndexPlanNode nlij;
        List<AbstractExpression> searchKeys;
        // SELF JOIN using two different indexes on the same table
        // sometimes with a surviving sort ordering that supports GROUP BY and/or ORDER BY.

        apn = compile("select * FROM R2 A, R2 B WHERE A.A = B.A AND B.C > 1 ORDER BY B.C");
        //* for debug */ System.out.println(apn.toExplainPlanString());
        // Some day, the wasteful projection node will not be here to skip.
        pn = apn.getChild(0).getChild(0);
        assertTrue(pn instanceof NestLoopIndexPlanNode);
        nlij = (NestLoopIndexPlanNode) pn;
        assertNull(nlij.getPreJoinPredicate());
        assertNull(nlij.getJoinPredicate());
        assertNull(nlij.getWherePredicate());
        assertEquals(1, nlij.getChildCount());
        c = (IndexScanPlanNode) nlij.getChild(0);
        assertNull(c.getPredicate());
        assertEquals(IndexLookupType.GT, c.getLookupType());
        searchKeys = c.getSearchKeyExpressions();
        assertEquals(1, searchKeys.size());
        assertTrue(searchKeys.get(0) instanceof ConstantValueExpression);
        c = (IndexScanPlanNode) nlij.getInlinePlanNode(PlanNodeType.INDEXSCAN);
        assertEquals(IndexLookupType.GTE, c.getLookupType());
        assertNull(c.getPredicate());
        searchKeys = c.getSearchKeyExpressions();
        assertEquals(1, searchKeys.size());
        assertTrue(searchKeys.get(0) instanceof TupleValueExpression);

        apn = compile("select * FROM R2 A, R2 B WHERE A.A = B.A AND B.C > 1 ORDER BY B.A, B.C");
        //* for debug */ System.out.println(apn.toExplainPlanString());
        // Some day, the wasteful projection node will not be here to skip.
        pn = apn.getChild(0).getChild(0);
        assertTrue(pn instanceof OrderByPlanNode);
        pn = pn.getChild(0);
        assertTrue(pn instanceof NestLoopIndexPlanNode);
        nlij = (NestLoopIndexPlanNode) pn;
        assertNull(nlij.getPreJoinPredicate());
        assertNull(nlij.getJoinPredicate());
        assertNull(nlij.getWherePredicate());
        assertEquals(1, nlij.getChildCount());
        c = (IndexScanPlanNode) nlij.getChild(0);
        assertNull(c.getPredicate());
        assertEquals(IndexLookupType.GT, c.getLookupType());
        searchKeys = c.getSearchKeyExpressions();
        assertEquals(1, searchKeys.size());
        assertTrue(searchKeys.get(0) instanceof ConstantValueExpression);
        c = (IndexScanPlanNode) nlij.getInlinePlanNode(PlanNodeType.INDEXSCAN);
        assertEquals(IndexLookupType.GTE, c.getLookupType());
        assertNull(c.getPredicate());
        searchKeys = c.getSearchKeyExpressions();
        assertEquals(1, searchKeys.size());
        assertTrue(searchKeys.get(0) instanceof TupleValueExpression);

        apn = compile("select * FROM R2 A, R2 B WHERE A.A = B.A AND B.A > 1 ORDER BY B.A, B.C");
        //* for debug */ System.out.println(apn.toExplainPlanString());
        // Some day, the wasteful projection node will not be here to skip.
        pn = apn.getChild(0).getChild(0);
        assertTrue(pn instanceof NestLoopIndexPlanNode);
        nlij = (NestLoopIndexPlanNode) pn;
        assertNull(nlij.getPreJoinPredicate());
        assertNull(nlij.getJoinPredicate());
        assertNull(nlij.getWherePredicate());
        assertEquals(1, nlij.getChildCount());
        assertTrue(nlij.getChild(0) instanceof IndexScanPlanNode);
        c = (IndexScanPlanNode) nlij.getChild(0);
        assertEquals(IndexLookupType.GT, c.getLookupType());
        searchKeys = c.getSearchKeyExpressions();
        assertEquals(1, searchKeys.size());
        assertTrue(searchKeys.get(0) instanceof ConstantValueExpression);
        c = (IndexScanPlanNode) nlij.getInlinePlanNode(PlanNodeType.INDEXSCAN);
        assertEquals(IndexLookupType.GTE, c.getLookupType());
        assertNull(c.getPredicate());
        searchKeys = c.getSearchKeyExpressions();
        assertEquals(1, searchKeys.size());
        assertTrue(searchKeys.get(0) instanceof TupleValueExpression);

        apn = compile("select B.C, MAX(A.C) FROM R2 A, R2 B WHERE A.A = B.A AND B.C > 1 GROUP BY B.C ORDER BY B.C");
        //* for debug */ System.out.println(apn.toExplainPlanString());
        // Some day, the wasteful projection node will not be here to skip.
        pn = apn.getChild(0);
        assertNotNull(AggregatePlanNode.getInlineAggregationNode(pn));
        assertTrue(pn instanceof NestLoopIndexPlanNode);
        nlij = (NestLoopIndexPlanNode) pn;
        assertNull(nlij.getPreJoinPredicate());
        assertNull(nlij.getJoinPredicate());
        assertNull(nlij.getWherePredicate());
        assertEquals(1, nlij.getChildCount());
        c = (IndexScanPlanNode) nlij.getChild(0);
        assertNull(c.getPredicate());
        assertEquals(IndexLookupType.GT, c.getLookupType());
        searchKeys = c.getSearchKeyExpressions();
        assertEquals(1, searchKeys.size());
        assertTrue(searchKeys.get(0) instanceof ConstantValueExpression);
        c = (IndexScanPlanNode) nlij.getInlinePlanNode(PlanNodeType.INDEXSCAN);
        assertEquals(IndexLookupType.GTE, c.getLookupType());
        assertNull(c.getPredicate());
        searchKeys = c.getSearchKeyExpressions();
        assertEquals(1, searchKeys.size());
        assertTrue(searchKeys.get(0) instanceof TupleValueExpression);

        apn = compile("select B.C, B.A FROM R2 A, R2 B WHERE A.A = B.A AND B.C > 1 GROUP BY B.A, B.C ORDER BY B.A, B.C");
        //* for debug */ System.out.println(apn.toExplainPlanString());
        // Some day, the wasteful projection node will not be here to skip.
        pn = apn.getChild(0).getChild(0);
        assertTrue(pn instanceof OrderByPlanNode);
        pn = pn.getChild(0);
        assertNotNull(AggregatePlanNode.getInlineAggregationNode(pn));
        assertTrue(pn instanceof NestLoopIndexPlanNode);
        nlij = (NestLoopIndexPlanNode) pn;
        assertNull(nlij.getPreJoinPredicate());
        assertNull(nlij.getJoinPredicate());
        assertNull(nlij.getWherePredicate());
        assertEquals(1, nlij.getChildCount());
        c = (IndexScanPlanNode) nlij.getChild(0);
        assertNull(c.getPredicate());
        assertEquals(IndexLookupType.GT, c.getLookupType());
        searchKeys = c.getSearchKeyExpressions();
        assertEquals(1, searchKeys.size());
        assertTrue(searchKeys.get(0) instanceof ConstantValueExpression);
        c = (IndexScanPlanNode) nlij.getInlinePlanNode(PlanNodeType.INDEXSCAN);
        assertEquals(IndexLookupType.GTE, c.getLookupType());
        assertNull(c.getPredicate());
        searchKeys = c.getSearchKeyExpressions();
        assertEquals(1, searchKeys.size());
        assertTrue(searchKeys.get(0) instanceof TupleValueExpression);

        apn = compile("select B.C, B.A FROM R2 A, R2 B WHERE A.A = B.A AND B.A > 1 GROUP BY B.A, B.C ORDER BY B.A, B.C");
        //* for debug */ System.out.println(apn.toExplainPlanString());
        // Some day, the wasteful projection node will not be here to skip.
        pn = apn.getChild(0);
        assertNotNull(AggregatePlanNode.getInlineAggregationNode(pn));
        assertTrue(pn instanceof NestLoopIndexPlanNode);
        nlij = (NestLoopIndexPlanNode) pn;
        assertNull(nlij.getPreJoinPredicate());
        assertNull(nlij.getJoinPredicate());
        assertNull(nlij.getWherePredicate());
        assertEquals(1, nlij.getChildCount());
        assertTrue(nlij.getChild(0) instanceof IndexScanPlanNode);
        c = (IndexScanPlanNode) nlij.getChild(0);
        assertEquals(IndexLookupType.GT, c.getLookupType());
        searchKeys = c.getSearchKeyExpressions();
        assertEquals(1, searchKeys.size());
        assertTrue(searchKeys.get(0) instanceof ConstantValueExpression);
        c = (IndexScanPlanNode) nlij.getInlinePlanNode(PlanNodeType.INDEXSCAN);
        assertEquals(IndexLookupType.GTE, c.getLookupType());
        assertNull(c.getPredicate());
        searchKeys = c.getSearchKeyExpressions();
        assertEquals(1, searchKeys.size());
        assertTrue(searchKeys.get(0) instanceof TupleValueExpression);

        // Here's a case that can't be optimized because it purposely uses the "wrong" alias
        // in the GROUP BY and ORDER BY.
        apn = compile("select B.C, B.A FROM R2 A, R2 B WHERE A.A = B.A AND B.C > 1 GROUP BY B.A, A.C ORDER BY B.A, A.C");
        //* for debug */ System.out.println(apn.toExplainPlanString());
        // Some day, the wasteful projection node will not be here to skip.
        pn = apn.getChild(0).getChild(0);
        assertTrue(pn instanceof OrderByPlanNode);
        pn = pn.getChild(0);
        assertNotNull(AggregatePlanNode.getInlineAggregationNode(pn));
        assertTrue(pn instanceof NestLoopIndexPlanNode);
        nlij = (NestLoopIndexPlanNode) pn;
        assertNull(nlij.getPreJoinPredicate());
        assertNull(nlij.getJoinPredicate());
        assertNull(nlij.getWherePredicate());
        assertEquals(1, nlij.getChildCount());
        c = (IndexScanPlanNode) nlij.getChild(0);
        assertNull(c.getPredicate());
        assertEquals(IndexLookupType.GT, c.getLookupType());
        searchKeys = c.getSearchKeyExpressions();
        assertEquals(1, searchKeys.size());
        assertTrue(searchKeys.get(0) instanceof ConstantValueExpression);
        c = (IndexScanPlanNode) nlij.getInlinePlanNode(PlanNodeType.INDEXSCAN);
        assertEquals(IndexLookupType.GTE, c.getLookupType());
        assertNull(c.getPredicate());
        searchKeys = c.getSearchKeyExpressions();
        assertEquals(1, searchKeys.size());
        assertTrue(searchKeys.get(0) instanceof TupleValueExpression);

        // This variant shows that the GROUP BY can be a permutation of the sort order
        // without messing up the optimization
        apn = compile("select B.C, B.A FROM R2 A, R2 B WHERE A.A = B.A AND B.A > 1 GROUP BY B.C, B.A ORDER BY B.A, B.C");
        //* for debug */ System.out.println(apn.toExplainPlanString());
        // Some day, the wasteful projection node will not be here to skip.
        pn = apn.getChild(0);
        assertNotNull(AggregatePlanNode.getInlineAggregationNode(pn));
        assertTrue(pn instanceof NestLoopIndexPlanNode);
        nlij = (NestLoopIndexPlanNode) pn;
        assertNull(nlij.getPreJoinPredicate());
        assertNull(nlij.getJoinPredicate());
        assertNull(nlij.getWherePredicate());
        assertEquals(1, nlij.getChildCount());
        assertTrue(nlij.getChild(0) instanceof IndexScanPlanNode);
        c = (IndexScanPlanNode) nlij.getChild(0);
        assertEquals(IndexLookupType.GT, c.getLookupType());
        searchKeys = c.getSearchKeyExpressions();
        assertEquals(1, searchKeys.size());
        assertTrue(searchKeys.get(0) instanceof ConstantValueExpression);
        c = (IndexScanPlanNode) nlij.getInlinePlanNode(PlanNodeType.INDEXSCAN);
        assertEquals(IndexLookupType.GTE, c.getLookupType());
        assertNull(c.getPredicate());
        searchKeys = c.getSearchKeyExpressions();
        assertEquals(1, searchKeys.size());
        assertTrue(searchKeys.get(0) instanceof TupleValueExpression);
View Full Code Here

        assertEquals(ExpressionType.VALUE_TUPLE, p.getRight().getExpressionType());
        seqScan = n.getChild(1);
        assertTrue(seqScan instanceof SeqScanPlanNode);
        n = n.getChild(0);
        assertTrue(n instanceof NestLoopIndexPlanNode);
        NestLoopIndexPlanNode nlij = (NestLoopIndexPlanNode) n;
        indexScan = (IndexScanPlanNode)nlij.getInlinePlanNode(PlanNodeType.INDEXSCAN);
        assertEquals(IndexLookupType.EQ, indexScan.getLookupType());
        assertEquals(ExpressionType.COMPARE_EQUAL, indexScan.getEndExpression().getExpressionType());
        seqScan = nlij.getChild(0);
        assertTrue(seqScan instanceof SeqScanPlanNode);
        assertEquals(ExpressionType.COMPARE_GREATERTHANOREQUALTO, ((SeqScanPlanNode)seqScan).getPredicate().getExpressionType());

    }
View Full Code Here

    }

    public void testIndexInnerJoin() {
        AbstractPlanNode pn;
        AbstractPlanNode n;
        NestLoopIndexPlanNode nli;
        AbstractPlanNode c0;
        pn = compile("select * FROM R3 JOIN R1 ON R1.C = R3.A");
        n = pn.getChild(0).getChild(0);
        assertTrue(n instanceof NestLoopIndexPlanNode);
        assertTrue(n.getChild(0) instanceof SeqScanPlanNode);
        assertNotNull(n.getInlinePlanNode(PlanNodeType.INDEXSCAN));

        // Test ORDER BY optimization on indexed self-join, ordering by LHS
        pn = compile("select X.A FROM R5 X, R5 Y WHERE X.A = Y.A ORDER BY X.A");
        n = pn.getChild(0);
        assertTrue(n instanceof ProjectionPlanNode);
        n = n.getChild(0);
        assertTrue(n instanceof NestLoopIndexPlanNode);
        nli = (NestLoopIndexPlanNode) n;
        assertEquals(1, nli.getChildCount());
        c0 = nli.getChild(0);
        assertTrue(c0 instanceof IndexScanPlanNode);
        assertTrue(((IndexScanPlanNode) c0).getTargetTableAlias().equalsIgnoreCase("X"));

        // Test ORDER BY optimization on indexed self-join, ordering by RHS
        pn = compile("select X.A FROM R5 X, R5 Y WHERE X.A = Y.A ORDER BY Y.A");
        n = pn.getChild(0);
        assertTrue(n instanceof ProjectionPlanNode);
        n = n.getChild(0);
        assertTrue(n instanceof NestLoopIndexPlanNode);
        nli = (NestLoopIndexPlanNode) n;
        assertEquals(1, nli.getChildCount());
        c0 = nli.getChild(0);
        assertTrue(c0 instanceof IndexScanPlanNode);
        assertTrue(((IndexScanPlanNode) c0).getTargetTableAlias().equalsIgnoreCase("Y"));

        // Test safety guarding misapplication of ORDER BY optimization on indexed self-join,
        // when ordering by combination of LHS and RHS columns.
View Full Code Here

       // Test multi column condition on index columns
        pn = compile("select A FROM R2 JOIN R3 USING(A)");
        n = pn.getChild(0).getChild(0);
        assertTrue(n instanceof NestLoopIndexPlanNode);
        NestLoopIndexPlanNode nlij = (NestLoopIndexPlanNode) n;
        assertEquals(IndexLookupType.EQ, ((IndexScanPlanNode) nlij.getInlinePlanNode(PlanNodeType.INDEXSCAN)).getLookupType());

        pn = compile("select R3.A, R2.A FROM R2 JOIN R3 ON R3.A = R2.A");
        n = pn.getChild(0).getChild(0);
        assertTrue(n instanceof NestLoopIndexPlanNode);
        nlij = (NestLoopIndexPlanNode) n;
        pred = ((IndexScanPlanNode) nlij.getInlinePlanNode(PlanNodeType.INDEXSCAN)).getPredicate();
        assertEquals(IndexLookupType.EQ, ((IndexScanPlanNode) nlij.getInlinePlanNode(PlanNodeType.INDEXSCAN)).getLookupType());

        pn = compile("select A, C FROM R3 JOIN R2 USING(A, C)");
        n = pn.getChild(0).getChild(0);
        assertTrue(n instanceof NestLoopIndexPlanNode);
        nlij = (NestLoopIndexPlanNode) n;
        pred = ((IndexScanPlanNode) nlij.getInlinePlanNode(PlanNodeType.INDEXSCAN)).getPredicate();
        assertNotNull(pred);
        assertEquals(ExpressionType.COMPARE_EQUAL, pred.getExpressionType());

        pn = compile("select R3.A, R2.A FROM R3 JOIN R2 ON R3.A = R2.A AND R3.C = R2.C");
        n = pn.getChild(0).getChild(0);
        assertTrue(n instanceof NestLoopIndexPlanNode);
        nlij = (NestLoopIndexPlanNode) n;
        pred = ((IndexScanPlanNode) nlij.getInlinePlanNode(PlanNodeType.INDEXSCAN)).getPredicate();
        assertNotNull(pred);
        assertEquals(ExpressionType.COMPARE_EQUAL, pred.getExpressionType());
}
View Full Code Here

        assertNull(indexScan.getPredicate());

        pn = compile("select * FROM R2 LEFT JOIN R3 ON R3.A = R2.C WHERE R3.A > 3");
        n = pn.getChild(0).getChild(0);
        assertTrue(n instanceof NestLoopIndexPlanNode);
        NestLoopIndexPlanNode nli = (NestLoopIndexPlanNode) n;
        assertEquals(JoinType.INNER, nli.getJoinType());
   }
View Full Code Here

        assertTrue(((SeqScanPlanNode) c1).getTargetTableName().equalsIgnoreCase("R2"));

        pn = compile("select * FROM R2 LEFT JOIN R3 ON R2.C = R3.A");
        n = pn.getChild(0).getChild(0);
        assertTrue(n instanceof NestLoopIndexPlanNode);
        NestLoopIndexPlanNode nli = (NestLoopIndexPlanNode) n;
        assertEquals(JoinType.LEFT, nli.getJoinType());
        assertEquals(1, nli.getChildCount());
        c0 = nli.getChild(0);
        assertTrue(c0 instanceof SeqScanPlanNode);
        assertTrue(((SeqScanPlanNode) c0).getTargetTableName().equalsIgnoreCase("R2"));
        c1 = nli.getInlinePlanNode(PlanNodeType.INDEXSCAN);
        assertNotNull(c1);
        assertTrue(((IndexScanPlanNode) c1).getTargetTableName().equalsIgnoreCase("R3"));
      }
View Full Code Here

        // R3.C > 0 Inner Join Expr is pushed down to the inlined IndexScan node as a predicate
        // R2.A < 6 Outer Join Expr is a pre-join predicate for NLIJ
        AbstractPlanNode pn = compile("select * FROM R2 LEFT JOIN R3 ON R3.A = R2.A AND R3.C > 0 AND R2.A < 6");
        AbstractPlanNode n = pn.getChild(0).getChild(0);
        assertTrue(n instanceof NestLoopIndexPlanNode);
        NestLoopIndexPlanNode nlij = (NestLoopIndexPlanNode) n;
        assertEquals(JoinType.LEFT, nlij.getJoinType());
        assertNotNull(nlij.getPreJoinPredicate());
        AbstractExpression p = nlij.getPreJoinPredicate();
        assertEquals(ExpressionType.COMPARE_LESSTHAN, p.getExpressionType());
        assertNull(nlij.getJoinPredicate());
        assertNull(nlij.getWherePredicate());
        IndexScanPlanNode indexScan = (IndexScanPlanNode)n.getInlinePlanNode(PlanNodeType.INDEXSCAN);
        assertEquals(IndexLookupType.EQ, indexScan.getLookupType());
        assertEquals(ExpressionType.COMPARE_EQUAL, indexScan.getEndExpression().getExpressionType());
        assertEquals(ExpressionType.COMPARE_GREATERTHAN, indexScan.getPredicate().getExpressionType());
        AbstractPlanNode c1 = n.getChild(0);
View Full Code Here

TOP

Related Classes of org.voltdb.plannodes.NestLoopIndexPlanNode

Copyright © 2018 www.massapicom. All rights reserved.
All source code are property of their respective owners. Java is a trademark of Sun Microsystems, Inc and owned by ORACLE Inc. Contact coftware#gmail.com.