import mondrian.olap.Util; //导入依赖的package包/类
@Override
public void contributeParameters(Map<String, Object> parameters)
		throws JRException {
	MondrianDataAdapter mda = getJdbcDataAdapter();
	if (mda != null) {
		Util.PropertyList props = new Util.PropertyList();
		props.put("Catalog", mda.getCatalogURI());
		props.put("Provider", "mondrian");
		props.put("Locale", Locale.getDefault().getLanguage());

		connection = DriverManager.getConnection(props, null,
				new SimpleSQLDataSource(this));

		parameters
				.put(JRMondrianQueryExecuterFactory.PARAMETER_MONDRIAN_CONNECTION,
						connection);
	}
}
 

import mondrian.olap.Util; //导入依赖的package包/类
@Override
public String filter(String schemaUrl, Util.PropertyList connectInfo, InputStream stream)
	throws Exception {
		String schema = super.filter(schemaUrl, connectInfo, stream);
		System.out.println("[CUSTOM.DSP] *********** Started DSP Custom ***********");
		IPentahoSession session = PentahoSessionHolder.getSession();
		// if you need only the default Pentaho username session var, not a specific one,
		// you can change the code with: String usercode = session.getName().toString();
		// this avoid to use a startup kettle job
		String usercode = (String) session.getAttribute("USERNAME");
		try {
			System.out.println("[CUSTOM.DSP] Trying to replace '%USER_NAME%' with session value: "+usercode);
			LOG.info("Trying to replace '%USER_NAME%' with session value: "+usercode);
			schema = schema.replaceAll("%USER_NAME%", usercode);
		}
		catch (PatternSyntaxException pse) {
			System.out.println("[CUSTOM.DSP] Some error during custom schema processing: "+usercode);
			LOG.error("Some error during custom schema processing. " , pse);
			pse.printStackTrace();
		}
	LOG.info("DSP Ended correctly for "+usercode);
	System.out.println("[CUSTOM.DSP] *********** DSP Ended correctly for "+usercode+" ***********");
	return schema;
}
 

import mondrian.olap.Util; //导入依赖的package包/类
/**
 * See if the DOMParser after parsing a Document has any errors and,
 * if so, throw a RuntimeException exception containing the errors.
 *
 */
private static void checkForParseError(
    final DOMParser parser,
    Throwable t)
{
    if (Util.IBM_JVM) {
        // IBM JDK returns lots of errors. Not sure whether they are
        // real errors, but ignore for now.
        return;
    }

    final ErrorHandler errorHandler = parser.getErrorHandler();
    if (errorHandler instanceof SaxErrorHandler) {
        final SaxErrorHandler saxEH = (SaxErrorHandler) errorHandler;
        final List<SaxErrorHandler.ErrorInfo> errors = saxEH.getErrors();

        if (errors != null && errors.size() > 0) {
            String errorStr = SaxErrorHandler.formatErrorInfos(saxEH);
            throw new RuntimeException(errorStr, t);
        }
    } else {
        System.out.println("errorHandler=" + errorHandler);
    }
}
 

import mondrian.olap.Util; //导入依赖的package包/类
private Object[] getAttributes(Property prop, Hierarchy hierarchy) {
    Property longProp = longProps.get(prop.getName());
    if (longProp == null) {
        longProp = prop;
    }
    List<Object> values = new ArrayList<Object>();
    values.add("name");
    values.add(
        hierarchy.getUniqueName()
        + "."
        + Util.quoteMdxIdentifier(longProp.getName()));
    if (longProp == prop) {
        // Adding type attribute to the optional properties
        values.add("type");
        values.add(getXsdType(longProp));
    }
    return values.toArray();
}
 

