Java 类javax.xml.xquery.XQException 实例源码

@Test
public void testGetDouble() throws XQException {

    XQPreparedExpression xqpe = xqc.prepareExpression("declare variable $v external; $v");
    try {
        xqpe.bindDouble(new QName("v"), 1d, xqc.createAtomicType(XQItemType.XQBASETYPE_DOUBLE));
    } catch (XQException e) {
        fail("A-XQDC-1.7: bindDouble() failed with message: " + e.getMessage());
    }
    XQSequence 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_DOUBLE, xqs.getItemType().getBaseType());
    assertTrue("A-XQDC-1.7: Successful bindXXX.", 1d == xqs.getDouble());
    xqpe.close(); 
}

@Override
public RepositoryRevision getRepositoryHEAD() {
    String[] files = getFilesFromExist(COLLECTION_PATH);
    RepositoryRevision repo = new RepositoryRevision();
    for (String file : files) {
        RepositoryFile repositoryFile = null;
        try {
            repositoryFile = new RepositoryFile(file,
                    getHeadFile(COLLECTION_PATH + file));
        } catch (XQException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        repo.addRepositoryFile(repositoryFile);
    }
    return repo;

}

public static Map<String, Object> mapFromSequence(XQSequence cs) throws XQException {
    Map<String, Object> result;
    synchronized (cs) {
        if (cs.isScrollable()) {
            cs.beforeFirst();
            result = new HashMap<>(cs.count());
        } else {
            result = new HashMap<>();
        }

        while (cs.next()) {
            XQSequence pair = (XQSequence) cs.getObject();
            pair.beforeFirst();
            pair.next();
            String key = pair.getAtomicValue();
            pair.next();
            Object value = pair.getObject();
            result.put(key, value);
        }
    }
        return result;
}

@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();
}

@Override
public boolean next() throws XQException {

    checkState(ex_sequence_closed);
    //try {
        if (iter.hasNext()) {
            XQItemAccessor current = iter.next();
            //if (current instanceof BagriXQItemAccessor) {
                setCurrent(((BagriXQItemAccessor) current).type, ((BagriXQItemAccessor) current).value);
            //} else if (current instanceof XQItem) {
            //  setCurrent(((XQItem) current).getItemType(), ((XQItem) current).getObject());
            //} else {
            //  setCurrent(getTypeForObject(xqFactory, current), current);
            //}
            accessed = false;
            return true;
        }
        positioned = false;
        return false;
    //} catch (BagriException ex) {
    //  throw getXQException(ex);
    //}
}

private String getDocumentUri(Map<String, Object> params) throws XQException {
    XQItem uri = (XQItem) params.remove("uri");
    if (uri == null) {
        throw new XQException("No document uri passed");
    }
    return uri.getAtomicValue();
}

@Override
public String readDocument(String uri) throws XQException {

    String query = "declare namespace bgdb=\"http://bagridb.com/bdb\";\n" +
            "declare variable $uri external;\n" + 
            "let $doc := bgdb:get-document-content($uri)\n" +
            "return $doc\n";

    XQPreparedExpression xqpe = xqConn.prepareExpression(query);
    xqpe.bindString(new QName("uri"), uri, xqConn.createAtomicType(XQItemType.XQBASETYPE_ANYURI));
    XQResultSequence xqs = xqpe.executeQuery();
    String result = null;
    if (xqs.next()) {
        result = xqs.getItemAsString(null);
    }
    return result;
}

@Override
public boolean absolute(int itempos) throws XQException {

    checkState(ex_sequence_closed);
    if (sequence.size() > 0) {
        if (itempos >= 0) {
            position = itempos;
        } else {
            position = sequence.size() + itempos + 1;
        }
        if (position < 0) {
            position = 0;
        } else if (position > sequence.size() + 1) {
            position = sequence.size() + 1;
        }
        setCurrent();
        return position > 0 && position <= sequence.size();
    }
    return false;
}

