Java CQLQueryResults类代码示例

import gov.nih.nci.cagrid.cqlresultset.CQLQueryResults; //导入依赖的package包/类
@Test
    public void testExpressionProbeAnnotation() throws RemoteException {
        CQLQuery cqlQuery = new CQLQuery();
        gov.nih.nci.cagrid.cqlquery.Object target = new gov.nih.nci.cagrid.cqlquery.Object();
        target.setName("gov.nih.nci.caarray.domain.array.ExpressionProbeAnnotation");
        cqlQuery.setTarget(target);
        Attribute[] atts = {
//            new Attribute("chromosomeName", Predicate.EQUAL_TO, "foo"),
//            new Attribute("chromosomeStartPosition", Predicate.LESS_THAN, "1"),
//            new Attribute("chromosomeEndPosition", Predicate.GREATER_THAN, "2")
        };
//        Group g = new Group(null, atts, null, LogicalOperator.AND);
//        target.setGroup(g);
        CQLQueryResults cqlResults = gridClient.query(cqlQuery);
//        assertEquals(1071, cqlResults.getObjectResult().length);
        Iterator iter = new CQLQueryResultsIterator(cqlResults, CaArraySvcClient.class.getResourceAsStream("client-config.wsdd"));
        while (iter.hasNext()) {
            ExpressionProbeAnnotation f = (ExpressionProbeAnnotation) (iter.next());
//            assertEquals("foo", f.getChromosomeName());
//            assertTrue(f.getChromosomeStartPosition().longValue() < 1L);
//            assertTrue(f.getChromosomeEndPosition().longValue() > 200L);
        }
    }
 

import gov.nih.nci.cagrid.cqlresultset.CQLQueryResults; //导入依赖的package包/类
/**
 * {@inheritDoc}
 */
@Override
public List<String> retrieveAllCollectionNameProjects() throws ConnectionException {
    List<String> collectionNameProjectsCollection = new ArrayList<String>();
    final CQLQuery query = new CQLQuery();
    Object target = new Object();
    target.setName("gov.nih.nci.ncia.domain.TrialDataProvenance");
    query.setTarget(target);
    QueryModifier distinctProjectModifier = new QueryModifier();
    distinctProjectModifier.setCountOnly(false);
    distinctProjectModifier.setDistinctAttribute("project");
    query.setQueryModifier(distinctProjectModifier);

    CQLQueryResults result = connectAndExecuteQuery(query);
    // Iterate Results
    if (result != null) {
        CQLQueryResultsIterator iter2 = new CQLQueryResultsIterator(result);
        while (iter2.hasNext()) {
            TargetAttribute[] obj = (TargetAttribute[]) iter2.next();
            //LOGGER.info(obj[0].getValue());
            collectionNameProjectsCollection.add(obj[0].getValue());
        }
    }
    return collectionNameProjectsCollection;
}
 

import gov.nih.nci.cagrid.cqlresultset.CQLQueryResults; //导入依赖的package包/类
public Project[] findAllProjects() throws RemoteException {
    CQLQuery query = new CQLQuery();
    Object target = new Object();
    query.setTarget(target);
    target.setName(Project.class.getName());

    CQLQueryResults results = this.client.query(query);

    Iterator iter = new CQLQueryResultsIterator(results, this.getClass().getResourceAsStream("client-config.wsdd"));
    int count = 0;

    List<Project> projects = new ArrayList<Project>();
    // iterate and print XML
    while (iter.hasNext()) {
        Project prj = (Project) iter.next();
        projects.add(prj);
        count++;
    }

    Project[] projectsArray = new Project[count];
    return projects.toArray(projectsArray);

}
 

import gov.nih.nci.cagrid.cqlresultset.CQLQueryResults; //导入依赖的package包/类
public void validateCQL2ResultSet(org.cagrid.cql2.results.CQLQueryResults results) throws SchemaValidationException {
    // make sure we are ready to go
       initializeRestrictedXSD();

       if (results == null) {
           LOG.debug("Null results passed, ignoring.");
           return;
       }

       StringWriter writer = new StringWriter();
       try {
           Utils.serializeObject(results, CqlSchemaConstants.CQL2_RESULTS_QNAME, writer);
       } catch (Exception e) {
           LOG.error(e);
           throw new SchemaValidationException("Problem serializing result set", e);
       }

       String xmlContents = writer.getBuffer().toString();
       if (LOG.isDebugEnabled()) {
           LOG.debug("RESULTS:\n" + xmlContents);
       }
       this.validator.validate(xmlContents);
}
 

