Java OlapStatement类代码示例

import org.olap4j.OlapStatement; //导入依赖的package包/类
@Test public void testCannedProcedure() throws Exception {
	String ddl = "create foreign procedure proc(arg integer, arg1 date) returns table (x string) options (\"teiid_rel:native-query\" '$2 $1 something')";
	String query = "exec proc(2, {d'1970-01-01'})";
	
	TransformationMetadata tm = RealMetadataFactory.fromDDL(ddl, "x", "phy");
	
	CommandBuilder commandBuilder = new CommandBuilder(tm);
       Command obj = commandBuilder.getCommand(query);
        
	OlapExecutionFactory oef = new OlapExecutionFactory();
	Connection mock = Mockito.mock(java.sql.Connection.class);
	OlapWrapper mock2 = Mockito.mock(OlapWrapper.class);
	OlapConnection mock3 = Mockito.mock(OlapConnection.class);
	OlapStatement mock4 = Mockito.mock(OlapStatement.class);
	Mockito.stub(mock4.executeOlapQuery(Mockito.anyString())).toThrow(new TeiidRuntimeException());
	Mockito.stub(mock3.createStatement()).toReturn(mock4);
	Mockito.stub(mock2.unwrap(OlapConnection.class)).toReturn(mock3);
	Mockito.stub(mock.unwrap(OlapWrapper.class)).toReturn(mock2);
	ProcedureExecution pe = oef.createProcedureExecution((Call)obj, Mockito.mock(ExecutionContext.class), new RuntimeMetadataImpl(tm), mock);
	try {
		pe.execute();
		fail();
	} catch (TeiidRuntimeException e) {
		Mockito.verify(mock4).executeOlapQuery("'1970-01-01' 2 something");
	}
}
 

import org.olap4j.OlapStatement; //导入依赖的package包/类
/**
 * Executes a query and processes the result using a callback.
 *
 * @param queryString MDX query text
 */
public <T> T runQuery(String queryString, Util.Functor1<T, CellSet> f) {
    long start = System.currentTimeMillis();
    OlapConnection connection = null;
    OlapStatement statement = null;
    CellSet cellSet = null;
    try {
        connection = getOlapConnection();
        statement = connection.createStatement();
        debug("CmdRunner.runQuery: AFTER createStatement");
        start = System.currentTimeMillis();
        cellSet = statement.executeOlapQuery(queryString);
        return f.apply(cellSet);
    } catch (SQLException e) {
        throw new RuntimeException(e);
    } finally {
        queryTime = (System.currentTimeMillis() - start);
        totalQueryTime += queryTime;
        debug("CmdRunner.runQuery: BOTTOM");
        Util.close(cellSet, statement, connection);
    }
}
 

import org.olap4j.OlapStatement; //导入依赖的package包/类
@Override
public void cancel() throws TranslatorException {
	try {
		OlapStatement olapStatement = this.stmt;
		if (olapStatement != null) {
			olapStatement.cancel();
		}
	} catch (SQLException e) {
		throw new TranslatorException(e);
	}		
}
 

import org.olap4j.OlapStatement; //导入依赖的package包/类
public void setStatementProfiling(
    OlapStatement statement,
    final PrintWriter pw)
{
    ((MondrianOlap4jStatement) statement).enableProfiling(
        new ProfileHandler() {
            public void explain(String plan, QueryTiming timing) {
                pw.println(plan);
                if (timing != null) {
                    pw.println(timing);
                }
            }
        }
    );
}
 

import org.olap4j.OlapStatement; //导入依赖的package包/类
@Override
public OlapStatement createStatement() throws OlapException {
	return new ServerOlapStatement(this);
}
 

import org.olap4j.OlapStatement; //导入依赖的package包/类
public ServerCellSet(OlapStatement olapStatement, Cube cube) {
	this.olapStatement = olapStatement;
	this.cube = cube;
}
 

import org.olap4j.OlapStatement; //导入依赖的package包/类
@Override
public OlapStatement getStatement() throws SQLException {
	return olapStatement;
}
 

