private void assertScore(boolean isScoresTest, SolrDocument doc) {
   if (isScoresTest) {
     assertThat(
         "score join doesn't return 1.0", doc.getFirstValue("score").toString(), not("1.0"));
   } else {
     assertEquals("Solr join has constant score", "1.0", doc.getFirstValue("score").toString());
   }
 }
  private static DcsManifestation getManifestation(SolrDocument doc) {
    DcsManifestation man = new DcsManifestation();

    man.setId(get(doc, EntityField.ID));

    if (has(doc, ManifestationField.DELIVERABLE_UNIT)) {
      man.setDeliverableUnit(get(doc, ManifestationField.DELIVERABLE_UNIT));
    }

    man.setMetadata(getMetadataSet(doc));
    man.setMetadataRef(getMetadataRefSet(doc, EntityField.METADATA_REF));
    man.setManifestationFiles(getManifestationFileSet(doc));

    if (has(doc, CoreMetadataField.TYPE)) {
      man.setType(get(doc, CoreMetadataField.TYPE));
    }

    man.setTechnicalEnvironment(getStringSet(doc, ManifestationField.TECH));

    if (has(doc, ManifestationField.DATE_CREATED)) {
      man.setDateCreated(
          DateUtility.toIso8601(
              ((Date) doc.getFirstValue(ManifestationField.DATE_CREATED.solrName())).getTime()));
    }

    man.setAlternateIds(getResourceIdentifierSet(doc));
    return man;
  }
  private static SeadEvent getEvent(SolrDocument doc) {
    SeadEvent event = new SeadEvent();

    event.setId(get(doc, EntityField.ID));

    Date date = (Date) doc.getFirstValue(EventField.DATE.solrName());

    if (date != null) {
      event.setDate(DateUtil.getThreadLocalDateFormat().format(date));
    }

    event.setDetail(getFirst(doc, EventField.DETAIL));
    event.setOutcome(getFirst(doc, EventField.OUTCOME));
    event.setEventType(getFirst(doc, EventField.TYPE));
    event.setTargets(getEntityRefSet(doc, EventField.TARGET));
    event.setAlternateIds(getResourceIdentifierSet(doc));

    SeadLogDetail logDetail = new SeadLogDetail();

    //   if (has(doc, DetailLogField.IPADDRESS)) {

    logDetail.setIpAddress(
        (String) doc.getFieldValue(SeadSolrField.DetailLogField.IPADDRESS.solrName()));
    //  }
    if (has(doc, SeadSolrField.DetailLogField.USERAGENT)) {

      logDetail.setUserAgent(
          (String) doc.getFieldValue(SeadSolrField.DetailLogField.USERAGENT.solrName()));
    }
    if (has(doc, SeadSolrField.DetailLogField.SUBJECT)) {

      logDetail.setSubject(
          (String) doc.getFieldValue(SeadSolrField.DetailLogField.SUBJECT.solrName()));
    }
    if (has(doc, SeadSolrField.DetailLogField.NODEIDENTIFIER)) {

      logDetail.setNodeIdentifier(
          (String) doc.getFieldValue(SeadSolrField.DetailLogField.NODEIDENTIFIER.solrName()));
    }

    event.setLogDetail(logDetail);

    return event;
  }
  private void testJoins(String toColl, String fromColl, Integer toDocId, boolean isScoresTest)
      throws SolrServerException, IOException {
    // verify the join with fromIndex works
    final String fromQ = "match_s:c^2";
    CloudSolrClient client = cluster.getSolrClient();
    {
      final String joinQ =
          "{!join "
              + anyScoreMode(isScoresTest)
              + "from=join_s fromIndex="
              + fromColl
              + " to=join_s}"
              + fromQ;
      QueryRequest qr =
          new QueryRequest(params("collection", toColl, "q", joinQ, "fl", "id,get_s,score"));
      QueryResponse rsp = new QueryResponse(client.request(qr), client);
      SolrDocumentList hits = rsp.getResults();
      assertTrue("Expected 1 doc, got " + hits, hits.getNumFound() == 1);
      SolrDocument doc = hits.get(0);
      assertEquals(toDocId, doc.getFirstValue("id"));
      assertEquals("b", doc.getFirstValue("get_s"));
      assertScore(isScoresTest, doc);
    }

    // negative test before creating an alias
    checkAbsentFromIndex(fromColl, toColl, isScoresTest);

    // create an alias for the fromIndex and then query through the alias
    String alias = fromColl + "Alias";
    CollectionAdminRequest.CreateAlias request =
        CollectionAdminRequest.createAlias(alias, fromColl);
    request.process(client);

    {
      final String joinQ =
          "{!join "
              + anyScoreMode(isScoresTest)
              + "from=join_s fromIndex="
              + alias
              + " to=join_s}"
              + fromQ;
      final QueryRequest qr =
          new QueryRequest(params("collection", toColl, "q", joinQ, "fl", "id,get_s,score"));
      final QueryResponse rsp = new QueryResponse(client.request(qr), client);
      final SolrDocumentList hits = rsp.getResults();
      assertTrue("Expected 1 doc", hits.getNumFound() == 1);
      SolrDocument doc = hits.get(0);
      assertEquals(toDocId, doc.getFirstValue("id"));
      assertEquals("b", doc.getFirstValue("get_s"));
      assertScore(isScoresTest, doc);
    }

    // negative test after creating an alias
    checkAbsentFromIndex(fromColl, toColl, isScoresTest);

    {
      // verify join doesn't work if no match in the "from" index
      final String joinQ =
          "{!join "
              + (anyScoreMode(isScoresTest))
              + "from=join_s fromIndex="
              + fromColl
              + " to=join_s}match_s:d";
      final QueryRequest qr =
          new QueryRequest(params("collection", toColl, "q", joinQ, "fl", "id,get_s,score"));
      final QueryResponse rsp = new QueryResponse(client.request(qr), client);
      final SolrDocumentList hits = rsp.getResults();
      assertTrue("Expected no hits", hits.getNumFound() == 0);
    }
  }
