protected SolrDocumentList getSolrDocumentByUUIDs(List<String> uuids) {
   String operand = "OR";
   SolrDocumentList solrDocumentList = null;
   StringBuffer sb = new StringBuffer();
   sb.append("(");
   for (String uuid : uuids) {
     sb.append("(");
     sb.append(uuid);
     sb.append(")");
     sb.append(operand);
   }
   String queryString = sb.substring(0, sb.length() - operand.length()) + ")";
   SolrQuery query = new SolrQuery();
   SolrDocument solrDocument = null;
   try {
     SolrServer server = SolrServerManager.getInstance().getSolrServer();
     QueryResponse response = null;
     query.setQuery("id:" + queryString);
     response = server.query(query);
     solrDocumentList = response.getResults();
   } catch (SolrServerException e) {
     LOG.info("Exception :", e);
     throw new DocstoreIndexException();
   }
   return solrDocumentList;
 }
예제 #2
0
  private static boolean commit(List<Review> rs) throws Exception {
    if (server == null) {
      server = getServer();
    }
    Collection<SolrInputDocument> docs = new ArrayList<SolrInputDocument>();

    for (Review r : rs) {
      SolrInputDocument doc1 = new SolrInputDocument();

      for (Field f : r.getClass().getDeclaredFields()) {
        if (!f.getName().equals("content") && !f.getName().equals("title")) {
          doc1.addField(f.getName(), f.getLong(r), 1.0f);
        } else {
          doc1.addField(f.getName(), f.get(r), 1.0f);
        }
      }

      docs.add(doc1);
      if (counter++ % 10000 == 0) {
        System.out.println("Process " + counter);
      }
    }
    server.add(docs);
    // 提交
    server.commit();
    System.out.println("Commit @ " + counter);
    return true;
  }
  public void commitRecordsToSolr(SolrServer solr) throws SolrServerException, IOException {

    if (commitCounter < MAX_WARM_SEARCH_COUNT) {
      solr.commit(false, false, false);
      // LOG.info("Time taken to commit with waitSearch = false  commitCounter <
      // MAX_WARM_SEARCH_COUNT");
      commitCounter++;
    } else {

      timeSinceLastCommit = System.currentTimeMillis() - lastCommitTime;
      if (timeSinceLastCommit > TIME_FOR_WARMING_SEARCHERS) {
        solr.commit(false, false, false);
        commitCounter++;
        //                commitCounter = 1;
        // LOG.info("Time taken to commit with waitSearch = false  timeSinceLastCommit >
        // TIME_FOR_WARMING_SEARCHERS");

      } else {
        long startTime = System.currentTimeMillis();
        solr.commit(false, true, false);
        long endTime = System.currentTimeMillis();
        // LOG.info("Time taken to commit with waitSearch = true and time taken is " + (endTime -
        // startTime));
        commitCounter = 1;
      }
    }
    lastCommitTime = System.currentTimeMillis();
  }
  @Test
  @Ignore // very incomplete
  public void testPathAnalysis() throws SolrServerException, IOException {
    SolrServer solr = getSolr();
    // Not really unit testing the schema here because the path logic in the handler is too relevant
    // - could be switched to
    IndexingItemProgress p = mock(IndexingItemProgress.class);
    CmsRepository repo = new CmsRepository("http://ex.ampl:444/s/rep1");
    when(p.getRepository()).thenReturn(repo);
    when(p.getRevision()).thenReturn(new RepoRevision(35L, new Date()));
    CmsChangesetItem item = mock(CmsChangesetItem.class);
    when(item.getPath())
        .thenReturn(new CmsItemPath("/dir/doc main.xml"))
        .thenReturn(new CmsItemPath("/dir sect/doc appendix.xml"));
    ;
    IndexingDocIncrementalSolrj doc = new IndexingDocIncrementalSolrj();
    when(p.getFields()).thenReturn(doc);
    when(p.getItem()).thenReturn(item);
    HandlerPathinfo handlerPathinfo = new HandlerPathinfo();
    handlerPathinfo.handle(p);
    solr.add(doc.getSolrDoc());

    fail(
        "need to test effects of analyzed path* fields and confirm the need for name and extension");
  }
 @Test(dependsOnMethods = "testAddDocument")
 public void testBasicQuery() throws SolrServerException {
   SolrServer server = solrServerFactory.getServer();
   SolrParams params = new SolrQuery("*:*");
   SolrDocumentList results = server.query(params).getResults();
   assertTrue(results.getNumFound() > 0, "didn't return any results");
 }
 protected void indexSolrDocuments(List<SolrInputDocument> solrDocs, boolean isCommit) {
   synchronized (this.getClass()) {
     SolrServer solr = null;
     try {
       solr = SolrServerManager.getInstance().getSolrServer();
       UpdateResponse response = solr.add(solrDocs);
       if (isCommit) {
         try {
           commitRecordsToSolr(solr);
         } catch (HttpSolrServer.RemoteSolrException e) {
           lastCommitTime = System.currentTimeMillis();
           if (e.getMessage().startsWith(MAX_WARM_SEARCH)) {
             LOG.warn(e.getMessage());
           } else {
             throw e;
           }
         }
       }
     } catch (Exception e) {
       LOG.info("Exception :", e);
       rollback(solr);
       throw new DocstoreIndexException(e);
     }
   }
 }