import org.olap4j.OlapStatement; //导入依赖的package包/类
@Override
public JRDataSource createDatasource() throws JRException
{
	
	Properties connectProps = new Properties();
	connectProps.put(XMLA_SERVER, getParameterValue(JRXmlaQueryExecuterFactory.PARAMETER_XMLA_URL));
	connectProps.put(XMLA_CATALOG, getParameterValue(JRXmlaQueryExecuterFactory.PARAMETER_XMLA_CATALOG));
	connectProps.put(XMLA_DATA_SOURCE, getParameterValue(JRXmlaQueryExecuterFactory.PARAMETER_XMLA_DATASOURCE));
	connectProps.put(XMLA_USER, getParameterValue(JRXmlaQueryExecuterFactory.PARAMETER_XMLA_USER));
	connectProps.put(XMLA_PASSWORD, getParameterValue(JRXmlaQueryExecuterFactory.PARAMETER_XMLA_PASSWORD));
	connectProps.put(OLAP4J_DRIVER, OLAP4J_XMLA_DRIVER_CLASS);
	connectProps.put(OLAP4J_URL_PREFIX, OLAP4J_XMLA_URL_PREFIX);
	
	// load driver  and Connection
	rConnection = null;
	try
	{
		Class.forName(OLAP4J_XMLA_DRIVER_CLASS);
		rConnection = java.sql.DriverManager.getConnection(OLAP4J_XMLA_URL_PREFIX, connectProps);
	}
	catch (Throwable t) 
	{
		throw 
			new JRException(
				EXCEPTION_MESSAGE_KEY_CONNECTION_ERROR,
				new Object[]{OLAP4J_XMLA_DRIVER_CLASS},
				t);
	}

	OlapConnection connection = (OlapConnection) rConnection;
	
	/*
	MdxParserFactory pFactory = connection.getParserFactory();
	MdxParser parser = pFactory.createMdxParser(connection);
	SelectNode parsedObject = parser.parseSelect(getQueryString());
	MdxValidator validator = pFactory.createMdxValidator(connection);
	try {
		validator.validateSelect(parsedObject);
	} catch (OlapException e) {
		throw new JRException("Invalid MDX query: " + getQueryString(), e);
	}
	*/
	if (log.isDebugEnabled())
	{
		log.debug("running MDX: " + getQueryString());
	}
	CellSet result = null;
	try
	{
		OlapStatement statement = connection.createStatement();

		result = statement.executeOlapQuery(getQueryString());
	}
	catch (OlapException e)
	{
		throw 
			new JRException(
				EXCEPTION_MESSAGE_KEY_EXECUTE_QUERY_ERROR,
				new Object[]{getQueryString()},
				e);
	}
	
	parseResult(result);
	
	return new JROlapDataSource(dataset, xmlaResult);
}
 

import org.olap4j.OlapStatement; //导入依赖的package包/类
@Override
public JRDataSource createDatasource() throws JRException
{
	JRDataSource dataSource = null;
	
	Properties connectProps = new Properties();
	connectProps.put(OLAP4J_JDBC_DRIVERS, getParameterValue(Olap4jMondrianQueryExecuterFactory.PARAMETER_JDBC_DRIVERS));
	connectProps.put(OLAP4J_JDBC_URL, getParameterValue(Olap4jMondrianQueryExecuterFactory.PARAMETER_JDBC_URL));
	connectProps.put(OLAP4J_JDBC_CATALOG, getParameterValue(Olap4jMondrianQueryExecuterFactory.PARAMETER_CATALOG));
	String user = (String) getParameterValue(Olap4jMondrianQueryExecuterFactory.PARAMETER_JDBC_USER);
	if (user != null) {
		connectProps.put(OLAP4J_JDBC_USER, user);
	}
	String password = (String) getParameterValue(Olap4jMondrianQueryExecuterFactory.PARAMETER_JDBC_PASSWORD);
	if (password != null) {
		connectProps.put(OLAP4J_JDBC_PASSWORD, password);
	}
	connectProps.put(OLAP4J_DRIVER, OLAP4J_MONDRIAN_DRIVER_CLASS);
	connectProps.put(OLAP4J_URL_PREFIX, OLAP4J_MONDRIAN_URL_PREFIX);
	
	// load driver  and Connection
	rConnection = null;
	try
	{
		Class.forName(OLAP4J_MONDRIAN_DRIVER_CLASS);
		rConnection = java.sql.DriverManager.getConnection(OLAP4J_MONDRIAN_URL_PREFIX, connectProps);
	}
	catch (Throwable t)
	{
		throw 
			new JRException(
				EXCEPTION_MESSAGE_KEY_CONNECTION_ERROR,
				new Object[]{OLAP4J_MONDRIAN_DRIVER_CLASS},
				t);
	}

	OlapConnection connection = (OlapConnection) rConnection;
	
	String queryStr = getQueryString();
	if (connection != null && queryStr != null)
	{
		if (log.isDebugEnabled())
		{
			log.debug("MDX query: " + queryStr);
		}
		CellSet result = null;

		try
		{
			OlapStatement statement = connection.createStatement();

			result = statement.executeOlapQuery(getQueryString());
		}
		catch (OlapException e)
		{
			throw 
				new JRException(
					EXCEPTION_MESSAGE_KEY_EXECUTE_QUERY_ERROR,
					new Object[]{getQueryString()},
					e);
		}

		if (log.isDebugEnabled())
		{
			OutputStream bos = new ByteArrayOutputStream();
			CellSetFormatter formatter = new RectangularCellSetFormatter(true);
			formatter.format(result, new PrintWriter(bos, true));
			log.debug("Result:\n" + bos.toString());
		}
		
		dataSource = new Olap4jDataSource(dataset, result);
	}

	return dataSource;
}
 

import org.olap4j.OlapStatement; //导入依赖的package包/类
public OlapStatement createStatement() {
    return super.createStatement();
}
 

import org.olap4j.OlapStatement; //导入依赖的package包/类
/**
 * 取CellSet
 * 
 * @param connection
 * @param mdx
 * @return
 * @throws OlapException
 * @throws Exception
 */
public static CellSet getResultSet(OlapConnection connection, String mdx) throws OlapException, Exception {
	OlapStatement olapStatement = connection.createStatement();
	CellSet cellSet = olapStatement.executeOlapQuery(mdx);
	return cellSet;
}