Java XQConnection类代码示例

import javax.xml.xquery.XQConnection; //导入依赖的package包/类
@Test
public void testGetBoolean() throws XQException {

       SaxonXQDataSource xqds = new SaxonXQDataSource();
       XQConnection xqc = xqds.getConnection();
	XQExpression xqe = xqc.createExpression();
    xqe.bindObject(new QName("v"), Boolean.valueOf(true), null);
    XQSequence xqs = xqe.executeQuery("declare variable $v external; $v instance of xs:boolean");
    xqs.next();
    assertTrue("expected true but got false", xqs.getBoolean());
    
    xqe.bindObject(new QName("v"), new Byte((byte) 1), null);
    xqs = xqe.executeQuery("declare variable $v external; $v instance of xs:byte");
    xqs.next();
    assertTrue("expected true (byte) but got false", xqs.getBoolean());
    
    xqs.close();
}
 

import javax.xml.xquery.XQConnection; //导入依赖的package包/类
@Test
public void testBinding() throws XQException {
       SaxonXQDataSource xqds = new SaxonXQDataSource();
       XQConnection xqc = xqds.getConnection();
    XQPreparedExpression xqpe = xqc.prepareExpression("declare variable $v external; $v");
    xqpe.bindString(new QName("v"), "Hello world!", xqc.createAtomicType(XQItemType.XQBASETYPE_STRING));
    XQSequence xqs = xqpe.executeQuery();
    assertTrue(xqs.next());
    assertEquals("Hello world!", xqs.getAtomicValue());
    xqpe.close();
    
    xqpe = xqc.prepareExpression("declare variable $v external; $v");
    xqpe.bindString(new QName("v"), "Hello", xqc.createAtomicType(XQItemType.XQBASETYPE_NCNAME));
    xqs = xqpe.executeQuery();
    xqs.next();
    assertEquals("A-XQDC-1.7: Successful bindXXX.", XQItemType.XQITEMKIND_ATOMIC, xqs.getItemType().getItemKind());
    assertEquals("A-XQDC-1.7: Successful bindXXX.", XQItemType.XQBASETYPE_NCNAME, xqs.getItemType().getBaseType());
    assertEquals("A-XQDC-1.7: Successful bindXXX.", "Hello", xqs.getObject());
    xqpe.close(); 
}
 

import javax.xml.xquery.XQConnection; //导入依赖的package包/类
private XQConnection initConnection(String username) throws XQException {

		BagriXQConnection connect = createConnection(username);
		Object xqp = makeInstance(XQ_PROCESSOR);
		if (xqp != null) {
			if (xqp instanceof XQProcessor) {
				connect.setProcessor((XQProcessor) xqp);
				((XQProcessor) xqp).setXQDataFactory(connect);

				Object xdm = initRepository(connect);
				if (xdm != null) {
					if (xdm instanceof SchemaRepository) {
						((XQProcessor) xqp).setRepository((SchemaRepository) xdm);
					} else {
						throw new XQException("Specified Repository class does not implement XDMRepository interface: " + 
								properties.getProperty(XDM_REPOSITORY));
					}
				}						
			} else {
				throw new XQException("Specified XQ Processor class does not implement XQProcessor interface: " + 
						properties.getProperty(XQ_PROCESSOR));
			}
		}
		return connect;
	}
 

import javax.xml.xquery.XQConnection; //导入依赖的package包/类
@Override
public XQConnection getConnection() throws XQException {
	// get pooled connection from pool
	// if no spare connections - grow pool..?
	PooledXQConnection xqConn;
	synchronized (pool) {
		if (pool.size() > 0) {
			xqConn = pool.pop();
		} else {
			xqConn = poolSource.getPooledConnection(); 
		}
	}
	xqConn.addConnectionEventListener(this);
	XQConnection conn = xqConn.getConnection();
	logger.debug("getConnection; pool size: {}; returning: {}", pool.size(), conn);
	return conn;
}
 