예제 #7
0
  public List<DOSearchResult> getSearchResults(
      DORestSearchRequest request, SearchErrors errors, Map<String, ArrayList<String>> nerMap) {
    List<DOSearchResult> result = new ArrayList<DOSearchResult>();
    QueryParam tcqp = null;
    QueryResponse qres = null;
    try {
      SolrServer server = solrConnectionUtils.getRestSolrServer();

      tcqp = restQueryCreator.getSearchQuery(request, nerMap);
      qres = server.query(tcqp);
      if (qres != null) {
        DOSearchResult serachRes = null;
        if (request.isGrouprequest()) {
          serachRes =
              DOResponseUtils.processGroupQueryResponse(
                  qres, Constants.RESPONSE_TYPE_REST, request.isSpellcheckApplied());
        } else {
          serachRes =
              DOResponseUtils.processQueryResponse(
                  qres, Constants.RESPONSE_TYPE_REST, request.isSpellcheckApplied());
        }
        result.add(serachRes);
      }
    } catch (SolrServerException e) {
      logger.error(e.getMessage(), e);
      SearchError error = new SearchError(ErrorCode.SOLR_ERROR_CODE, e.getMessage());
      errors.add(error);
    } catch (Exception e) {
      logger.error(e.getMessage(), e);
      SearchError error = new SearchError(ErrorCode.SOLR_ERROR_CODE, e.getMessage());
      errors.add(error);
    }

    return result;
  }
 @Test(dependsOnMethods = {"testGetServer"})
 public void testBadQuery() throws SolrServerException {
   SolrServer server = solrServerFactory.getServer();
   SolrParams params = new SolrQuery("text that is not found");
   QueryResponse response = server.query(params);
   assertEquals(0L, response.getResults().getNumFound());
 }
  @Test
  public void fieldsRequestsShouldTurnIntoSelectors() throws Exception, TException {

    String table = "fieldsRequestsShouldTurnIntoSelectors";
    SolrServer server =
        TestTableCreator.newTable(table)
            .withRowCount(1)
            .withRecordsPerRow(2)
            .withRecordColumns("fam.value", "fam.mvf")
            .create();

    SolrQuery query = new SolrQuery("value0-0");
    query.setFields("fam.value");
    QueryResponse response = server.query(query);

    assertEquals(
        "We should get our doc back for a valid test.", 1l, response.getResults().getNumFound());

    SolrDocument docResult = response.getResults().get(0);

    assertEquals("value0-0", docResult.getFieldValue("fam.value"));
    assertNull(
        "We shouldn't get this one back since it wasnt in our fields.",
        docResult.getFieldValues("fam.mvf"));

    removeTable(table);
  }
 protected void indexAndDelete(
     List<SolrInputDocument> solrDocs, List<String> idsToDelete, boolean isCommit) {
   synchronized (this.getClass()) {
     SolrServer solr = null;
     try {
       solr = SolrServerManager.getInstance().getSolrServer();
       if (CollectionUtils.isNotEmpty(solrDocs)) {
         UpdateResponse response = solr.add(solrDocs);
       }
       // deleting document which contains operation delete
       delete(idsToDelete, solr);
       if (isCommit) {
         try {
           commitRecordsToSolr(solr);
         } catch (HttpSolrServer.RemoteSolrException e) {
           lastCommitTime = System.currentTimeMillis();
           if (e.getMessage().startsWith(MAX_WARM_SEARCH)) {
             LOG.warn(e.getMessage());
           } else {
             throw e;
           }
         }
       }
     } catch (Exception e) {
       LOG.info("Exception :", e);
       rollback(solr);
       throw new DocstoreIndexException(e);
     }
   }
 }
 /* (non-Javadoc)
  * @see fr.hoteia.qalingo.core.solr.service.ProductSkuSolrService#addOrUpdateProductSku(fr.hoteia.qalingo.core.domain.ProductSku)
  */
 public void addOrUpdateProductSku(
     final ProductSku productSku, final MarketArea marketArea, final Retailer retailer)
     throws SolrServerException, IOException {
   if (productSku.getId() == null) {
     throw new IllegalArgumentException("Id  cannot be blank or null.");
   }
   if (logger.isDebugEnabled()) {
     logger.debug("Indexing productSku " + productSku.getId());
     logger.debug("Indexing productSku " + productSku.getBusinessName());
     logger.debug("Indexing productSku " + productSku.getDescription());
     logger.debug("Indexing productSku " + productSku.getCode());
   }
   ProductSkuSolr productSkuSolr = new ProductSkuSolr();
   productSkuSolr.setId(productSku.getId());
   productSkuSolr.setBusinessname(productSku.getBusinessName());
   productSkuSolr.setDescription(productSku.getDescription());
   productSkuSolr.setCode(productSku.getCode());
   ProductSkuPrice productSkuPrice = productSku.getPrice(marketArea.getId(), retailer.getId());
   if (productSkuPrice != null) {
     BigDecimal salePrice = productSkuPrice.getSalePrice();
     productSkuSolr.setPrice(salePrice.toString());
   }
   productSkuSolrServer.addBean(productSkuSolr);
   productSkuSolrServer.commit();
 }
  @Test
  public void basicFullTextQuery() throws Exception {
    String table = "basicFullTextQuery";
    SolrServer server =
        TestTableCreator.newTable(table)
            .withRowCount(1)
            .withRecordsPerRow(2)
            .withRecordColumns("fam.value", "fam.mvf", "fam.mvf")
            .create();

    SolrQuery query = new SolrQuery("value0-0");

    QueryResponse response = server.query(query);

    assertEquals("We should get our doc back.", 1l, response.getResults().getNumFound());

    SolrDocument docResult = response.getResults().get(0);

    assertEquals("0", docResult.getFieldValue("recordid"));
    assertEquals("value0-0", docResult.getFieldValue("fam.value"));

    Collection<Object> mvfVals = docResult.getFieldValues("fam.mvf");

    assertTrue(
        "We should get all our values back[" + mvfVals + "]",
        CollectionUtils.isEqualCollection(mvfVals, Lists.newArrayList("value0-0", "value0-0")));

    removeTable(table);
  }