@Override
public void write(ObjectDataOutput out, XQSequence sequence) throws IOException {
    try {
        List<XQItemAccessor> items;
        synchronized (sequence) {
            if (sequence.isScrollable()) {
                sequence.beforeFirst();
                items = new ArrayList<>(sequence.count());
            } else {
                items = new ArrayList<>();
            }
            while (sequence.next()) {
                Object value = sequence.getObject();
                if (value instanceof XQItemAccessor) {
                    items.add((XQItemAccessor) value);
                } else {
                    items.add(sequence.getItem());
                }
            }
        }
        logger.trace("write; writing items: {}", items);
        out.writeObject(items);
    } catch (XQException ex) {
        throw new IOException(ex);
    }
}

public boolean runSecQuery() throws XQException {

    String query = "declare namespace s=\"http://tpox-benchmark.com/security\";\n" +
        "declare variable $sym external;\n" + 
        "for $sec in fn:collection(\"/{http://tpox-benchmark.com/security}Security\")/s:Security\n" +
        "where $sec/s:Symbol=$sym\n" + //'IBM'\n" +
        "return $sec\n";

    XQPreparedExpression xqpe = xqc.prepareExpression(query);
    xqpe.bindString(new QName("sym"), "IBM", null);
    XQResultSequence xqs = xqpe.executeQuery();
    boolean found = false;
    while (xqs.next()) {
        System.out.println(xqs.getItemAsString(null));
        found = true;
    }
    return found;
}

@Override
public XQSequenceType getStaticVariableType(QName name) throws XQException {

    checkState(ex_expression_closed);
    if (name == null) {
        throw new XQException("name is null");
    }
    if (getVarNames().contains(name)) {
        // where can I get var type??
        XQItemType type;
        XQItemAccessor acc = (XQItemAccessor) getBindings().get(name);
        if (acc != null) {
            type = acc.getItemType();
        } else {
            type = connection.createItemType();
        }
        return new BagriXQSequenceType(type, OCC_ZERO_OR_MORE);
    }
    throw new XQException("Static variable [" + name + "] does not exist");
}

@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;
}

@Test
public void testPersonQuery() throws XPathException, XQException {

       Configuration config = Configuration.newConfiguration();
       StaticQueryContext sqc = config.newStaticQueryContext();
        DynamicQueryContext dqc = new DynamicQueryContext(config);
       dqc.setApplyFunctionConversionRulesToExternalVariables(false);

    String query = "declare base-uri \"../../etc/samples/xmark/\";\n" +
            "let $auction := fn:doc(\"auction.xml\") return\n" +
            "for $b in $auction/site/people/person[@id = 'person0'] return $b/name/text()";

    //dqc.setParameter(new StructuredQName("", "", "v"), objectToItem(Boolean.TRUE, config));
        XQueryExpression xqExp = sqc.compileQuery(query);
       SequenceIterator itr = xqExp.iterator(dqc);
       Item item = itr.next();
        assertNotNull(item);
        String val = item.getStringValue();
    assertEquals("Huei Demke", val);
    assertNull(itr.next());
}

@Override
public boolean isQueryReadOnly(final String query, Properties props) throws XQException {
    boolean result = super.isQueryReadOnly(query);
    if (result) {
        int qKey = getQueryManagement().getQueryKey(query);
        XQueryExpression xqExp;
        try {
            xqExp = getXQuery(qKey, query, props);
        } catch (XPathException xpe) {
            logger.error("isQueryReadOnly.error: ", xpe);
            throw convertXPathException(xpe);
        }
        result = !isUpdatingExpression(xqExp.getExpression());
        }
        return result;
}

@Override
public XQItem createItemFromNode(Node value, XQItemType type) throws XQException {

    checkState(ex_connection_closed);
    if (value == null) {
        throw new XQException("Node value is null");
    }
    if (type == null) {
        return new BagriXQItem(xqProcessor, createNodeType(), value); 
    } else { 
        if (!((BagriXQItemType) type).isNodeCompatible(value)) {
            throw new XQException("Node type and value are not compatible");
        } 
        return new BagriXQItem(xqProcessor, type, value); 
    }
}