import gov.nih.nci.cagrid.cqlresultset.CQLQueryResults; //导入依赖的package包/类
private static CQLQueryResults aggregateDcqlResults(DCQLQueryResultsCollection results) {
    CQLQueryResults cqlResults = new CQLQueryResults();
    List<CQLObjectResult> allObjectResults = new ArrayList<CQLObjectResult>();
    String targetName = null;
    for (DCQLResult result : results.getDCQLResult()) {
        CQLQueryResults singleCqlResult = result.getCQLQueryResultCollection();
        if (targetName == null) {
            targetName = singleCqlResult.getTargetClassname();
        } else {
            assertEquals("Unexpected result type found in DCQL", targetName, singleCqlResult.getTargetClassname());
        }
        CQLObjectResult[] objectResults = singleCqlResult.getObjectResult();
        assertNotNull("Data service " + result.getTargetServiceURL() + " returned non-object results!", objectResults);
        Collections.addAll(allObjectResults, objectResults);
    }
    
    // generate the aggregate query result
    CQLQueryResults aggregate = new CQLQueryResults();
    CQLObjectResult[] resultArray = new CQLObjectResult[allObjectResults.size()];
    allObjectResults.toArray(resultArray);
    aggregate.setObjectResult(resultArray);
    aggregate.setTargetClassname(targetName);
    return cqlResults;
}
 

import gov.nih.nci.cagrid.cqlresultset.CQLQueryResults; //导入依赖的package包/类
public static CQLQueryResults aggregateDCQLResults(
    DCQLQueryResultsCollection dcqlResults, String targetClassname) {
    List<CQLObjectResult> objectResults = new LinkedList<CQLObjectResult>();
    for (DCQLResult result : dcqlResults.getDCQLResult()) {
        CQLObjectResult[] objects = result.getCQLQueryResultCollection().getObjectResult();
        if (objects != null && objects.length != 0) {
            Collections.addAll(objectResults, objects);
        }
    }
    
    // generate the aggregate query result
    CQLQueryResults aggregate = new CQLQueryResults();
    CQLObjectResult[] resultArray = new CQLObjectResult[objectResults.size()];
    objectResults.toArray(resultArray);
    aggregate.setObjectResult(resultArray);
    aggregate.setTargetClassname(targetClassname);
    
    return aggregate;
}
 

import gov.nih.nci.cagrid.cqlresultset.CQLQueryResults; //导入依赖的package包/类
public String fetchBioassay(String id) 
	throws MalformedURIException, RemoteException
{
	 String url = "http://cagrid-portal.nci.nih.gov:8080/wsrf/services/cagrid/CaArraySvc";

		 CaArraySvcClient client = new CaArraySvcClient(url);

		 //CQLQuery query = (CQLQuery) Utils.deserializeDocument("demo.xml", CQLQuery.class);
		 CQLQuery query = new CQLQuery();
		 Object target = new Object();
		 target.setName("gov.nih.nci.mageom.domain.BioAssayData.MeasuredBioAssayData");
		 Attribute att = new Attribute("identifier", Predicate.EQUAL_TO, id);
		 target.setAttribute(att);
		 query.setTarget(target);
		 
		 CQLQueryResults results = client.query(query);

		 results.setTargetClassname("java.lang.Object");
		 CQLQueryResultsIterator iterator = new CQLQueryResultsIterator(results, true);

		 if (! iterator.hasNext()) return null;
	 String bioassay = (String) iterator.next();
	 System.out.println(bioassay);
		 return bioassay;
}
 

import gov.nih.nci.cagrid.cqlresultset.CQLQueryResults; //导入依赖的package包/类
private List<Object> processResults(CQLQueryResults results)
		throws Exception {

	InputStream resourceAsStream = CbmCodeListTests.class
			.getResourceAsStream("client-config.wsdd");
	Iterator<?> iter = new CQLQueryResultsIterator(results,
			resourceAsStream);

	List<Object> remoteValues = new Vector<Object>();

	// Check that all retrieved values are supported by the reference code
	// list while
	while (iter.hasNext()) {
		Object rawValue = iter.next();

		remoteValues.add(rawValue);

	}
	return remoteValues;
}
 

