Package org.voltdb.catalog

Examples of org.voltdb.catalog.ProcParameter


            } else if (superclasses.contains(ProcParameter.class)) {

                // SPECIAL CASE: MultiProcParameter
                if (multiattribute_key != null && multiattribute_key.equalsIgnoreCase(MultiProcParameter.PREFIX)) {
                    JSONArray jsonArray = jsonObject.getJSONArray(orig_parent_key);
                    ProcParameter params[] = new ProcParameter[jsonArray.length()];
                    for (int i = 0; i < params.length; i++) {
                        params[i] = getFromKey(catalog_db, jsonArray.getJSONObject(i), ProcParameter.class);
                    } // FOR
                    assert (params.length > 1) : "Invalid MultiProcParameter Key: " + child_key;
                    catalog_child = (T) MultiProcParameter.get(params);
View Full Code Here


                for (Integer stmt_param : map.get(stmt_name).keySet()) {
                    StmtParameter catalog_stmt_param = catalog_stmt.getParameters().get(stmt_param);

                    Integer proc_param = map.get(stmt_name).get(stmt_param);
                    ProcParameter catalog_proc_param = catalog_proc.getParameters().get(proc_param);

                    // Skip if it already has the proper ProcParameter set
                    if (!force && catalog_stmt_param.getProcparameter() != null && catalog_stmt_param.getProcparameter().equals(catalog_proc_param)) {
                        if (debug.val) LOG.debug("Skipping parameter mapping in " + catalog_stmt + " because it is already set");
                    } else {
                        catalog_stmt_param.setProcparameter(catalog_proc_param);
                        if (debug.val) LOG.debug("Added parameter mapping in Statement '" + stmt_name + "' from StmtParameter '" + catalog_stmt_param.getName() + "' to '" + catalog_proc_param.getName() + "'");
                    }
                } // FOR
            } // FOR
        } // FOR
        return;
View Full Code Here

        this.params = new ProcParameter[num_params];
        this.param_isarray = new boolean[num_params];
        this.param_types = new VoltType[num_params];
        boolean found_array = false;
        for (int i = 0, cnt = catalog_params.size(); i < cnt; i++) {
            ProcParameter catalog_param = catalog_params.get(i);
            this.params[i] = catalog_param;
            this.param_isarray[i] = catalog_param.getIsarray();
            this.param_types[i] = VoltType.get(catalog_param.getType());
            found_array = found_array || this.param_isarray[i];
        } // FOR
        this.has_arrays = found_array;
    }
View Full Code Here

        assert(catalog_stmt != null);
        StmtParameter catalog_stmt_param = c.getStmtParameter();
        assert(catalog_stmt_param != null);
        Procedure catalog_proc = catalog_stmt.getParent();
        assert(catalog_proc != null);
        ProcParameter catalog_proc_param = c.getProcParameter();
        Column catalog_col = c.getColumn();
       
        // Procedure Index
        if (!this.procIndex.containsKey(catalog_proc)) {
            this.procIndex.put(catalog_proc, new ProcedureMappings());
View Full Code Here

    }
   
    public Pair<ProcParameter, Integer> getProcParameterWithIndex(String feature_key) {
        assert(feature_key.contains(FeatureUtil.DELIMITER)) : "Invalid: " + feature_key;
        String split[] = FeatureUtil.PREFIX_SPLITTER.split(feature_key);
        ProcParameter catalog_param = this.catalog_proc.getParameters().get(Integer.valueOf(split[1]));
        Integer param_idx = (split.length > 2 ? Integer.valueOf(split[2]) : null);
        return (Pair.of(catalog_param, param_idx));
    }