예제 #13
0
  public static void main(String a[]) throws MalformedURLException, SolrServerException {
    SolrServer hotServer = new CommonsHttpSolrServer("http://indexedsearch.prod.o.com:8980/cds");
    SolrQuery solrLocrQuery = new SolrQuery();
    /*solrLocrQuery.setParam("pos", "ORB");
    solrLocrQuery.setParam("locale", "en_US");*/
    solrLocrQuery.setRows(300);
    QueryResponse queryLocResponse = hotServer.query(solrLocrQuery);
    SolrDocumentList locList = queryLocResponse.getResults();

    for (SolrDocument doc : locList) {
      try {
        String str = doc.get("text_s").toString();
        if (str.toLowerCase().contains("price")) {
          if (str.toLowerCase().contains("assurance")) {
            String id = doc.get("id").toString();
            String url = doc.get("title_s").toString();

            System.out.println(id + "|" + url);
          }
        }
      } catch (Exception e) {

      }
    }
  }
  private static void createSolrAlert(String userId, String created, String hashtag) {

    Date d = new Date(created);
    // SimpleDateFormat formatter=new SimpleDateFormat("yyyy-MM-dd'T'hh:mm:ss'Z+9HOUR'");
    // SimpleDateFormat formatter=new SimpleDateFormat("yyyy-MM-dd'T'hh:mm:ss'Z-4HOUR'");
    SimpleDateFormat formatter = new SimpleDateFormat("yyyy-MM-dd'T'HH:mm:ss'Z'");
    created = formatter.format(d);

    SolrServer server = new HttpSolrServer("http://sandbox.hortonworks.com:8983/solr/tweets");
    // create a tweet doc
    SolrInputDocument doc = new SolrInputDocument();

    doc.addField("id", userId + ":" + hashtag + "-" + created);
    doc.addField("doctype_s", "alert");
    doc.addField("createdAt_dt", created);
    doc.addField("tag_s", hashtag);

    try {
      server.add(doc);
      System.out.println("SolrBolt: successfully added alert to Solr server" + hashtag);
    } catch (Exception e) {
      e.printStackTrace();
      // collector.fail(input);
    }
  }