import gov.nih.nci.cagrid.cqlresultset.CQLQueryResults; //导入依赖的package包/类
public gov.nih.nci.cagrid.cqlresultset.CQLQueryResults executeAndAggregateResults(
    gov.nih.nci.cagrid.dcql.DCQLQuery query) throws RemoteException,
    gov.nih.nci.cagrid.fqp.stubs.types.FederatedQueryProcessingFault {
    validateQueryConstraints(query, null);
    
    FederatedQueryEngine engine = new FederatedQueryEngine(null, null, getWorkExecutorService());
    CQLQueryResults results = null;
    try {
        results = engine.executeAndAggregateResults(query);
    } catch (FederatedQueryProcessingException e) {
        LOG.error("Problem executing query: " + e.getMessage(), e);
        FederatedQueryProcessingFault fault = new FederatedQueryProcessingFault();
        fault.setFaultString("Problem executing query: " + e.getMessage());
        FaultHelper helper = new FaultHelper(fault);
        helper.addFaultCause(e);
        throw helper.getFault();
    }
    return results;
}
 

import gov.nih.nci.cagrid.cqlresultset.CQLQueryResults; //导入依赖的package包/类
private void verifyResults(List<SOAPElement> results) {
    LOG.debug("Verifying test results");
    LOG.debug("Loading gold results from " + getGoldFilenname());
    DCQLQueryResultsCollection goldResults = loadGoldDcqlResults();
    
    // convert the list of elements into DCQL results
    DCQLQueryResultsCollection testResults = new DCQLQueryResultsCollection();
    DCQLResult testResult = new DCQLResult();
    testResult.setTargetServiceURL("http://fake.service");
    CQLQueryResults cqlResults = new CQLQueryResults();
    // what's the target classname supposed to be?
    String targetName = deserializeQuery().getTargetObject().getName();
    LOG.debug("Setting test results target classname to " + targetName);
    cqlResults.setTargetClassname(targetName);
    CQLObjectResult[] objectResults = new CQLObjectResult[results.size()];
    for (int i = 0; i < results.size(); i++) {
        CQLObjectResult obj = new CQLObjectResult();
        obj.set_any(new MessageElement[] {new MessageElement(results.get(i))});
        objectResults[i] = obj;
    }
    cqlResults.setObjectResult(objectResults);
    testResult.setCQLQueryResultCollection(cqlResults);
    testResults.setDCQLResult(new DCQLResult[] {testResult});
    
    QueryResultsVerifier.verifyDcqlResults(testResults, goldResults);
}
 

import gov.nih.nci.cagrid.cqlresultset.CQLQueryResults; //导入依赖的package包/类
/**
 * {@inheritDoc}
 */
public ImageAnnotation getImageSeriesAnnotation(String seriesInstanceUID) throws ConnectionException {
    ImageAnnotation imageAnnotation = null;
    Attribute seriesInstanceUIDAttribute = retrieveAttribute("instanceUID", Predicate.EQUAL_TO, seriesInstanceUID);
    Association seriesAssociation = retrieveAssociation("edu.northwestern.radiology.aim.Series", "series",
            seriesInstanceUIDAttribute);
    Association studyAssociation = retrieveAssociation("edu.northwestern.radiology.aim.Study", "study",
            null);
    Association dicomImageReferenceAssociation = retrieveAssociation(
            "edu.northwestern.radiology.aim.DICOMImageReference", "imageReferenceCollection", null);
    studyAssociation.setAssociation(seriesAssociation);
    dicomImageReferenceAssociation.setAssociation(studyAssociation);
    CQLQuery query = retrieveQuery("edu.northwestern.radiology.aim.ImageAnnotation",
            dicomImageReferenceAssociation);
    CQLQueryResults result = connectAndExecuteQuery(query);
    if (result != null) {
        CQLQueryResultsIterator iter = new CQLQueryResultsIterator(result, true);
        if (iter.hasNext()) {
            imageAnnotation = AIMJaxbParser.retrieveImageAnnotationFromXMLString((String) iter.next());
        }
    }
    return imageAnnotation;
}
 