View Full Code Here

                // Special Case: MultiProcParameter
                if (child_key.startsWith(MultiProcParameter.PREFIX)) {
                    int prefix_offset = MultiProcParameter.PREFIX.length() + MULTIATTRIBUTE_DELIMITER.length();
                    String names[] = child_key.substring(prefix_offset).split(MULTIATTRIBUTE_DELIMITER);
                    assert (names.length > 1) : "Invalid MultiProcParameter Key: " + child_key.substring(prefix_offset);
                    ProcParameter params[] = new ProcParameter[names.length];
                    for (int i = 0; i < names.length; i++) {
                        params[i] = getFromKey(catalog_db, createKey(parent_key, names[i]), ProcParameter.class);
                    } // FOR
                    catalog_child = (T) MultiProcParameter.get(params);
View Full Code Here

                            m[0].put(field, VoltType.get(((Integer)value).byteValue()).name());
                            break;
                        }
                    } // FOR
                    if (field.equals("procparameter")) {
                        ProcParameter proc_param = ((StmtParameter)catalog_obj).getProcparameter();
                        if (proc_param != null) {
                            m[0].put(field, proc_param.fullName());
                        }
                    }
                }
            } // FOR
        } else {
View Full Code Here

            procNode.add(parameters_node);
            for (ProcParameter param_cat : CatalogUtil.getSortedCatalogItems(catalog_proc.getParameters(), "index")) {
                DefaultMutableTreeNode param_node = new DefaultMutableTreeNode(new WrapperNode(param_cat) {
                    @Override
                    public String toString() {
                        ProcParameter param_cat = (ProcParameter)this.getCatalogType();
                        VoltType type = VoltType.get((byte)param_cat.getType());
                        return (super.toString() + " :: " + type.name());
                    }
                });
                parameters_node.add(param_node);
                buildSearchIndex(param_cat, param_node);
            } // FOR (parameters)
           
            // Statements
            if (catalog_proc.getSystemproc() == false) {
                DefaultMutableTreeNode statementRootNode = new CatalogMapTreeNode(Statement.class, "Statements", catalog_proc.getStatements());
                procNode.add(statementRootNode);                 
                for (Statement statement_cat : catalog_proc.getStatements()) {
                    DefaultMutableTreeNode statement_node = new DefaultMutableTreeNode(new WrapperNode(statement_cat));
                    statementRootNode.add(statement_node);
                    buildSearchIndex(statement_cat, statement_node);
                   
                    // Plan Trees
                    for (boolean is_singlepartition : new boolean[] { true, false }) {
                        if (is_singlepartition && !statement_cat.getHas_singlesited()) continue;
                        if (!is_singlepartition && !statement_cat.getHas_multisited()) continue;

                        String label = (is_singlepartition ? "Single-Partition" : "Distributed") + " Plan Fragments";
//                            String attributes = "";
                        AbstractPlanNode node = null;
                       
                        try {
                            node = PlanNodeUtil.getRootPlanNodeForStatement(statement_cat, is_singlepartition);
                        } catch (Exception e) {
                            String msg = e.getMessage();
                            if (msg == null || msg.length() == 0) {
                                e.printStackTrace();
                            } else {
                                LOG.warn(msg);
                            }
                        }
                       
                        CatalogMap<PlanFragment> fragments = (is_singlepartition ? statement_cat.getFragments() : statement_cat.getMs_fragments());
                        PlanTreeCatalogNode planTreeNode = new PlanTreeCatalogNode(label, fragments, node);
                        DefaultMutableTreeNode planNode = new DefaultMutableTreeNode(planTreeNode);
                        statement_node.add(planNode);
                       
                        // Plan Fragments
                        for (PlanFragment fragment_cat : CatalogUtil.getSortedCatalogItems(fragments, "id")) {
                            DefaultMutableTreeNode fragment_node = new DefaultMutableTreeNode(new WrapperNode(fragment_cat));
                            planNode.add(fragment_node);
                            buildSearchIndex(fragment_cat, fragment_node);
                        } // FOR (fragments)
                    }
               
                    // Statement Parameter
                    DefaultMutableTreeNode paramRootNode = new CatalogMapTreeNode(StmtParameter.class, "Parameters", statement_cat.getParameters());
                    statement_node.add(paramRootNode);
                    for (StmtParameter param_cat : CatalogUtil.getSortedCatalogItems(statement_cat.getParameters(), "index")) {
                        DefaultMutableTreeNode param_node = new DefaultMutableTreeNode(new WrapperNode(param_cat) {
                            @Override
                            public String toString() {
                                 StmtParameter param_cat = (StmtParameter)this.getCatalogType();
                                 VoltType type = VoltType.get((byte)param_cat.getJavatype());
                                 return (super.toString() + " :: " + type.name());
                            }
                        });
                        paramRootNode.add(param_node);
                        buildSearchIndex(param_cat, param_node);
View Full Code Here

     * @param catalog_proc
     * @return
     */
    public static ProcParameter getPartitioningProcParameter(Procedure catalog_proc) {
        assert (catalog_proc != null);
        ProcParameter catalog_param = null;
        if (catalog_proc.getParameters().size() > 0 && !catalog_proc.getSystemproc()) {
            int idx = catalog_proc.getPartitionparameter();
            if (idx == NullProcParameter.PARAM_IDX) {
                catalog_param = NullProcParameter.singleton(catalog_proc);
            } else {
View Full Code Here

                if (PartitionerUtil.shouldIgnoreProcedure(hints, catalog_proc))
                    continue;

                Set<String> param_order = PartitionerUtil.generateProcParameterOrder(info, info.catalogContext.database, catalog_proc, hints);
                if (param_order.isEmpty() == false) {
                    ProcParameter catalog_proc_param = CatalogKey.getFromKey(info.catalogContext.database, CollectionUtil.first(param_order), ProcParameter.class);
                    if (debug.val)
                        LOG.debug(String.format("PARTITION %-25s%s", catalog_proc.getName(), CatalogUtil.getDisplayName(catalog_proc_param)));

                    // Create a new PartitionEntry for this procedure and set it
                    // to be always single-partitioned
View Full Code Here

TOP

Related Classes of org.voltdb.catalog.ProcParameter

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.