import javax.xml.xquery.XQConnection; //导入依赖的package包/类
@Test
public void testStoreSecurity() throws XQException {

	String dName = "../etc/samples/tpox/";
	String xml;
	try {
		xml = readTextFile(dName + "security1500.xml");
	} catch (IOException ex) {
		throw new XQException(ex.getMessage());
	}
	
	String query = "declare namespace bgdb=\"http://bagridb.com/bdb\";\n" +
			"declare variable $url external;\n" + 
			"declare variable $xml external;\n" + 
			"let $id := bgdb:store-document($url, $xml)\n" +
			"return $id\n";
	XQConnection xqc = xqds.getConnection();
    XQPreparedExpression xqpe = xqc.prepareExpression(query);
    xqpe.bindString(new QName("url"), "security1500.xml", xqc.createAtomicType(XQItemType.XQBASETYPE_ANYURI));
    xqpe.bindString(new QName("xml"), xml, xqc.createAtomicType(XQItemType.XQBASETYPE_STRING));
    XQSequence xqs = xqpe.executeQuery();
    assertTrue(xqs.next());
    xqs.close();
    xqpe.close();
}
 

import javax.xml.xquery.XQConnection; //导入依赖的package包/类
private static String runQuery(String query) throws XQException {
	System.out.println("runQuery: \n\t" + query);
	XQDataSource xqs = new ExistXQDataSource();
	String returnString = "";
	xqs.setProperty("serverName", "localhost");

	xqs.setProperty("port", "8080");

	XQConnection conn = xqs.getConnection();
	XQPreparedExpression xqpe = conn.prepareExpression(query);

	XQResultSequence rs = xqpe.executeQuery();

	while (rs.next()) {
		returnString += rs.getItemAsString(null).replace("xmlns=\"\"", "")
				+ "\n";
	}

	System.out.println("Query result: \n\t" + returnString);

	return returnString;

}
 

import javax.xml.xquery.XQConnection; //导入依赖的package包/类
@Before
public void setUp() throws Exception {
    config = mock(XQueryRunConfig.class);
    binderFactory = mock(TypeBinderFactory.class);
    connection = mock(XQConnection.class);
    expression = mock(XQPreparedExpression.class);
    binder = new ContextItemBinder(binderFactory, config) {
        @Override
        protected String readFile(String fileName) throws IOException {
            fileRead = true;
            return FILE_CONTENTS;
        }
    };
    typeBinder = mock(TypeBinder.class);
    given(binderFactory.getBinder(CONTEXT_ITEM_TYPE)).willReturn(typeBinder);
}
 

import javax.xml.xquery.XQConnection; //导入依赖的package包/类
/**
	 *
	 * @throws XQException
	 * @throws XQException
	 * @throws JAXBException
	 * @throws IOException
	 */
	@Test
	public void testXQueryExpression() throws XQException
	{
		String sourceFile="synderTest.xml";
		String xqFile="synderQuery1.xq";
		Configuration saxonConfig = new Configuration();
		SaxonXQDataSource dataSource = new SaxonXQDataSource(saxonConfig);
		XQConnection conn = dataSource.getConnection();
		String xsString="for $Template in doc(\"synderTest.xml\")/TemplateContainer/Template/Tags "+
			" return $Template" ;


		XQPreparedExpression exp = conn.prepareExpression(xsString);

		URI sourcUri=new File(sourceFile).toURI();
//		exp.bindString(new QName("docName"), sourcUri.getPath(), conn
//				.createAtomicType(XQItemType.XQBASETYPE_STRING));
		XQResultSequence result = exp.executeQuery();
		String rawResult = result.getSequenceAsString(new Properties());

		System.out.println("TransformTest.testXQueryExpression()..:"+rawResult);
//		System.out.println(tester.transfer(sourceFile, xqFile));
	}
 

import javax.xml.xquery.XQConnection; //导入依赖的package包/类
public String executeQuery(String query) throws XQException{
	log.debug("语句执行begin:"+query);
	XQConnection connection= this.getXqConnection();
	String result = connection.createExpression().executeQuery(query).getSequenceAsString(null);
	log.debug("语句执行end:"+result);
	return result;
}
 

import javax.xml.xquery.XQConnection; //导入依赖的package包/类
public XQSequence executeQuerySequence(String query) throws XQException{
	log.debug("sequence语句执行begin:"+query);
	XQConnection connection= this.getXqConnection();
	XQSequence sequence = connection.createExpression().executeQuery(query);
	log.debug("sequence语句执行end");
	return sequence;
}
 