Пример #5
0
  @Override
  // Returned Map will have suffixes in the key names - client is responsible for handling them
  public List<Map<String, Object>> get(String type, String cql) throws PersistenceException {
    if (StringUtils.isBlank(type)) {
      throw new PersistenceException(
          "The type of object(s) to retrieve must be non-null and not blank, e.g., notification, metacard, etc.");
    }

    List<Map<String, Object>> results = new ArrayList<>();

    // Set Solr Core name to type and create/connect to Solr Core
    SolrServer coreSolrServer = getSolrCore(type);
    if (coreSolrServer == null) {
      return results;
    }

    SolrQueryFilterVisitor visitor = new SolrQueryFilterVisitor(coreSolrServer, type);

    try {
      SolrQuery solrQuery;
      // If not cql specified, then return all items
      if (StringUtils.isBlank(cql)) {
        solrQuery = new SolrQuery("*:*");
      } else {
        Filter filter = CQL.toFilter(cql);
        solrQuery = (SolrQuery) filter.accept(visitor, null);
      }
      QueryResponse solrResponse = coreSolrServer.query(solrQuery, METHOD.POST);
      long numResults = solrResponse.getResults().getNumFound();
      LOGGER.debug("numResults = {}", numResults);

      SolrDocumentList docs = solrResponse.getResults();
      for (SolrDocument doc : docs) {
        PersistentItem result = new PersistentItem();
        Collection<String> fieldNames = doc.getFieldNames();
        for (String name : fieldNames) {
          LOGGER.debug("field name = {} has value = {}", name, doc.getFieldValue(name));
          if (name.endsWith(PersistentItem.TEXT_SUFFIX) && doc.getFieldValues(name).size() > 1) {
            result.addProperty(
                name,
                doc.getFieldValues(name)
                    .stream()
                    .filter(s -> s instanceof String)
                    .map(s -> (String) s)
                    .collect(Collectors.toSet()));
          } else if (name.endsWith(PersistentItem.XML_SUFFIX)) {
            result.addXmlProperty(name, (String) doc.getFirstValue(name));
          } else if (name.endsWith(PersistentItem.TEXT_SUFFIX)) {
            result.addProperty(name, (String) doc.getFirstValue(name));
          } else if (name.endsWith(PersistentItem.LONG_SUFFIX)) {
            result.addProperty(name, (Long) doc.getFirstValue(name));
          } else if (name.endsWith(PersistentItem.INT_SUFFIX)) {
            result.addProperty(name, (Integer) doc.getFirstValue(name));
          } else if (name.endsWith(PersistentItem.DATE_SUFFIX)) {
            result.addProperty(name, (Date) doc.getFirstValue(name));
          } else {
            LOGGER.info("Not adding field {} because it has invalid suffix", name);
          }
        }
        results.add(result);
      }
    } catch (CQLException e) {
      throw new PersistenceException(
          "CQLException while getting Solr data with cql statement " + cql, e);
    } catch (SolrServerException e) {
      throw new PersistenceException(
          "SolrServerException while getting Solr data with cql statement " + cql, e);
    }

    return results;
  }
  private static DcsEntity getDeliverableUnit(SolrDocument doc) {
    SeadDeliverableUnit du = new SeadDeliverableUnit();

    du.setId(get(doc, EntityField.ID));

    if (has(doc, CoreMetadataField.RIGHTS)) {
      du.setRights(get(doc, CoreMetadataField.RIGHTS));
    }

    du.setCollections(getCollectionRefSet(doc, DeliverableUnitField.COLLECTIONS));
    du.setFormerExternalRefs(getStringSet(doc, DeliverableUnitField.FORMER_REFS));

    if (has(doc, CoreMetadataField.TITLE)) {
      du.setTitle(getFirst(doc, CoreMetadataField.TITLE));
    }

    if (has(doc, SeadSolrField.EntityField.ABSTRACT)) {
      String abstrct = get(doc, SeadSolrField.EntityField.ABSTRACT);
      abstrct = StringEscapeUtils.unescapeHtml(abstrct);
      du.setAbstrct(abstrct);
    }

    if (has(doc, SeadSolrField.EntityField.PUBDATE)) {
      String pubdate = getFirst(doc, SeadSolrField.EntityField.PUBDATE);
      du.setPubdate(pubdate);
    }

    if (has(doc, SeadSolrField.EntityField.MDUPDATE_DATE)) {
      Date date = (Date) doc.getFirstValue(SeadSolrField.EntityField.MDUPDATE_DATE.solrName());

      if (date != null) {
        du.setMetadataUpdateDate(DateUtil.getThreadLocalDateFormat().format(date));
      }
    }

    //        if (has(doc, DeliverableUnitField.LOCATION)) {
    //            String location = getFirst(doc, DeliverableUnitField.LOCATION);
    //            du.addSite(location);
    //        }

    du.setSites(getStringSet(doc, SeadSolrField.DeliverableUnitField.LOCATION));

    if (has(doc, SeadSolrField.DeliverableUnitField.SIZEBYTES)) {
      long size = (Long) doc.getFirstValue(SeadSolrField.DeliverableUnitField.SIZEBYTES.solrName());
      if (size > 0) {
        du.setSizeBytes(size);
      }
    }

    if (has(doc, SeadSolrField.DeliverableUnitField.FILENO)) {
      long fileNo = (Long) doc.getFirstValue(SeadSolrField.DeliverableUnitField.FILENO.solrName());
      if (fileNo > 0) {
        du.setFileNo(fileNo);
      }
    }

    if (has(doc, SeadSolrField.CoreMetadataField.CONTACT)) {
      String contact = getFirst(doc, SeadSolrField.CoreMetadataField.CONTACT);
      du.setContact(contact);
    }

    du.setCollections(getCollectionRefSet(doc, DeliverableUnitField.COLLECTIONS));
    du.setFormerExternalRefs(getStringSet(doc, DeliverableUnitField.FORMER_REFS));

    if (has(doc, DeliverableUnitField.DIGITAL_SURROGATE)) {
      du.setDigitalSurrogate(
          (Boolean) doc.getFieldValue(DeliverableUnitField.DIGITAL_SURROGATE.solrName()));
    }

    du.setMetadataRef(getMetadataRefSet(doc, EntityField.METADATA_REF));
    du.setMetadata(getMetadataSet(doc));
    du.setRelations(getRelations(doc));
    du.setParents(getDeliverableUnitRefSet(doc, DeliverableUnitField.PARENT));

    du.setSubjects(getStringSet(doc, CoreMetadataField.SUBJECT));
    du.setDataContributors(getCreatorSet(doc));
    du.setSubmitter(getSubmitter(doc));
    du.setAlternateIds(getResourceIdentifierSet(doc));
    SeadDataLocation primaryDataLocation = getPrimaryDataLocation(doc);
    du.setPrimaryLocation(primaryDataLocation);
    du.setSecondaryDataLocations(getSecondaryDataLocationSet(doc));

    if (has(doc, CoreMetadataField.TYPE)) {
      du.setType(getFirst(doc, CoreMetadataField.TYPE));
    }

    return du;
  }
  private static DcsFile getFile(SolrDocument doc) {
    SeadFile file = new SeadFile();

    file.setId(get(doc, EntityField.ID));
    file.setFixity(getFixitySet(doc));
    file.setFormats(getFormatSet(doc));
    file.setExtant((Boolean) doc.getFieldValue(FileField.EXTANT.solrName()));

    if (has(doc, FileField.VALID)) {
      file.setValid((Boolean) doc.getFieldValue(FileField.VALID.solrName()));
    }

    if (has(doc, FileField.NAME)) {
      file.setName(getFirst(doc, FileField.NAME));
    }

    if (has(doc, FileField.SOURCE)) {
      file.setSource(getFirst(doc, FileField.SOURCE));
    }

    if (has(doc, SeadSolrField.EntityField.IMMEDIATEANCESTRY)) {
      file.setParent(getFirst(doc, SeadSolrField.EntityField.IMMEDIATEANCESTRY));
    }

    if (has(doc, SeadSolrField.EntityField.MDUPDATE_DATE)) {
      Object object = doc.getFirstValue(SeadSolrField.EntityField.MDUPDATE_DATE.solrName());
      if (object instanceof Date) {
        Date date = (Date) object;

        if (date != null) {
          file.setMetadataUpdateDate(DateUtil.getThreadLocalDateFormat().format(date));
        }
      } else {

        if (object != null) {
          file.setMetadataUpdateDate(object.toString());
        }
      }
    } else {
      file.setMetadataUpdateDate("2012-10-27T22:05:20.809Z");
    }

    if (has(doc, SeadSolrField.FileField.DEPOSITDATE)) {

      Object object = doc.getFirstValue(SeadSolrField.FileField.DEPOSITDATE.solrName());
      if (object instanceof Date) {
        Date date = (Date) object; // doc.getFirstValue(FileField.DEPOSITDATE.solrName());

        if (date != null) {
          file.setDepositDate(DateUtil.getThreadLocalDateFormat().format(date));
        }
      } else {

        if (object != null) {
          file.setDepositDate(object.toString());
        }
      }
    } else {
      file.setDepositDate("2012-10-27T22:05:20.809Z");
    }

    long size = (Long) doc.getFirstValue(FileField.SIZE.solrName());
    if (size > 0) {
      file.setSizeBytes(size);
    }

    file.setMetadata(getMetadataSet(doc));
    file.setMetadataRef(getMetadataRefSet(doc, EntityField.METADATA_REF));
    file.setAlternateIds(getResourceIdentifierSet(doc));
    SeadDataLocation primaryDataLocation = getPrimaryDataLocation(doc);
    file.setPrimaryLocation(primaryDataLocation);

    file.setSecondaryDataLocations(getSecondaryDataLocationSet(doc));

    return file;
  }
 private static String getFirst(SolrDocument doc, SolrName field) {
   return (String) doc.getFirstValue(field.solrName());
 }