@Override
public void commit() throws XQException {

    checkState(ex_connection_closed);
    if (autoCommit) {
        throw new XQException("The connection is in AutoCommit state, nothing to commit explicitly.", String.valueOf(ecTransWrongState));
    }

    if (transactional) {
        try {
            getTxManager().commitTransaction(txId);
        } catch (BagriException ex) {
            throw getXQException(ex);
        }
        txId = TX_NO;
    }
}

@Override
public XMLStreamReader getSequenceAsStream() throws XQException {

    checkState(ex_sequence_closed);
    try {
        return XMLUtils.stringToStream(getSequenceAsString(null));
    } catch (IOException ex) {
        throw new XQException(ex.getMessage());
    }
}

@Test
public void testNamespace() throws XQException {
    XQStaticContext xqsc = xqc.getStaticContext(); 
    xqsc.declareNamespace("foo", "http://www.foo.com");
    XQExpression  xqe = xqc.createExpression(xqsc);
    XQSequence xqs = xqe.executeQuery("<foo:e/>");
    xqe.close();
}

@Test
public void testItemType() throws XQException {
    XQItemType xqtype = xqc.createDocumentType() ;
    assertFalse("A-XQIT-8.1: isAnonymousType() reports if the type is anonymous.", xqtype.isAnonymousType());
    assertFalse("A-XQIT-9.1: isElementNillable() reports if the element is nillable.", xqtype.isElementNillable());
    //xqtype.getPIName();
}

private void closeResults() throws XQException {
    for (XQResultSequence sq: results) {
        if (!sq.isClosed()) {
            sq.close();
        }
    }
    results.clear();
}

@Override
public XQPreparedExpression prepareExpression(InputStream xquery, XQStaticContext context) throws XQException {

    String query = null;
    try {
        query = XMLUtils.textToString(xquery);
    } catch (IOException ex) {
        throw getXQException(ex);
    }
    return prepareExpression(query, context);
}

@Test
@Ignore
public void getConnectionWithCredentialsTest() throws XQException {
    String username = "test";
    String password = "test";
    XQConnection conn = xqds.getConnection(username, password);
    assertNull(conn);
    //assertFalse(conn.isClosed());
    //conn.close();
}

@Override
public void writeItemToResult(Result result) throws XQException {

    checkAccess(true);
    super.writeItemToResult(result);
    accessed = true;
}

@Override
public Object getObject() throws XQException {

    checkAccess(true);
    Object result = super.getObject();
    accessed = true;
    return result;
}

@Override
public boolean getBoolean() throws XQException {

    checkAccess(true);
    boolean result = super.getBoolean();
    accessed = true;
    return result;
}

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;
}

public static XQSequence mapToSequence(XQDataFactory factory, Map<String, Object> map) throws XQException {

        List<XQSequence> pairs = new ArrayList<>(); 
        for (Map.Entry<String, Object> e: map.entrySet()) {
            List<XQItemAccessor> pair = new ArrayList<>(2);
            pair.add(factory.createItemFromString(e.getKey(), factory.createAtomicType(XQBASETYPE_STRING)));
            pair.add(factory.createItemFromObject(e.getValue(), factory.createAtomicType(getBaseTypeForObject(e.getValue()))));
            pairs.add(factory.createSequence(pair.iterator()));
        }
        return factory.createSequence(pairs.iterator());
    }

@Override
public XQPreparedExpression prepareExpression(String xquery) throws XQException {

    checkState(ex_connection_closed);
    if (xquery == null) {
        throw new XQException("Provided query is null");
    }

    BagriXQPreparedExpression exp = new BagriXQPreparedExpression(this);
    exp.setXQuery(xquery);
    prepareQuery(exp);
    return exp;
}

BagriXQDynamicContext(BagriXQConnection connection) {
    this();
    this.connection = connection;
    try {
        this.context = connection.getStaticContext();
    } catch (XQException ex) {
        connection = null;
    }
}

@Override
public void writeItem(Writer ow, Properties props) throws XQException {

    checkAccess(true);
    super.writeItem(ow, props);
    accessed = true;
}