import gov.nih.nci.cagrid.cqlresultset.CQLQueryResults; //导入依赖的package包/类
private ArrayDesign lookupArrayDesign(CaArraySvcClient client, String arrayDesignName) throws RemoteException {
    CQLQuery cqlQuery = new CQLQuery();
    gov.nih.nci.cagrid.cqlquery.Object target = new gov.nih.nci.cagrid.cqlquery.Object();
    target.setName("gov.nih.nci.caarray.domain.array.ArrayDesign");
    Attribute arrayDesignNameAttribute = new Attribute();
    arrayDesignNameAttribute.setName("name");
    arrayDesignNameAttribute.setValue(arrayDesignName);
    arrayDesignNameAttribute.setPredicate(Predicate.EQUAL_TO);
    target.setAttribute(arrayDesignNameAttribute);
    cqlQuery.setTarget(target);
    CQLQueryResults cqlResults = client.query(cqlQuery);
    CQLQueryResultsIterator iter = new CQLQueryResultsIterator(cqlResults, CaArraySvcClient.class
            .getResourceAsStream("client-config.wsdd"));
    if (!(iter.hasNext())) {
        return null;
    }
    return (ArrayDesign) iter.next();
}
 

import gov.nih.nci.cagrid.cqlresultset.CQLQueryResults; //导入依赖的package包/类
private CaArrayFile lookupFile(String fileName) throws RemoteException {
    CQLQuery cqlQuery = new CQLQuery();
    gov.nih.nci.cagrid.cqlquery.Object target = new gov.nih.nci.cagrid.cqlquery.Object();
    target.setName("gov.nih.nci.caarray.domain.file.CaArrayFile");
    Attribute fileNameAttribute = new Attribute();
    fileNameAttribute.setName("name");
    fileNameAttribute.setValue(fileName);
    fileNameAttribute.setPredicate(Predicate.EQUAL_TO);
    target.setAttribute(fileNameAttribute);
    cqlQuery.setTarget(target);
    CQLQueryResults cqlResults = gridClient.query(cqlQuery);
    logForSilverCompatibility(API_CALL, "Grid query(CQLQuery)");
    CQLQueryResultsIterator iter = new CQLQueryResultsIterator(cqlResults, CaArraySvcClient.class
            .getResourceAsStream("client-config.wsdd"));
    return (CaArrayFile) iter.next();
}
 

import gov.nih.nci.cagrid.cqlresultset.CQLQueryResults; //导入依赖的package包/类
private boolean isResultOkay(CQLQueryResults cqlResults, String sampleName) {
    if (cqlResults.getObjectResult() == null) {
        return false;
    }
    Iterator iter = new CQLQueryResultsIterator(cqlResults, CaArraySvcClient.class
            .getResourceAsStream("client-config.wsdd"));
    if (!(iter.hasNext())) {
        return false;
    }
    while (iter.hasNext()) {
        Sample retrievedSample = (Sample) (iter.next());
        // Check if retrieved sample matches requested search criteria.
        logForSilverCompatibility(TRAVERSE_OBJECT_GRAPH, "Sample.getName(): " + retrievedSample.getName());
        if (!sampleName.equalsIgnoreCase(retrievedSample.getName())) {
            return false;
        }
        Set<Extract> extracts = retrievedSample.getExtracts();
        if (extracts == null) {
            logForSilverCompatibility(TRAVERSE_OBJECT_GRAPH, "Sample.getExtracts(): null");
        } else {
            logForSilverCompatibility(TRAVERSE_OBJECT_GRAPH, "Sample.getExtracts(): size = " + extracts.size());
        }
    }
    return true;
}
 

import gov.nih.nci.cagrid.cqlresultset.CQLQueryResults; //导入依赖的package包/类
public void testCountIteration() {
    CQLQueryResults results = loadResults("countResults.xml");
    CQLQueryResultsIterator iter = new CQLQueryResultsIterator(results, false);
    assertTrue("Count iterator had no results", iter.hasNext());
    Object o = iter.next();
    assertNotNull("Count iteration result was null", o);
    assertEquals("Count iteration result was of unexpected type", Long.class, o.getClass());
    assertEquals("Count iteration result was of unexpected value", ((Long) o).longValue(), 200);
    assertFalse("Count iterator claims to have more results", iter.hasNext());
    try {
        iter.next();
        fail("Count iterator did not throw NoSuchElementException with no results to return");
    } catch (NoSuchElementException ex) {
        // expected
    }
}