import mondrian.olap.Util; //导入依赖的package包/类
public Object visit(ExecutionStartEvent event) {
    MutableStatementInfo stmt =
        statementMap.get(event.statementId);
    if (stmt == null) {
        return missing(event);
    }
    final MutableExecutionInfo exec =
        new MutableExecutionInfo(
            stmt, event.executionId, event.stack);
    executionMap.put(event.executionId, exec);

    foo(exec, event);
    foo(stmt.aggExec, event);
    foo(stmt.conn.aggExec, event);
    foo(server.aggExec, event);
    if (RolapUtil.MONITOR_LOGGER.isTraceEnabled()) {
        RolapUtil.MONITOR_LOGGER.trace(
            "Execution("
            + event.executionId
            + ") created. stack is:"
            + Util.nl
            + event.stack);
    }
    return null;
}
 

import mondrian.olap.Util; //导入依赖的package包/类
public <T> T compileScript(
    Class<T> iface,
    String script,
    String engineName)
{
    ScriptEngineManager factory = new ScriptEngineManager();
    ScriptEngine engine = factory.getEngineByName(engineName);
    try {
        engine.eval(script);
        Invocable inv = (Invocable) engine;
        return inv.getInterface(iface);
    } catch (ScriptException e) {
        throw Util.newError(
            e,
            "Error while compiling script to implement " + iface + " SPI");
    }
}
 

import mondrian.olap.Util; //导入依赖的package包/类
protected boolean removeEldestEntry(
    Map.Entry<Long, MutableSqlStatementInfo> e)
{
    if (size() > maxSize) {
        if (RolapUtil.MONITOR_LOGGER.isTraceEnabled()) {
            RolapUtil.MONITOR_LOGGER.trace(
                "StatementInfo("
                + e.getKey()
                + ") evicted. Stack is:"
                + Util.nl
                + e.getValue().stack);
        }
        return true;
    }
    return false;
}
 

import mondrian.olap.Util; //导入依赖的package包/类
public DefaultXmlaResponse(
    OutputStream outputStream,
    String encoding,
    Enumeration.ResponseMimeType responseMimeType)
{
    try {
        switch (responseMimeType) {
        case JSON:
            writer = new JsonSaxWriter(outputStream);
            break;
        case SOAP:
        default:
            writer = new DefaultSaxWriter(outputStream, encoding);
            break;
        }
    } catch (UnsupportedEncodingException uee) {
        throw Util.newError(uee, MSG_ENCODING_ERROR + encoding);
    }
}
 

import mondrian.olap.Util; //导入依赖的package包/类
private void initCommand(Element commandRoot) throws XmlaException {
    Element[] childElems =
        XmlaUtil.filterChildElements(
            commandRoot,
            NS_XMLA,
            "Statement");
    if (childElems.length != 1) {
        StringBuilder buf = new StringBuilder(100);
        buf.append(MSG_INVALID_XMLA);
        buf.append(": Wrong number of Statement elements: ");
        buf.append(childElems.length);
        throw new XmlaException(
            CLIENT_FAULT_FC,
            HSB_BAD_STATEMENT_CODE,
            HSB_BAD_STATEMENT_FAULT_FS,
            Util.newError(buf.toString()));
    }
    statement = XmlaUtil.textInElement(childElems[0]).replaceAll("\\r", "");
    drillthrough = statement.toUpperCase().indexOf("DRILLTHROUGH") != -1;
}
 

import mondrian.olap.Util; //导入依赖的package包/类
public String filter(
    String schemaUrl,
    Util.PropertyList connectInfo,
    InputStream stream) throws Exception
{
    setLocale(
        connectInfo.get("Locale") == null
            ? Locale.getDefault().toString()
            : connectInfo.get("Locale"));

    loadProperties();

    String schema = super.filter(schemaUrl, connectInfo, stream);
    if (bundle != null) {
        schema = doRegExReplacements(schema);
    }
    LOGGER.debug(schema);
    return schema;
}
 

import mondrian.olap.Util; //导入依赖的package包/类
/**
 * Reads the contents of a schema as a stream and returns the result as
 * a string.
 *
 * <p>The default implementation returns the contents of the schema
 * unchanged.
 *
 * @param schemaUrl the URL of the catalog
 * @param connectInfo Connection properties
 * @param stream Schema contents represented as a stream
 * @return the modified schema
 * @throws Exception if an error occurs
 */