private void rollback() throws XQException {
    IXQSession ixqSession=DptXMLDBSessionFactory.getXQSession();
    if(ixqSession!=null&&!ixqSession.isClosed()){
        ixqSession.rollBack();
    }

}

@ManagedOperation(description="Cancel currently running query started from the same JMX connection")
public void cancelQuery() {
    try {
        // are we in exec state now?
        XQProcessor xqp = ((BagriXQConnection) xqConn).getProcessor();
        xqp.cancelExecution();
    } catch (XQException ex) {
        logger.error("cancelQuery.error", ex); 
        throw new RuntimeException(ex.getMessage());
    } 
}

/**
 * Checkout the repository on a specific revision
 * 
 * TODO: Implement the search of all files in the repository
 * 
 * @param revision
 */
@Override
public RepositoryRevision checkout(String revision) {
    String fileUrl = "a.xml";
    String fileContent = "";
    try {
        fileContent = checkout(revision, fileUrl);
    } catch (XQException e) {
        e.printStackTrace();
    }

    RepositoryRevision rr = new RepositoryRevision();
    rr.addRepositoryFile(new RepositoryFile(fileUrl, fileContent));
    return rr;
}

@Override
public String getItemAsString(Properties props) throws XQException {

    if (closed) {
        throw new XQException(ex_item_closed);
    }
    if (value == null) {
        throw new XQException("Value is not accessible");
    }
    props = checkOutputProperties(props);
    return xqProcessor.convertToString(value, props);
}

@Override
public void setHoldability(int holdability) throws XQException {

    if (holdability != HOLDTYPE_HOLD_CURSORS_OVER_COMMIT && holdability != HOLDTYPE_CLOSE_CURSORS_AT_COMMIT) {
        throw new XQException("Wrong holdability value: " + holdability);
    }  
    this.holdability = holdability;
}

@Override
public XMLStreamReader getItemAsStream() throws XQException {

    if (closed) {
        throw new XQException(ex_item_closed);
    }
    try {
        return XMLUtils.stringToStream(getItemAsString(null));
    } catch (IOException ex) {
        throw new XQException(ex.getMessage());
    }
}

@Override
public float getFloat() throws XQException {

    checkAccess(true);
    float result = super.getFloat();
    accessed = true;
    return result;
}

@Override
public String getSequenceAsString(Properties props) throws XQException {

    checkState(ex_sequence_closed);
       props = checkOutputProperties(props);
    return getXQProcessor().convertToString(this, props);
}

private long storeXmlDocument(String fileName) throws XQException {

    String dName = "..\\..\\etc\\samples\\tpox\\";
    String xml;
    try {
        xml = readTextFile(dName + fileName);
    } catch (IOException ex) {
        throw new XQException(ex.getMessage());
    }

    String query = "declare namespace bgdb=\"http://bagridb.com/bdb\";\n" +
            "declare variable $uri external;\n" + 
            "declare variable $xml external;\n" + 
            "declare variable $props external;\n" + 
            "let $id := bgdb:store-document($uri, $xml, $props)\n" +
            "return $id\n";

    XQPreparedExpression xqpe = xqc.prepareExpression(query);
    xqpe.bindString(new QName("uri"), "65538.xml", xqc.createAtomicType(XQItemType.XQBASETYPE_ANYURI));
    xqpe.bindString(new QName("xml"), xml, xqc.createAtomicType(XQItemType.XQBASETYPE_STRING));
    List<String> props = new ArrayList<>(4);
    props.add(pn_document_data_format + "=xml");
    props.add(pn_document_collections + "=CLN_Custom, CLN_Security");
    xqpe.bindSequence(new QName("props"), xqc.createSequence(props.iterator()));
    XQSequence xqs = xqpe.executeQuery();
    if (xqs.next()) {
        long id = xqs.getLong();
        xqpe.close();
        xqs.close();
        return id;
    } else {
        xqpe.close();
        xqs.close();
        throw new XQException("no response from store-document function");
    }
}

@Override
public boolean previous() throws XQException {

    checkState(ex_sequence_closed);
    position--;
    if (position > 0 && sequence.size() > 0) {
        setCurrent();
        return true;
    }
    return false;
}