import javax.xml.xquery.XQConnection; //导入依赖的package包/类
public XQSession openXQSession() throws XQException {
	BaseXXQDataSource xqds = new BaseXXQDataSource();
	xqds.setProperty("serverName", ProperConfigUtil.getConfigByKey("SERVERIP"));
	xqds.setProperty("port",ProperConfigUtil.getConfigByKey("SERVERPORT"));
	XQConnection conn = xqds.getConnection(ProperConfigUtil.getConfigByKey("USER"),ProperConfigUtil.getConfigByKey("PASSWORD"));
	XQSession session = new XQSession(conn);
	return session;
}
 

import javax.xml.xquery.XQConnection; //导入依赖的package包/类
public XQSequence executeQuerySequence(String query, Map bind_map)
		throws XQException {
	XQSequence sequence = null;
	XQConnection connection = this.getXqConnection();
	if (bind_map != null && !bind_map.isEmpty()) {
		if(log.isDebugEnabled()){
			log.debug("查询参数:"+bind_map);
		}
		// bind
		if (bind_map != null && !bind_map.isEmpty()) {
			XQPreparedExpression expression = connection
					.prepareExpression(query);
			Set<Map.Entry> set = bind_map.entrySet();
			for (Iterator<Map.Entry> it = set.iterator(); it.hasNext();) {
				Map.Entry entry = (Map.Entry) it.next();
				String value = (String) entry.getValue();
				if(value!=null){
					expression.bindAtomicValue(new QName((String) entry.getKey()),
							value, null);
				}
			}
			sequence = expression.executeQuery();
		} else {
			sequence = connection.createExpression().executeQuery(query);
		}
	} else {
		sequence = connection.createExpression().executeQuery(query);
	}
	return sequence;
}
 

import javax.xml.xquery.XQConnection; //导入依赖的package包/类
private void setupXQConnection(ApplicationContext ctx) throws XQException {
	XQDataSource xqds = ctx.getBean("xqDataSource", XQDataSource.class);
	String username = srvUser.getCurrentUser();
	String password = srvUser.getUserPassword(username);
	if (password == null) {
		throw new XQException("no credentials found for user " + username);
	}
	
	XQConnection xqConn = xqds.getConnection(username, password);
	QueryManagement qMgr = ctx.getBean("queryManager", QueryManagement.class);
    qMgr.setXQConnection(xqConn);
}
 

import javax.xml.xquery.XQConnection; //导入依赖的package包/类
public static void main(String[] args) throws XQException {
	
	//System.setProperty("bdb.schema.members", "localhost:10600");
	System.setProperty("logback.configurationFile", "hz-client-logging.xml");
	System.setProperty("bdb.log.level", "trace");
	//
	context = new ClassPathXmlApplicationContext("spring/xqj-client-context.xml");
	XQConnection xqc = context.getBean("xqConnection", XQConnection.class);
	ClientApp client = new ClientApp(xqc);
	//HazelcastInstance hz = context.getBean("hzInstance", HazelcastInstance.class);
			
	boolean found = false;
	try {
		//client.storeSecCommand();
		long id = client.storeSecQuery();
		//long id = client.storeXmlDocument("axis.xml");
		//System.out.println("document stored; id: " + id);
		//found = client.runPriceQuery("IBM"); 
		//found &= client.runPriceQuery("IBM");
		found = client.runSecQuery("IBM");
		//found &= client.runSecQuery("VFINX");
		//found &= client.runPriceQuery("PTTAX");
		//found = client.searchSecQuery();
		//found = client.searchSecQueryParams();
		//client.searchSecQueryParams();
		//found = client.runAxisQuery();
		//client.removeSecCommand(id);
	} catch (XQException e) {
		e.printStackTrace();
	}

    if (!found) {
    	throw new XQException("result is empty");
    }

    //context.close();
}
 

import javax.xml.xquery.XQConnection; //导入依赖的package包/类
public static void main(String[] args) throws Exception {
	
	ApplicationContext context = new ClassPathXmlApplicationContext("spring/xqj-client-context.xml");
	XQConnection xqc = context.getBean("xqConnection", XQConnection.class);
	
    XQJClientSpringApp client = new XQJClientSpringApp(xqc); 
	tester.testClient(client);
}