예제 #15
0
  /**
   * Query the indexed csv data using Tabular query, with the parameter {@link SirenParams#TQ}.
   *
   * @throws SolrServerException
   */
  public void query() throws SolrServerException {
    System.out.println("Query: [0]'conference1'");
    final SolrQuery query1 = new SolrQuery();
    query1.setQueryType("siren");
    query1.set(SirenParams.TQ, "[0]'conference1'"); // tabular query
    final QueryResponse response1 = server.query(query1);
    for (SolrDocument d : response1.getResults()) {
      System.out.println(d);
    }
    System.out.println();

    System.out.println("Query: * <name> 'john AND gartner'");
    final SolrQuery query2 = new SolrQuery();
    query2.setQueryType("siren");
    query2.set(SirenParams.NQ, "* <name> 'john AND gartner'"); // ntriple query
    final QueryResponse response2 = server.query(query2);
    for (SolrDocument d : response2.getResults()) {
      System.out.println(d);
    }
    System.out.println();

    System.out.println("Query: * <type> <student> AND [2]'[* TO 2010]'^^<xsd:int>");
    final SolrQuery query3 = new SolrQuery();
    query3.setQueryType("siren");
    query3.set(SirenParams.NQ, "* <type> <student>"); // ntriple query
    query3.set(SirenParams.TQ, "[2]'[* TO 2010]'^^<xsd:int>"); // tabular query
    final QueryResponse response3 = server.query(query3);
    for (SolrDocument d : response3.getResults()) {
      System.out.println(d);
    }
    System.out.println();
  }
 @Test(dependsOnMethods = "testBasicQuery", dataProvider = "documentMap")
 public void testIdQuery(Map<String, String[]> document) throws SolrServerException {
   String id = document.get("id")[0];
   SolrServer server = solrServerFactory.getServer();
   SolrParams params = new SolrQuery("id:" + id);
   SolrDocumentList results = server.query(params).getResults();
   assertEquals(results.getNumFound(), 1, "didn't find article by id");
 }