protected String filter(
    String schemaUrl,
    Util.PropertyList connectInfo,
    InputStream stream)
    throws Exception
{
    BufferedReader in =
        new BufferedReader(
            new InputStreamReader(stream));
    try {
        StringBuilder builder = new StringBuilder();
        char[] buf = new char[2048];
        int readCount;
        while ((readCount = in.read(buf, 0, buf.length)) >= 0) {
            builder.append(buf, 0, readCount);
        }
        return builder.toString();
    } finally {
        in.close();
    }
}
 

import mondrian.olap.Util; //导入依赖的package包/类
public void testBasicSchemaFetch() {
    RolapSchemaPool schemaPool = RolapSchemaPool.instance();
    schemaPool.clear();

    String catalogUrl = getFoodmartCatalogUrl().toString();
    Util.PropertyList connectInfo =
        Util.parseConnectString(TestContext.getDefaultConnectString());

    RolapSchema schema =
        schemaPool.get(
            catalogUrl,
            "connectionKeyA",
            "joeTheUser",
            "aDataSource",
            connectInfo);
    RolapSchema schemaA =
        schemaPool.get(
            catalogUrl,
            "connectionKeyA",
            "joeTheUser",
            "aDataSource",
            connectInfo);
    //same arguments, same object
    assertTrue(schema == schemaA);
}
 

import mondrian.olap.Util; //导入依赖的package包/类
public boolean mightIntersect(StarPredicate other) {
    if (other instanceof LiteralStarPredicate) {
        return ((LiteralStarPredicate) other).getValue();
    }
    if (other instanceof ValueColumnPredicate) {
        ValueColumnPredicate valueColumnPredicate =
            (ValueColumnPredicate) other;
        return evaluate(valueColumnPredicate.getValue());
    }
    if (other instanceof ListColumnPredicate) {
        final List<Object> thatSet = new ArrayList<Object>();
        ((ListColumnPredicate) other).values(thatSet);
        for (Object o : thatSet) {
            if (evaluate(o)) {
                return true;
            }
        }
        return false;
    }
    throw Util.newInternal("unknown constraint type " + other);
}
 

import mondrian.olap.Util; //导入依赖的package包/类
private void describe(StringBuilder buf, boolean values) {
    final String sep = Util.nl + "    ";
    buf.append(printSegmentHeaderInfo(sep));

    for (int i = 0; i < columns.length; i++) {
        buf.append(sep);
        buf.append(columns[i].getExpression().getGenericExpression());
        describeAxes(buf, i, values);
    }
    if (!excludedRegions.isEmpty()) {
        buf.append(sep);
        buf.append("excluded={");
        int k = 0;
        for (ExcludedRegion excludedRegion : excludedRegions) {
            if (k++ > 0) {
                buf.append(", ");
            }
            excludedRegion.describe(buf);
        }
        buf.append('}');
    }
    buf.append('}');
}
 

import mondrian.olap.Util; //导入依赖的package包/类
SegmentDataset createDataset(
    SegmentAxis[] axes,
    boolean sparse,
    SqlStatement.Type type,
    int size)
{
    if (sparse) {
        return new SparseSegmentDataset();
    } else {
        switch (type) {
        case OBJECT:
        case LONG:
        case STRING:
            return new DenseObjectSegmentDataset(axes, size);
        case INT:
            return new DenseIntSegmentDataset(axes, size);
        case DOUBLE:
            return new DenseDoubleSegmentDataset(axes, size);
        default:
            throw Util.unexpected(type);
        }
    }
}
 

import mondrian.olap.Util; //导入依赖的package包/类
/**
 * Adds a measure to a query.
 *
 * @param i Ordinal of measure
 * @param sqlQuery Query object
 */
