explicitrules.java

来自「数据仓库展示程序」· Java 代码 · 共 1,597 行 · 第 1/4 页

                    // Is the level name a duplicate
                    if (namesToObjects.containsKey(level.getName())) {
                        msgRecorder.reportError(
                            mres.DuplicateLevelNames.str(
                                    msgRecorder.getContext(),
                                    level.getName()));
                    } else {
                        namesToObjects.put(level.getName(), level);
                    }

                    // Is the level foreign key name a duplicate
                    if (columnsToObjects.containsKey(level.getColumnName())) {
                        Level l = (Level)
                            columnsToObjects.get(level.getColumnName());
                        msgRecorder.reportError(
                            mres.DuplicateLevelColumnNames.str(
                                    msgRecorder.getContext(),
                                    level.getName(),
                                    l.getName(),
                                    level.getColumnName()));
                    } else {
                        columnsToObjects.put(level.getColumnName(), level);
                    }
                }

                // reset names map, but keep the columns from levels
                namesToObjects.clear();
                for (Iterator it = measures.iterator(); it.hasNext(); ) {
                    Measure measure = (Measure) it.next();

                    measure.validate(msgRecorder);

                    if (namesToObjects.containsKey(measure.getName())) {
                        msgRecorder.reportError(
                            mres.DuplicateMeasureNames.str(
                                    msgRecorder.getContext(),
                                    measure.getName()));
                        continue;
                    } else {
                        namesToObjects.put(measure.getName(), measure);
                    }

                    if (columnsToObjects.containsKey(measure.getColumnName())) {
                        Object o = columnsToObjects.get(measure.getColumnName());
                        if (o instanceof Measure) {
                            Measure m = (Measure) o;
                            msgRecorder.reportError(
                                mres.DuplicateMeasureColumnNames.str(
                                        msgRecorder.getContext(),
                                        measure.getName(),
                                        m.getName(),
                                        measure.getColumnName()));
                        } else {
                            Level l = (Level) o;
                            msgRecorder.reportError(
                                mres.DuplicateLevelMeasureColumnNames.str(
                                        msgRecorder.getContext(),
                                        l.getName(),
                                        measure.getName(),
                                        measure.getColumnName()));
                        }

                    } else {
                        columnsToObjects.put(measure.getColumnName(), measure);
                    }
                }

                // reset both
                namesToObjects.clear();
                columnsToObjects.clear();

                // Make sure that the base fact table foreign key names match
                // real columns
                RolapStar star = getStar();
                RolapStar.Table factTable = star.getFactTable();
                String tableName = factTable.getAlias();
                for (Iterator it = getFKEntries(); it.hasNext(); ) {
                    Map.Entry e = (Map.Entry) it.next();
                    String baseFKName = (String) e.getKey();
                    String aggFKName = (String) e.getValue();

                    if (namesToObjects.containsKey(baseFKName)) {
                        msgRecorder.reportError(
                                    mres.DuplicateFactForeignKey.str(
                                       msgRecorder.getContext(),
                                       baseFKName,
                                       aggFKName));
                    } else {
                        namesToObjects.put(baseFKName, aggFKName);
                    }
                    if (columnsToObjects.containsKey(aggFKName)) {
                        msgRecorder.reportError(
                                    mres.DuplicateFactForeignKey.str(
                                       msgRecorder.getContext(),
                                       baseFKName,
                                       aggFKName));
                    } else {
                        columnsToObjects.put(aggFKName, baseFKName);
                    }

                    MondrianDef.Column c =
                            new MondrianDef.Column(tableName, baseFKName);
                    if (factTable.findTableWithLeftCondition(c) == null) {
                        msgRecorder.reportError(
                                    mres.UnknownLeftJoinCondition.str(
                                       msgRecorder.getContext(),
                                       tableName,
                                       baseFKName));
                    }
                }
            } finally {
                msgRecorder.popContextName();
            }
        }

        public String toString() {
            StringWriter sw = new StringWriter(256);
            PrintWriter pw = new PrintWriter(sw);
            print(pw, "");
            pw.flush();
            return sw.toString();
        }
        public void print(final PrintWriter pw, final String prefix) {
            String subprefix = prefix + "  ";
            String subsubprefix = subprefix + "  ";

            pw.print(subprefix);
            pw.print("id=");
            pw.println(this.id);

            pw.print(subprefix);
            pw.print("ignoreCase=");
            pw.println(this.ignoreCase);

            pw.print(subprefix);
            pw.println("Levels: [");
            Iterator it = this.levels.iterator();
            while (it.hasNext()) {
                Level level = (Level) it.next();
                level.print(pw, subsubprefix);
            }
            pw.print(subprefix);
            pw.println("]");

            pw.print(subprefix);
            pw.println("Measures: [");
            it = this.measures.iterator();
            while (it.hasNext()) {
                Measure measure = (Measure) it.next();
                measure.print(pw, subsubprefix);
            }
            pw.print(subprefix);
            pw.println("]");
        }
    }
    static class NameTableDef extends ExplicitRules.TableDef {
        /**
         * Make a NameTableDef from the calalog schema.
         *
         * @param aggName
         * @param group
         * @return
         */
        static ExplicitRules.NameTableDef make(final MondrianDef.AggName aggName,
                                             final ExplicitRules.Group group) {
            ExplicitRules.NameTableDef name =
                new ExplicitRules.NameTableDef(aggName.getNameAttribute(),
                                     aggName.isIgnoreCase(),
                                     group);

            ExplicitRules.TableDef.add(name, aggName);

            return name;
        }

        private final String name;
        public NameTableDef(final String name,
                            final boolean ignoreCase,
                            final ExplicitRules.Group group) {
            super(ignoreCase, group);
            this.name = name;
        }

        /**
         * Does the given tableName match this NameTableDef (either exact match
         * or, if set, a case insensitive match).
         *
         * @param tableName
         * @return
         */
        public boolean matches(final String tableName) {
            return (this.ignoreCase)
                ? this.name.equals(tableName)
                : this.name.equalsIgnoreCase(tableName);
        }

        /**
         * Validate name and base class.
         *
         * @param msgRecorder
         */
        public void validate(final MessageRecorder msgRecorder) {
            msgRecorder.pushContextName("NameTableDef");
            try {
                checkAttributeString(msgRecorder, name, "name");

                super.validate(msgRecorder);
            } finally {
                msgRecorder.popContextName();
            }
        }

        public void print(final PrintWriter pw, final String prefix) {
            pw.print(prefix);
            pw.println("ExplicitRules.NameTableDef:");
            super.print(pw, prefix);

            String subprefix = prefix + "  ";

            pw.print(subprefix);
            pw.print("name=");
            pw.println(this.name);

        }
    }

    /**
     * This class matches candidate aggregate table name with a pattern.
     */
    public static class PatternTableDef extends ExplicitRules.TableDef {

        /**
         * Make a PatternTableDef from the calalog schema.
         *
         * @param aggPattern
         * @param group
         * @return
         */
        static ExplicitRules.PatternTableDef make(
                                    final MondrianDef.AggPattern aggPattern,
                                    final ExplicitRules.Group group) {

            ExplicitRules.PatternTableDef pattern =
                new ExplicitRules.PatternTableDef(aggPattern.getPattern(),
                                        aggPattern.isIgnoreCase(),
                                        group);

            MondrianDef.AggExclude[] excludes = aggPattern.getAggExcludes();
            if (excludes != null) {
                for (int i = 0; i < excludes.length; i++) {
                    Exclude exclude = ExplicitRules.make(excludes[i]);
                    pattern.add(exclude);
                }
            }

            ExplicitRules.TableDef.add(pattern, aggPattern);

            return pattern;
        }

        private final Pattern pattern;
        private List excludes;

        public PatternTableDef(final String pattern,
                               final boolean ignoreCase,
                               final ExplicitRules.Group group) {
            super(ignoreCase, group);
            this.pattern = (this.ignoreCase)
                ? Pattern.compile(pattern, Pattern.CASE_INSENSITIVE)
                : Pattern.compile(pattern);
            this.excludes = Collections.EMPTY_LIST;
        }

        /**
         * Get the Pattern.
         *
         * @return
         */
        public Pattern getPattern() {
            return pattern;
        }

        /**
         * Get an Iterator over the list of Excludes.
         *
         * @return
         */
        public Iterator getExcludes() {
            return excludes.iterator();
        }

        /**
         * Add an Exclude.
         *
         * @param exclude
         */
        private void add(final Exclude exclude) {
            if (this.excludes == Collections.EMPTY_LIST) {
                this.excludes = new ArrayList();
            }
            this.excludes.add(exclude);
        }

        /**
         * Return true if the tableName 1) matches the pattern and 2) is not
         * matched by any of the Excludes.
         *
         * @param tableName
         * @return
         */
        public boolean matches(final String tableName) {
            if (! pattern.matcher(tableName).matches()) {
                return false;
            } else {
                for (Iterator it = getExcludes(); it.hasNext(); ) {
                    Exclude exclude = (Exclude) it.next();
                    if (exclude.isExcluded(tableName)) {
                        return false;
                    }
                }
                return true;
            }
        }

        /**
         * Validate excludes and base class.
         *
         * @param msgRecorder
         */
        public void validate(final MessageRecorder msgRecorder) {
            msgRecorder.pushContextName("PatternTableDef");
            try {
                checkAttributeString(msgRecorder, pattern.pattern(), "pattern");

                for (Iterator it = getExcludes(); it.hasNext(); ) {
                    Exclude exclude = (Exclude) it.next();
                    exclude.validate(msgRecorder);
                }
                super.validate(msgRecorder);
            } finally {
                msgRecorder.popContextName();
            }
        }
        public void print(final PrintWriter pw, final String prefix) {
            pw.print(prefix);
            pw.println("ExplicitRules.PatternTableDef:");
            super.print(pw, prefix);

            String subprefix = prefix + "  ";
            String subsubprefix = subprefix + "  ";

            pw.print(subprefix);
            pw.print("pattern=");
            pw.print(this.pattern.pattern());
            pw.print(":");
            pw.println(this.pattern.flags());

            pw.print(subprefix);
            pw.println("Excludes: [");
            Iterator it = this.excludes.iterator();
            while (it.hasNext()) {
                Exclude exclude = (Exclude) it.next();
                exclude.print(pw, subsubprefix);
            }
            pw.print(subprefix);
            pw.println("]");

        }
    }

    /**
     * Helper method used to determine if an attribute with name attrName has a
     * non-empty value.
     *
     * @param msgRecorder
     * @param attrValue
     * @param attrName
     */
    private static void checkAttributeString(final MessageRecorder msgRecorder,
                                             final String attrValue,
                                             final String attrName) {
        if (attrValue == null) {
            msgRecorder.reportError(mres.NullAttributeString.str(
                    msgRecorder.getContext(),
                    attrName));
        } else if (attrValue.length() == 0) {
            msgRecorder.reportError(mres.EmptyAttributeString.str(
                    msgRecorder.getContext(),
                    attrName));
        }
    }


    private ExplicitRules() {}
}