예제 #17
0
  public JSONArray Search(String query, String sort) {
    SolrServer server;
    SolrDocumentList docs = null;
    String Date_format = null; // for Date格式轉換
    JSONArray jsonArray = new JSONArray();
    try {
      server = new HttpSolrServer(url);
      // add

      SolrQuery solrQuery = new SolrQuery();
      solrQuery.setQuery(query);
      solrQuery.setStart(_start);
      solrQuery.setRows(_nbDocuments);
      solrQuery.setRequestHandler("query");
      solrQuery.set("fl", "*,score"); // 設定fl參數,指定要傳回哪個field的資料,這裡設定所有field與score
      if (_fq1 != "") {
        solrQuery.addFilterQuery("ProductName:" + _fq1);
      }
      if (_fq2 != "") {
        solrQuery.addFilterQuery("publishedDate:" + _fq2);
      }
      if (sort != null) {
        solrQuery.addSortField(sort, ORDER.asc);
      }
      solrQuery.setRequestHandler("/browse");
      response = server.query(solrQuery);
      docs = response.getResults();
      if (docs != null) {
        System.out.println(
            docs.getNumFound() + " documents found, " + docs.size() + " returned : ");
        setResultNumber(docs.getNumFound(), docs.size()); // 設定目前回傳幾筆資料給前端
        for (int i = 0; i < docs.size(); i++) {
          SolrDocument doc = docs.get(i);
          JSONObject jsonObject = new JSONObject();
          for (Iterator<Entry<String, Object>> it2 = doc.iterator(); it2.hasNext(); ) {
            Entry<String, Object> entry = it2.next();
            if (entry.getKey().equals("publishedDate")) { // 將傳回的date格式轉為純字串,方便前端呈現
              Date_format = entry.getValue().toString();
              jsonObject.put(entry.getKey(), Date_format);
            } else {
              // 一般情況
              jsonObject.put(entry.getKey(), entry.getValue());
            }
          }
          System.out.print("\n");
          // 將總共找到幾筆資料存在jsonarray的最後面傳給前端
          jsonObject.put("TotalResultFound", docs.getNumFound());
          jsonArray.add(jsonObject);
        }
      }

    } catch (SolrServerException e) {
      // TODO Auto-generated catch block
      e.printStackTrace();
    }
    return jsonArray;
  }
  @Test
  public void testFilenameNumberedDelimiterDash() throws Exception {
    SolrServer solr = getSolr();
    SolrInputDocument doc1 = new SolrInputDocument();
    doc1.addField("id", "1");
    doc1.addField("pathnamebase", "MAP-12345678");
    solr.add(doc1);
    SolrInputDocument doc2 = new SolrInputDocument();
    doc2.addField("id", "2");
    doc2.addField("pathnamebase", "TOP-12345678");
    solr.add(doc2);
    solr.commit();

    assertEquals(
        "exact match",
        1,
        solr.query(new SolrQuery("name:MAP-12345678")).getResults().getNumFound());
    assertEquals(
        "exact match",
        1,
        solr.query(new SolrQuery("name:TOP-12345678")).getResults().getNumFound());
    // split on dash
    assertEquals(
        "split on dash", 1, solr.query(new SolrQuery("name:TOP")).getResults().getNumFound());
    assertEquals(
        "split on dash", 2, solr.query(new SolrQuery("name:12345678")).getResults().getNumFound());
    assertEquals(
        "split on dash",
        1,
        solr.query(new SolrQuery("name:TOP 12345678")).getResults().getNumFound());
  }
  @Test
  public void testFulltextSearchNumbersHyphen() throws Exception {
    SolrServer solr = getSolr();
    SolrInputDocument doc = new SolrInputDocument();
    doc.addField("id", "1");
    doc.addField("text", "word The SD-500 product");
    solr.add(doc);
    solr.commit();

    assertEquals(
        "Should match simple word",
        1,
        solr.query(new SolrQuery("text:word")).getResults().getNumFound());
    assertEquals(
        "Should match exact product",
        1,
        solr.query(new SolrQuery("text:SD-500")).getResults().getNumFound());
    assertEquals(
        "Should match exact product lowercase",
        1,
        solr.query(new SolrQuery("text:sd-500")).getResults().getNumFound());

    // With hyphen also the StandardTokenizer will split.
    assertEquals(
        "Could match part 1", 1, solr.query(new SolrQuery("text:SD")).getResults().getNumFound());
    assertEquals(
        "Could match part 2", 1, solr.query(new SolrQuery("text:500")).getResults().getNumFound());

    assertEquals(
        "Could match quoted context",
        1,
        solr.query(new SolrQuery("text:\"The SD-500 product\"")).getResults().getNumFound());
  }
  private SolrServer createServerAndTableWithSimpleTestDoc(String table)
      throws BlurException, TException, IOException, SolrServerException {
    createTable(table);
    SolrServer server = new SolrLookingBlurServer(miniCluster.getControllerConnectionStr(), table);
    SolrInputDocument doc;

    doc = createSimpleTestDoc();

    server.add(doc);
    return server;
  }