protected void addMeasure(final int i, final SqlQuery sqlQuery) {
    RolapStar.Measure measure = getMeasure(i);
    if (!isPartOfSelect(measure)) {
        return;
    }
    Util.assertTrue(measure.getTable() == getStar().getFactTable());
    measure.getTable().addToFrom(sqlQuery, false, true);

    String exprInner =
        measure.getExpression() == null
            ? "*"
            : measure.generateExprString(sqlQuery);
    String exprOuter = measure.getAggregator().getExpression(exprInner);
    sqlQuery.addSelect(
        exprOuter,
        measure.getInternalType(),
        getMeasureAlias(i));
}
 

import mondrian.olap.Util; //导入依赖的package包/类
static Column forType(
    int ordinal,
    SqlStatement.Type type,
    int capacity)
{
    switch (type) {
    case OBJECT:
    case STRING:
        return new ObjectColumn(ordinal, type, capacity);
    case INT:
        return new IntColumn(ordinal, type, capacity);
    case LONG:
        return new LongColumn(ordinal, type, capacity);
    case DOUBLE:
        return new DoubleColumn(ordinal, type, capacity);
    default:
        throw Util.unexpected(type);
    }
}
 

import mondrian.olap.Util; //导入依赖的package包/类
SiblingIterator(MemberReader reader, RolapMember member) {
    this.reader = reader;
    RolapMember parent = member.getParentMember();
    List<RolapMember> siblingList;
    if (parent == null) {
        siblingList = reader.getRootMembers();
        this.parentIterator = null;
    } else {
        siblingList = new ArrayList<RolapMember>();
        reader.getMemberChildren(parent, siblingList);
        this.parentIterator = new SiblingIterator(reader, parent);
    }
    this.siblings = siblingList;
    this.position = -1;
    for (int i = 0; i < this.siblings.size(); i++) {
        if (siblings.get(i).equals(member)) {
            this.position = i;
            break;
        }
    }
    if (this.position == -1) {
        throw Util.newInternal(
            "member " + member + " not found among its siblings");
    }
}
 

import mondrian.olap.Util; //导入依赖的package包/类
public void testTwentySimpleGetters() throws Exception {
    final int cycles = 1000;
    final int actorsAmount = 20;

    List<SingleSchemaGetter> actors =
        new ArrayList<SingleSchemaGetter>(actorsAmount);
    for (int i = 0; i < actorsAmount; i++) {
        String catalogUrl = UUID.randomUUID().toString();

        DataSource ds = mock(DataSource.class);

        Util.PropertyList list = new Util.PropertyList();
        list.put(CatalogContent.name(), UUID.randomUUID().toString());

        // force the pool to create the fake schema
        RolapSchema schema = poolSpy.get(catalogUrl, ds, list);
        addedSchemas.add(schema);

        actors.add(new SingleSchemaGetter(
            poolSpy, cycles, catalogUrl, ds, list));
    }

    runTest(actors);
}
 

import mondrian.olap.Util; //导入依赖的package包/类
/**
 * Processes a request.
 *
 * @param request  XML request, for example, "<SOAP-ENV:Envelope ...>".
 * @param response Destination for response
 * @throws XmlaException on error
 */
public void process(XmlaRequest request, XmlaResponse response)
    throws XmlaException
{
    Method method = request.getMethod();
    long start = System.currentTimeMillis();

    switch (method) {
    case DISCOVER:
        discover(request, response);
        break;
    case EXECUTE:
        execute(request, response);
        break;
    default:
        throw new XmlaException(
            CLIENT_FAULT_FC,
            HSB_BAD_METHOD_CODE,
            HSB_BAD_METHOD_FAULT_FS,
            new IllegalArgumentException(
                "Unsupported XML/A method: " + method));
    }
    if (LOGGER.isDebugEnabled()) {
        long end = System.currentTimeMillis();
        LOGGER.debug("XmlaHandler.process: time = " + (end - start));
        LOGGER.debug("XmlaHandler.process: " + Util.printMemory());
    }
}