Package org.voltdb.catalog

Examples of org.voltdb.catalog.Statement


        // Database catalog_db =
        // edu.brown.catalog.CatalogUtil.getDatabase(procedure);
        // FIXME catalog_db.getTables().get(procedure.getMapemittable());

        boolean isMapReduce = procedure.getMapreduce();
        Statement mapStatement = null;
        if (isMapReduce) {
            String mapInputQuery = procedure.getMapinputquery();
            mapStatement = procedure.getStatements().get(mapInputQuery);
            if (mapStatement == null) {
                String msg = "Procedure: " + shortName + " uses undefined mapInputQuery '" + mapInputQuery + "'";
                throw compiler.new VoltCompilerException(msg);
            }

            String reduceInputQuery = procedure.getReduceinputquery();
            Statement reduceStatement = null;
            if (reduceInputQuery != null && reduceInputQuery.isEmpty() == false) {
                reduceStatement = procedure.getStatements().get(reduceInputQuery);
                if (reduceStatement == null) {
                    String msg = "Procedure: " + shortName + " uses undefined reduceInputQuery '" + reduceInputQuery + "'";
                    throw compiler.new VoltCompilerException(msg);
View Full Code Here


        assert (info != null);

        // ADD THE STATEMENT

        // add the statement to the catalog
        Statement catalogStmt = procedure.getStatements().add(HStoreConstants.ANON_STMT_NAME);

        // compile the statement
        StatementCompiler.compile(compiler, hsql, catalog, db, estimates, catalogStmt, procedureDescriptor.m_singleStmt, info.singlePartition);

        // if the single stmt is not read only, then the proc is not read only
        boolean procHasWriteStmts = (catalogStmt.getReadonly() == false);

        // set the read onlyness of a proc
        procedure.setReadonly(procHasWriteStmts == false);

        // set procedure parameter types
        CatalogMap<ProcParameter> params = procedure.getParameters();
        CatalogMap<StmtParameter> stmtParams = catalogStmt.getParameters();

        // set the procedure parameter types from the statement parameter types
        int i = 0;
        for (StmtParameter stmtParam : CatalogUtil.getSortedCatalogItems(stmtParams, "index")) {
            // name each parameter "param1", "param2", etc...
View Full Code Here

        String stmt_name = args.getOptParam(1);

        Procedure catalog_proc = args.catalog_db.getProcedures().getIgnoreCase(proc_name);
        assert (catalog_proc != null) : "Invalid Procedure Name: " + proc_name;

        Statement catalog_stmt = catalog_proc.getStatements().getIgnoreCase(stmt_name);
        assert (catalog_stmt != null) : "Invalid Statement Name: " + proc_name + "." + stmt_name;

        AbstractPlanNode root = PlanNodeUtil.getRootPlanNodeForStatement(catalog_stmt, false);
        PlanNodeGraph graph = new PlanNodeGraph(root);
View Full Code Here

        if (debug.val && this.optimized.isEmpty()) {
            LOG.warn("There are no optimized query plans for " + this.fullName());
        }
        for (Entry<Statement, Statement> e : this.optimized.entrySet()) {
            // Make a back-up for each original Statement
            Statement backup = this.backups.get(e.getKey());
            if (backup == null) {
                Procedure catalog_proc = e.getKey().getParent();
                backup = catalog_proc.getStatements().add("BACKUP__" + e.getKey().getName());
                if (debug.val)
                    LOG.debug(String.format("Created temporary catalog object %s to back-up %s's query plans", backup.getName(), e.getKey().fullName()));
                this.backups.put(e.getKey(), backup);
                boolean ret = catalog_proc.getStatements().remove(backup);
                assert (ret);
                assert (catalog_proc.getStatements().contains(backup) == false);
            }
View Full Code Here

        assert (catalog_tbl.getViews().contains(this.catalog_view));
        catalog_tbl.getViews().remove(this.catalog_view);

        // Restore the original query plans from the backups
        for (Statement catalog_stmt : this.optimized.keySet()) {
            Statement backup = this.backups.get(catalog_stmt);
            assert (backup != null) : "Missing backup for " + catalog_stmt.fullName();
            if (debug.val)
                LOG.debug(String.format("Restoring %s's original query plans from %s", catalog_stmt.fullName(), backup.getName()));
            CatalogUtil.copyQueryPlans(backup, catalog_stmt);
        } // FOR
        this.applied = false;

        validate(catalog_view, catalog_tbl);
View Full Code Here

        // After the initial edges have been added to the graph, loop back
        // through again looking for implicit references between two tables:
        //  + Tables implicitly joined by sharing parameters on foreign keys
        //  + Tables implicitly referenced together by using the same values on
        //    foreign keys
        Statement catalog_stmts[] = this.catalog_proc.getStatements().values();
        for (int stmt_ctr0 = 0, stmt_cnt = catalog_stmts.length; stmt_ctr0 < stmt_cnt; stmt_ctr0++) {
            Statement catalog_stmt0 = catalog_stmts[stmt_ctr0];
            Collection<Table> stmt0_tables = CatalogUtil.getReferencedTables(catalog_stmt0);
            this.setDebug(stmt0_tables.containsAll(debug_tables));

            // --------------------------------------------------------------
            // (3) Add an edge between the tables in this Statement and all other
            // tables in other queries that share input parameters on foreign
            // keys relationships
            // --------------------------------------------------------------
            List<ProcParameter> params0 = new ArrayList<ProcParameter>();
            for (StmtParameter param : catalog_stmt0.getParameters()) {
                if (param.getProcparameter() != null)
                    params0.add(param.getProcparameter());
            } // FOR
            if (debug && d)
                LOG.debug(catalog_stmt0.getName() + " Params: " + params0);

            for (int stmt_ctr1 = stmt_ctr0 + 1; stmt_ctr1 < stmt_cnt; stmt_ctr1++) {
                Statement catalog_stmt1 = catalog_stmts[stmt_ctr1];
                if (catalog_stmt1 == null || catalog_stmt1.getParameters() == null)
                    continue;
                this.createSharedParamEdges(agraph, catalog_stmt0, catalog_stmt1, params0);
            } // FOR

            // --------------------------------------------------------------
View Full Code Here

    protected void updateEdgeWeights(AccessGraph agraph, TransactionTrace xact) throws Exception {
        int time = info.workload.getTimeInterval(xact, this.info.getNumIntervals());

        // Update the weights for the direct query-to-edge mappings
        for (QueryTrace query : xact.getQueries()) {
            Statement catalog_stmt = query.getCatalogItem(this.info.catalogContext.database);
            if (!this.stmt_edge_xref.containsKey(catalog_stmt)) {
                if (d)
                    LOG.warn("Missing query '" + catalog_stmt.fullName() + "' in Statement-Edge Xref mapping");
            } else {
                for (DesignerEdge edge : this.stmt_edge_xref.get(catalog_stmt)) {
                    edge.addToWeight(time, 1d);
                } // FOR
            }
View Full Code Here

                boolean ret = VerticalPartitionerUtil.generateOptimizedQueries(catalog_db, vc);
                if (ret == false) {
                    LOG.warn(String.format("Failed to generate optimized queries for %s\n%s", vc.getClass().getSimpleName(), vc));
                } else {
                    assert (vc.hasOptimizedQueries()) : vc;
                    Statement catalog_stmt = CollectionUtil.first(vc.getOptimizedQueries());
                    assert (catalog_stmt != null);
                    Procedure catalog_proc = catalog_stmt.getParent();
                    String stmtName = catalog_stmt.getName();
                    if (vc.isUpdateApplied() == false)
                        vc.applyUpdate();

                    catalog_stmt = catalog_proc.getStatements().get(stmtName);
                    AbstractPlanNode root = PlanNodeUtil.getRootPlanNodeForStatement(catalog_stmt, false);
                    if (debug)
                        LOG.debug(catalog_stmt.fullName() + "\n" + PlanNodeUtil.debug(root));
                    clearCache = true;
                }
            } // FOR
            if (clearCache) {
                CatalogUtil.clearCache(catalog_db);
View Full Code Here

    public void process(Database catalog_db, TransactionTrace xact) throws Exception {
        final Table catalog_tbl = this.getCatalogItem(catalog_db);
        // For each query, check whether they are going to our table
        // If so, then we need to update our statistics
        for (QueryTrace query : xact.getQueries()) {
            Statement catalog_stmt = query.getCatalogItem(catalog_db);
            QueryType query_type = QueryType.get(catalog_stmt.getQuerytype());
            // System.out.println("Examining " + catalog_stmt + " for " +
            // catalog_tbl);

            if (CatalogUtil.getReferencedTables(catalog_stmt).contains(catalog_tbl)) {
                // Query Type Counts
View Full Code Here

        VoltCompiler compiler = new VoltCompiler();
        HSQLInterface hsql = HSQLInterface.loadHsqldb();

        Database catalog_db = (Database) catalog_proc.getParent();
        Catalog catalog = catalog_db.getCatalog();
        Statement catalog_stmt = catalog_proc.getStatements().add(name);

        StatementCompiler.compile(compiler, hsql, catalog, catalog_db, new DatabaseEstimates(), catalog_stmt, sql, true);

        // HACK: For now just return the PlanNodeList from the first fragment
        System.err.println("CATALOG_STMT: " + CatalogUtil.debug(catalog_stmt.getFragments()));
        assert (catalog_stmt.getFragments().get(0) != null);
        String serialized = catalog_stmt.getFragments().get(0).getPlannodetree();
        String jsonString = Encoder.hexDecodeToString(serialized);
        PlanNodeList list = null; // FIXME
                                  // (PlanNodeList)PlanNodeTree.fromJSONObject(new
                                  // JSONObject(jsonString), catalog_db);
        return (list.getRootPlanNode());
View Full Code Here

TOP

Related Classes of org.voltdb.catalog.Statement

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.