예제 #21
0
 /**
  * Execute a search query
  *
  * @param solrQuery The solr query to perform
  * @param hasFacet Indicates whether the solr query has facets
  * @return The search result
  * @throws SolrServerException
  */
 private SolrSearchResult executeSearch(SolrQuery solrQuery, boolean hasFacet)
     throws SolrServerException {
   LOGGER.debug("Query to send to Solr: {}", solrQuery.toString());
   SolrServer solrServer = SolrManager.getInstance().getSolrServer();
   QueryResponse queryResponse = solrServer.query(solrQuery);
   if (hasFacet) {
     return new SolrSearchResult(queryResponse.getResults(), queryResponse.getFacetFields());
   } else {
     return new SolrSearchResult(queryResponse.getResults());
   }
 }
예제 #22
0
 /**
  * delete
  *
  * <p>Set the status of the given object to deleted
  *
  * @param fedoraObject The fedora object
  * @throws FedoraClientException
  */
 public void delete(FedoraObject fedoraObject) throws FedoraClientException {
   FedoraBroker.updateObjectState(fedoraObject.getObject_id(), "D");
   // Add this as a work around for the fact that commitWithin does not seem to work for
   // the Solr XML delete so we want to commit after delete
   SolrServer solrServer = SolrManager.getInstance().getSolrServer();
   try {
     solrServer.deleteById(fedoraObject.getObject_id(), 5000);
   } catch (IOException e) {
     LOGGER.debug("Exception committing delete", e);
   } catch (SolrServerException e) {
     LOGGER.debug("Exception committing delete", e);
   }
 }
예제 #23
0
  public static void cache(String queryId, Object obj, SolrServer server, boolean commit)
      throws IOException, SolrServerException {
    SolrInputDocument newDoc = new SolrInputDocument();
    newDoc.addField(Constants.CACHE_INDEX_idFieldName, queryId);
    newDoc.addField(Constants.CACHE_INDEX_valueFieldName, SerializableUtils.serializeBase64(obj));
    // newDoc.addField(valueTextFieldName, ojbectToString(obj));

    if (server == null) {
      throw new SolrServerException("server IS NULL!");
    }
    server.add(newDoc);
    if (commit) server.commit();
  }
예제 #24
0
  @Test
  public void test2() throws Exception {
    SolrInputDocument doc = new SolrInputDocument();
    // ID
    doc.setField("id", "3");
    // 名称
    doc.setField("name", "何灵");

    // 添加
    solrServer.add(doc);
    // 提交
    solrServer.commit();
  }
 @Override
 public void delete(String id) {
   try {
     SolrServer server = SolrServerManager.getInstance().getSolrServer();
     deleteRecordInSolr(server, id);
     server.commit();
   } catch (SolrServerException e) {
     LOG.info("Exception :", e);
     throw new DocstoreIndexException();
   } catch (IOException e) {
     LOG.info("Exception :", e);
     throw new DocstoreIndexException();
   }
 }
예제 #26
0
  public void delete(Object entity) {
    if (!(entity instanceof AbstractEntity)) {
      return;
    }

    try {
      solrServer.deleteById(((AbstractEntity) entity).getId());
      solrServer.commit();
    } catch (SolrServerException e) {
      throw new RuntimeException(e);
    } catch (IOException e) {
      throw new RuntimeException(e);
    }
  }
  @Test
  public void testFulltextSearchEmail() throws Exception {
    SolrServer solr = getSolr();
    SolrInputDocument doc = new SolrInputDocument();
    doc.addField("id", "1");
    doc.addField("text", "contact [email protected]");
    solr.add(doc);
    solr.commit();

    assertEquals(
        "Should match simple word",
        1,
        solr.query(new SolrQuery("text:contact")).getResults().getNumFound());
    // Likely NOT possible with WDF in index pipeline.
    assertEquals(
        "Should match exact email",
        1,
        solr.query(new SolrQuery("text:[email protected]")).getResults().getNumFound());
    assertEquals(
        "Should match exact email - Quoted",
        1,
        solr.query(new SolrQuery("text:\"[email protected]\"")).getResults().getNumFound());

    assertEquals(
        "Could match part 1",
        1,
        solr.query(new SolrQuery("text:support")).getResults().getNumFound());
    assertEquals(
        "Could match part 2",
        1,
        solr.query(new SolrQuery("text:example.com")).getResults().getNumFound());
  }
예제 #28
0
  @Test
  public void test1() throws Exception {
    String baseURL = "http://192.168.19.128:8080/solr";

    SolrServer solr = new HttpSolrServer(baseURL);
    SolrInputDocument doc = new SolrInputDocument();

    doc.setField("id", "2");
    doc.setField("name", "kobe");

    solr.add(doc);
    // 提交
    solr.commit();
  }
예제 #29
0
  @Override
  // Input Map is expected to have the suffixes on the key names
  public void add(String type, Map<String, Object> properties) throws PersistenceException {
    LOGGER.debug("type = {}", type);
    if (type == null || type.isEmpty()) {
      return;
    }
    if (properties == null || properties.isEmpty() || properties.containsValue("guest")) {
      return;
    }

    LOGGER.debug("Adding entry of type {}", type);

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

    Date now = new Date();
    // DateFormat df = new SimpleDateFormat("yyyy-MM-dd'T'HH:mm:ssZ");
    // String createdDate = df.format(now);

    SolrInputDocument solrInputDocument = new SolrInputDocument();
    solrInputDocument.addField("createddate_tdt", now);

    for (Map.Entry<String, Object> entry : properties.entrySet()) {
      solrInputDocument.addField(entry.getKey(), entry.getValue());
    }

    try {
      UpdateResponse response = coreSolrServer.add(solrInputDocument);
      LOGGER.debug("UpdateResponse from add of SolrInputDocument:  {}", response);
    } catch (SolrServerException e) {
      LOGGER.info("SolrServerException while adding Solr index for persistent type {}", type, e);
      doRollback(coreSolrServer, type);
      throw new PersistenceException(
          "SolrServerException while adding Solr index for persistent type " + type, e);
    } catch (IOException e) {
      LOGGER.info("IOException while adding Solr index for persistent type {}", type, e);
      doRollback(coreSolrServer, type);
      throw new PersistenceException(
          "IOException while adding Solr index for persistent type " + type, e);
    } catch (RuntimeException e) {
      LOGGER.info("RuntimeException while adding Solr index for persistent type {}", type, e);
      doRollback(coreSolrServer, type);
      throw new PersistenceException(
          "RuntimeException while adding Solr index for persistent type " + type, e);
    }
  }
예제 #30
0
  protected void execute() throws Exception {

    SolrServer server = new HttpSolrServer("http://localhost:8983/solr");
    SolrQuery query = new SolrQuery("text:ipod");
    QueryResponse response = server.query(query);

    SolrDocumentList docList = response.getResults();
    System.out.println("件数:" + docList.size());
    for (SolrDocument doc : docList) {
      System.out.println("■");
      for (String fieldName : doc.getFieldNames()) {
        System.out.println(fieldName.toString() + ":" + doc.getFieldValue(fieldName.toString()));
      }
    }
  }