solr在使用solrj操作中的各个操作大全（在solrcores中测试）(转自：http://blog.csdn.net/a925907195/article/details/42491157)

package com.fjsh.SearchJobsFirst;  

import java.text.SimpleDateFormat;
import java.util.Calendar;
import java.util.Date;
import java.util.GregorianCalendar;
import java.util.HashMap;
import java.util.Iterator;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;  

import javax.swing.RepaintManager;
import javax.swing.text.html.parser.Entity;  

import org.apache.solr.client.solrj.SolrQuery;
import org.apache.solr.client.solrj.SolrServer;
import org.apache.solr.client.solrj.SolrServerException;
import org.apache.solr.client.solrj.impl.HttpSolrServer;
import org.apache.solr.client.solrj.response.FacetField;
import org.apache.solr.client.solrj.response.FacetField.Count;
import org.apache.solr.client.solrj.response.Group;
import org.apache.solr.client.solrj.response.GroupCommand;
import org.apache.solr.client.solrj.response.GroupResponse;
import org.apache.solr.client.solrj.response.QueryResponse;
import org.apache.solr.common.SolrDocument;
import org.apache.solr.common.SolrDocumentList;
import org.apache.solr.common.params.GroupParams;
import org.apache.solr.common.params.ModifiableSolrParams;

/**
* @Project JobsOtherWebSearch
* @Package com.fjsh.SearchJobsFirst
* @ClassName: SearchJobs
* @Author fjsh
* @Description: 对solr中的各个功能进行测试
* @Date 2014-3-5 下午3:38:09
*/
public class SearchJobs {
private static String url = "jdbc:sqlserver://192.168.2.106:1433;DatabaseName=JobsOtherweb51jobDB";
private static String user = "sa";
private static String password = "sa";
private String Corenum;
public static int JobsId = 219443;// start jobsid
public SolrServer solrServer = null;// new
// HttpSolrServer("http://192.168.2.100:8080/solr/JobsOtherWeb1");
// 1、创建solrserver对象：
public SolrServer createSolrServer() {
HttpSolrServer solr = null;
try {
solr = new HttpSolrServer(
"http://192.168.2.106:8080/solr/JobsOtherWeb0");
solr.setConnectionTimeout(100);
solr.setDefaultMaxConnectionsPerHost(100);
solr.setMaxTotalConnections(100);
} catch (Exception e) {
System.out.println("请检查tomcat服务器或端口是否开启!");
e.printStackTrace();
}
return solr;
}
// 简单的查询，取出二十个
public void querytop20() {
solrServer = createSolrServer();
System.out.println("简单查询取出前二十个");
String dtStart = new SimpleDateFormat("yyyyMMddHHmmssSSS")
.format(new Date());
System.out.println("开始时间：" + dtStart + "\n");
try {
SolrQuery query = new SolrQuery();// 查询
query.setQuery("jobsName:计算机");
query.setRows(20);
SolrDocumentList docs = solrServer.query(query).getResults();
for (SolrDocument sd : docs) {
System.out.println(sd.getFieldValue("jobsName"));
System.out.println(sd.getFieldValue("publishDate"));
}
solrServer.shutdown();
String dtEnd = new SimpleDateFormat("yyyyMMddHHmmssSSS")
.format(new Date());
System.out.println(query);
} catch (SolrServerException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
// 删除索引
// 据查询结果删除：
public void DeleteByQuery() {
solrServer = createSolrServer();
try {
// 删除所有的索引
solrServer.deleteByQuery("jobsName:高级技术支持");
solrServer.commit();
} catch (Exception e) {
e.printStackTrace();
}
}
// 根据索引号删除索引：
public void DeleteByQueryJobsId() {
solrServer = createSolrServer();
try {
solrServer.deleteById("515792");
solrServer.commit();
} catch (Exception e) {
e.printStackTrace();
}
}
// 查询
// SolrJ提供的查询功能比较强大，可以进行结果中查询、范围查询、排序等。
// 补充一下范围查询的格式：[star t TO end]，start与end是相应数据格式的值的字符串形式，“TO” 一定要保持大写！
/*
* field 查询的字段名称数组 key 查询的字段名称对应的值 start 查询的起始位置 count 一次查询出来的数量 sortfield
* 需要排序的字段数组 flag 需要排序的字段的排序方式如果为true 升序如果为false 降序 hightlight 是否需要高亮显示
*/
public QueryResponse Search(String[] field, String[] key, int start,
int count, String[] sortfield, Boolean[] flag, Boolean hightlight) {
solrServer = createSolrServer();
// 检测输入是否合法
if (null == field || null == key || field.length != key.length) {
return null;
}
if (null == sortfield || null == flag
|| sortfield.length != flag.length) {
return null;
}
SolrQuery query = null;
try {
// 初始化查询对象
query = new SolrQuery(field[0] + ":" + key[0]);
for (int i = 0; i < field.length; i++) {
query.addFilterQuery(field[i] + ":" + key[i]);
}
// 设置起始位置与返回结果数
query.setStart(start);
query.setRows(count);
// 设置排序
for (int i = 0; i < sortfield.length; i++) {
if (flag[i]) {
query.addSortField(sortfield[i], SolrQuery.ORDER.asc);
} else {
query.addSortField(sortfield[i], SolrQuery.ORDER.desc);
}
}
// 设置高亮
if (null != hightlight) {
query.setHighlight(true); // 开启高亮组件
query.addHighlightField("jobsName");// 高亮字段
query.setHighlightSimplePre("<font color=\"red\">");// 标记
query.setHighlightSimplePost("</font>");
query.setHighlightSnippets(1);// 结果分片数，默认为1
query.setHighlightFragsize(1000);// 每个分片的最大长度，默认为100
}
} catch (Exception e) {
e.printStackTrace();
}
QueryResponse rsp = null;
try {
rsp = solrServer.query(query);
} catch (Exception e) {
e.printStackTrace();
return null;
}
// 返回查询结果
return rsp;
}
// Facet的一个应用：自动补全
// prefix为前缀，min为最大返回结果数
// field需要查询并返回不全的字段，prefix需要查询并返回的字段不全值
public String[] autoComplete(String field, String prefix, int min) {
/*------------第一处标记------------------------*/
solrServer = createSolrServer();
String words[] = null;
StringBuffer sb = new StringBuffer("");
SolrQuery query = new SolrQuery(field + ":" + prefix);
QueryResponse rsp = new QueryResponse();
// Facet为solr中的层次分类查询
/*------------第二处标记：程序从第一处标记执行到这里需要300ms所以将上面的代码进行实例化最好------------------------*/
try {
query.setFacet(true);
// query.setQuery("*:*");
query = new SolrQuery(field + ":" + prefix);
query.setFacetPrefix(prefix);
query.addFacetField(field);
rsp = solrServer.query(query);
/*------------第三处标记：程序从第二处标记执行到这里需要200ms但此处很难再进行优化，由于查询的复杂性------------------------*/
} catch (Exception e) {
// TODO: handle exception
e.printStackTrace();
return null;
}
if (null != rsp) {
FacetField ff = rsp.getFacetField(field);
List<Count> countList = ff.getValues();
if (null == countList) {
return null;
}
for (int i = 0; i < countList.size(); i++) {
String tmp[] = countList.get(i).toString().split(" ");
// 排除单个字
if (tmp[0].length() < 2) {
continue;
}
sb.append(tmp[0] + " ");
min--;
if (min == 0) {
break;
}
}
words = sb.toString().split(" ");
} else {
return null;
}
return words;
}
/**
* @Author fjsh
* @Title SearchGroup
* @Description 按group进行查找
* @param QUERY_CONTENT 查询内容
* @param QUERY_ROWS 查找的数量,默认是10
* @param GROUP true or false 是否按group查询
* @param GROUP_FIELD 查询field
* @param GROUP_LIMIT The number of results (documents) to return for each group. Defaults to 1
* @Return void
* @Throws
* @Date 2014-5-7
* 输出结果的时候，由于定义的数据索引没有做很好是调整，显示的结果并不理想，不过此方法可以作为参考
*/
public void SearchGroup(String QUERY_CONTENT,int QUERY_ROWS, Boolean GROUP, String GROUP_FIELD,String GROUP_LIMIT) {
SolrServer server = createSolrServer();
SolrQuery param = new SolrQuery();
param.setQuery("jobsName:"+QUERY_CONTENT);
param.setRows(QUERY_ROWS);
param.setParam(GroupParams.GROUP, GROUP);
param.setParam(GroupParams.GROUP_FIELD, GROUP_FIELD);
param.setParam(GroupParams.GROUP_LIMIT, GROUP_LIMIT);
QueryResponse response = null;
try {
response = server.query(param);
} catch (SolrServerException e) {
// logger.error(e.getMessage(), e);
}
Map<String, Integer> info = new HashMap<String, Integer>();
GroupResponse groupResponse = response.getGroupResponse();
if(groupResponse != null) {
List<GroupCommand> groupList = groupResponse.getValues();
for(GroupCommand groupCommand : groupList) {
List<Group> groups = groupCommand.getValues();
for(Group group : groups) {
info.put(group.getGroupValue(), (int)group.getResult().getNumFound());
System.out.println(group.getGroupValue()+"---"+group.getResult().getNumFound());
}
}
}
}
/*
* 介绍了一下facet之后，来说说怎么实现facet。facet的实现其实很简单，主要在搜索参数上带上就OK。
*
* facet=on/true #代表开启facet facet.field=cate #代表要统计的面（分组），比如上面的分类，品牌，可以多次出现
* facet.limit =20 #每个分组最多返回条数 facet.mincount = 1 #这个表示分组下某一条目的最小数据量
* facet.missing = on/true #统计null的值 facet.method = #默认为fc, fc表示Field Cache
* 比如
* ：http://localhost/product/select/?q=铁观音&facet=on&facet.field=category&facet
* .field=brand&facet.mincount=1在搜索结果中返回xml的facet结果
*
*
* view sourceprint? 01 <lst name="facet_counts"> 02 <lst
* name="facet_queries"/> 03 <lst name="facet_fields"> 04 <lst
* name="category"> 05 <int name="2742">64</int> 06 <int name="793">48</int>
* 07 <int name="2741">12</int> 08 <int name="801">6</int> 09 <int
* name="1087">1</int> 10 </lst> 11 <lst name="brand"> 12 <int
* name="229">74</int> 13 <int name="227">16</int> 14 <int
* name="270">13</int> 15 <int name="317">10</int> 16 <int name="0">4</int>
* 17 <int name="165">4</int> 18 <int name="203">3</int> 19 <int
* name="147">2</int> 20 <int name="166">2</int> 21 <int name="217">1</int>
* 22 <int name="342">1</int> 23 <int name="343">1</int> 24 </lst> 25 </lst>
* <lst name="category"> 分组名 <int name="2742">64</int>
* 分组内条目，name表示条目，64是统计结果数。
*
*
*
*
* Date Facet 日期类型的字段在文档中很常见 , 如商品上市时间 , 货物出仓时间 , 书籍上架时间等等 . 某些情况下需要针对这些字段进行
* Facet. 不过时间字段的取值有无限性 , 用户往往关心的不是某个时间点而是某个时间段内的查询统计结果 . Solr
* 为日期字段提供了更为方便的查询统计方式 . 当然 , 字段的类型必须是 DateField( 或其子类型 ). 需要注意的是 , 使用 Date
* Facet 时 , 字段名 , 起始时间 , 结束时间 , 时间间隔这 4 个参数都必须提供 . 与 Field Facet 类似 ,Date
* Facet 也可以对多个字段进行 Facet. 并且针对每个字段都可以单独设置参数 . 2.1 facet.date 该参数表示需要进行 Date
* Facet 的字段名 , 与 facet.field 一样 , 该参数可以被设置多次 , 表示对多个字段进行 Date Facet. 2.2
* facet.date.start 起始时间 , 时间的一般格式为 ” 1995-12-31T23:59:59Z”, 另外可以使用
* ”NOW”,”YEAR”,”MONTH” 等等 , 具体格式可以参考 org.apache.solr.schema. DateField 的
* java doc. 2.3 facet.date.end 结束时间 . 2.4 facet.date.gap 时间间隔 . 如果 start 为
* 2009-1-1,end 为 2010-1-1.gap 设置为 ”+1MONTH” 表示间隔 1 个月 , 那么将会把这段时间划分为 12
* 个间隔段 . 注意 ”+” 因为是特殊字符所以应该用 ”%2B” 代替 . 2.5 facet.date.hardend 取值可以为
* true|false, 默认为 false. 它表示 gap 迭代到 end 处采用何种处理 . 举例说明 start 为
* 2009-1-1,end 为 2009-12-25,gap 为 ”+1MONTH”,hardend 为 false 的话最后一个时间段为
* 2009-12-1 至 2010-1-1;hardend 为 true 的话最后一个时间段为 2009-12-1 至 2009-12-25.
* 2.6 facet.date.other 取值范围为 before|after|between|none|all, 默认为 none.
* before 会对 start 之前的值做统计 . after 会对 end 之后的值做统计 . between 会对 start 至 end
* 之间所有值做统计 . 如果 hardend 为 true 的话 , 那么该值就是各个时间段统计值的和 . none 表示该项禁用 . all 表示
* before,after,all 都会统计 . 举例 : &facet=on &facet.date=date
* &facet.date.start=2009-1-1T0:0:0Z &facet.date.end=2010-1-1T0:0:0Z
* &facet.date.gap=%2B1MONTH &facet.date.other=all
*/
public void FacetFieldQuery() throws Exception {
solrServer = createSolrServer();
SolrQuery query = new SolrQuery();// 建立一个新的查询
query.setQuery("jobsName:计算机维护");
query.setFacet(true);// 设置facet=on
// 分类信息分为：薪水，发布时间，教育背景，工作经验，公司类型，工作类型
query.addFacetField(new String[] { "salary", "publishDate",
"educateBackground", "jobExperience", "companytype", "jobsType" });// 设置需要facet的字段
query.setFacetLimit(10);// 限制facet返回的数量
query.setFacetMissing(false);// 不统计null的值
query.setFacetMinCount(1);// 设置返回的数据中每个分组的数据最小值，比如设置为1，则统计数量最小为1，不然不显示
// query.addFacetQuery("publishDate:[2014-04-11T00:00:00Z TO 2014-04-13T00:00:00Z]");
QueryResponse response = solrServer.query(query);
System.out.println("查询时间：" + response.getQTime());
List<FacetField> facets = response.getFacetFields();// 返回的facet列表
for (FacetField facet : facets) {
System.out.println(facet.getName());
System.out.println("----------------");
List<Count> counts = facet.getValues();
for (Count count : counts) {
System.out.println(count.getName() + ":" + count.getCount());
}
System.out.println();
}
}
// 时间片使用方法
public void FacetFieldQueryDate() throws Exception {
solrServer = createSolrServer();
SolrQuery query = new SolrQuery();// 建立一个新的查询
query.setQuery("jobsName:计算");
query.setFacet(true);// 设置facet=on
query.setFacetLimit(10);// 限制facet返回的数量
query.setFacetMissing(false);// 不统计null的值
query.setFacetMinCount(1);// 设置返回的数据中每个分组的数据最小值，比如设置为1，则统计数量最小为1，不然不显示
query.addFacetField(new String[] { "salary", "educateBackground",
"jobExperience", "companytype", "jobsType" });// 设置需要facet的字段
// query.addFacetQuery("publishDate:[2014-04-21T00:00:00Z TO 2014-04-23T00:00:00Z]");
// query.addFacetQuery("publishDate:[2014-04-11T00:00:00Z TO 2014-04-13T00:00:00Z]");
SimpleDateFormat time0 = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
SimpleDateFormat time1 = new SimpleDateFormat("yyyy-MM-dd");
SimpleDateFormat time2 = new SimpleDateFormat("HH:mm:ss");
// return
// date.getYear()+"-"+date.getMonth()+"-"+date.getDay()+"T"+date.getHours()+":"+date.getMinutes()+":"+date.getSeconds();
Calendar c = Calendar.getInstance();
c.setTime(time0.parse(time1.format(c.getTime()) + " 23:59:59"));
Date date = c.getTime();
String dateNow = time1.format(date) + "T" + time2.format(date) + "Z";
c.setTime(time0.parse(time1.format(c.getTime()) + " 23:59:59"));
c.add(Calendar.DATE, -1);
date = c.getTime();
// 当天
query.addFacetQuery("publishDate:[" + time1.format(date) + "T"
+ time2.format(date) + "Z" + " TO " + dateNow + "]");
c.add(Calendar.DATE, -2);
date = c.getTime();
// 前三天
query.addFacetQuery("publishDate:[" + time1.format(date) + "T"
+ time2.format(date) + "Z" + " TO " + dateNow + "]");
c.add(Calendar.DATE, -4);
date = c.getTime();
// 前一周
query.addFacetQuery("publishDate:[" + time1.format(date) + "T"
+ time2.format(date) + "Z" + " TO " + dateNow + "]");
c.add(Calendar.DATE, -7);
date = c.getTime();
// 前两周
query.addFacetQuery("publishDate:[" + time1.format(date) + "T"
+ time2.format(date) + "Z" + " TO " + dateNow + "]");
c.add(Calendar.DATE, -16);
date = c.getTime();
// 前一个月
query.addFacetQuery("publishDate:[" + time1.format(date) + "T"
+ time2.format(date) + "Z" + " TO " + dateNow + "]");
c.add(Calendar.DATE, -30);
date = c.getTime();
// 前两个月
query.addFacetQuery("publishDate:[" + time1.format(date) + "T"
+ time2.format(date) + "Z" + " TO " + dateNow + "]");
QueryResponse response = solrServer.query(query);
System.out.println("查询时间：" + response.getQTime());
List<FacetField> facets = response.getFacetFields();// 返回的facet列表
for (FacetField facet : facets) {
System.out.println(facet.getName());
System.out.println("----------------");
List<Count> counts = facet.getValues();
for (Count count : counts) {
System.out.println(count.getName() + ":" + count.getCount());
}
System.out.println();
}
// 根据时间段来获取数据
Map<String, Integer> maps = response.getFacetQuery();
for (Entry<String, Integer> entry : maps.entrySet()) {
System.out.println(entry.getKey() + ":" + entry.getValue());
}
}
// 最终使用的查询方式
// SolrJ提供的查询功能比较强大，可以进行结果中查询、范围查询、排序等。
// 补充一下范围查询的格式：[star t TO end]，start与end是相应数据格式的值的字符串形式，“TO” 一定要保持大写！
/*
* field 查询的字段名称数组 key 查询的字段名称对应的值 start 查询的起始位置 count 一次查询出来的数量 sortfield
* 需要排序的字段数组 flag 需要排序的字段的排序方式如果为true 升序如果为false 降序 hightlight 是否需要高亮显示
*/
public QueryResponse searchResult(String[] field, String[] key, int start,
int count, String[] sortfield, Boolean[] flag, Boolean hightlight)
throws Exception {
solrServer = createSolrServer();
// 检测输入是否合法
if (null == field || null == key || field.length != key.length) {
return null;
}
SolrQuery query = null;
try {
// 初始化查询对象
query = new SolrQuery(field[0] + ":" + key[0]);
for (int i = 0; i < field.length; i++) {
query.addFilterQuery(field[i] + ":" + key[i]);
}
// 设置起始位置与返回结果数
query.setStart(start);
query.setRows(count);
// 设置排序
if (!(null == sortfield || null == flag
|| sortfield.length != flag.length)) {
for (int i = 0; i < sortfield.length; i++) {
if (flag[i]) {
query.addSortField(sortfield[i], SolrQuery.ORDER.asc);
} else {
query.addSortField(sortfield[i], SolrQuery.ORDER.desc);
}
}
}
// 设置高亮
if (null != hightlight) {
query.setHighlight(true); // 开启高亮组件
query.addHighlightField("jobsName");// 高亮字段
query.setHighlightSimplePre("<font color=\"red\">");// 标记
query.setHighlightSimplePost("</font>");
query.setHighlightSnippets(1);// 结果分片数，默认为1
query.setHighlightFragsize(1000);// 每个分片的最大长度，默认为100
}
} catch (Exception e) {
e.printStackTrace();
}
query.setFacet(true);// 设置facet=on
query.setFacetLimit(10);// 限制facet返回的数量
query.setFacetMissing(false);// 不统计null的值
query.setFacetMinCount(1);// 设置返回的数据中每个分组的数据最小值，比如设置为1，则统计数量最小为1，不然不显示
query.addFacetField(new String[] { "salary", "educateBackground",
"jobExperience", "companytype", "jobsType" });// 设置需要facet的字段
// query.addFacetQuery("publishDate:[2014-04-21T00:00:00Z TO 2014-04-23T00:00:00Z]");
// query.addFacetQuery("publishDate:[2014-04-11T00:00:00Z TO 2014-04-13T00:00:00Z]");
SimpleDateFormat time0 = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
SimpleDateFormat time1 = new SimpleDateFormat("yyyy-MM-dd");
SimpleDateFormat time2 = new SimpleDateFormat("HH:mm:ss");
// return
// date.getYear()+"-"+date.getMonth()+"-"+date.getDay()+"T"+date.getHours()+":"+date.getMinutes()+":"+date.getSeconds();
Calendar c = Calendar.getInstance();
c.setTime(time0.parse(time1.format(c.getTime()) + " 23:59:59"));
Date date = c.getTime();
String dateNow = time1.format(date) + "T" + time2.format(date) + "Z";
c.setTime(time0.parse(time1.format(c.getTime()) + " 23:59:59"));
c.add(Calendar.DATE, -1);
date = c.getTime();
// 当天
query.addFacetQuery("publishDate:[" + time1.format(date) + "T"
+ time2.format(date) + "Z" + " TO " + dateNow + "]");
c.add(Calendar.DATE, -2);
date = c.getTime();
// 前三天
query.addFacetQuery("publishDate:[" + time1.format(date) + "T"
+ time2.format(date) + "Z" + " TO " + dateNow + "]");
c.add(Calendar.DATE, -4);
date = c.getTime();
// 前一周
query.addFacetQuery("publishDate:[" + time1.format(date) + "T"
+ time2.format(date) + "Z" + " TO " + dateNow + "]");
c.add(Calendar.DATE, -7);
date = c.getTime();
// 前两周
query.addFacetQuery("publishDate:[" + time1.format(date) + "T"
+ time2.format(date) + "Z" + " TO " + dateNow + "]");
c.add(Calendar.DATE, -16);
date = c.getTime();
// 前一个月
query.addFacetQuery("publishDate:[" + time1.format(date) + "T"
+ time2.format(date) + "Z" + " TO " + dateNow + "]");
c.add(Calendar.DATE, -30);
date = c.getTime();
// 前两个月
query.addFacetQuery("publishDate:[" + time1.format(date) + "T"
+ time2.format(date) + "Z" + " TO " + dateNow + "]");
QueryResponse rsp = null;
try {
rsp = solrServer.query(query);
System.out.println("此次查询时间qtime :" + rsp.getQTime());
List<FacetField> facets = rsp.getFacetFields();// 返回的facet列表
for (FacetField facet : facets) {
System.out.println(facet.getName());
System.out.println("----------------");
List<Count> counts = facet.getValues();
for (Count countitem : counts) {
System.out.println(countitem.getName() + ":"
+ countitem.getCount());
}
System.out.println();
}
// 根据时间段来获取数据
Map<String, Integer> maps = rsp.getFacetQuery();
for (Entry<String, Integer> entry : maps.entrySet()) {
System.out.println(entry.getKey() + ":" + entry.getValue());
}
// 获取返回的结果
SolrDocumentList docs = rsp.getResults();
for (SolrDocument doc : docs) {
System.out.println("-----");
System.out.println(doc.getFieldValue("jobsName"));
System.out.println(doc.getFieldValue("publishDate"));
}
} catch (Exception e) {
e.printStackTrace();
return null;
}
// 返回查询结果
return rsp;
}
}

时间： 2024-04-20 21:26:58

solr在使用solrj操作中的各个操作大全（在solrcores中测试）(转自：http://blog.csdn.net/a925907195/article/details/42491157)的相关文章

solr教程，值得刚接触搜索开发人员一看(转载：http://blog.csdn.net/awj3584/article/details/16963525)

Solr调研总结开发类型全文检索相关开发 Solr版本 4.2 文件内容本文介绍solr的功能使用及相关注意事项;主要包括以下内容:环境搭建及调试;两个核心配置文件介绍;维护索引;查询索引,和在查询中可以应用的高亮显示.拼写检查.搜索建议.分组统计.拼音检索等功能的使用方法. 版本作者/修改人日期 V1.0 gzk 2013-06-04 1. Solr 是什么? Solr它是一种开放源码的.基于 Lucene Java 的搜索服务器,易于加入到 Web 应用程序中.Solr 提供了层面

Hive分区、分桶操作及其比较（转自：http://blog.csdn.net/epitomizelu/article/details/41911657）

1,Hive分区. 是指按照数据表的某列或某些列分为多个区,区从形式上可以理解为文件夹,比如我们要收集某个大型网站的日志数据,一个网站每天的日志数据存在同一张表上,由于每天会生成大量的日志,导致数据表的内容巨大,在查询时进行全表扫描耗费的资源非常多.那其实这个情况下,我们可以按照日期对数据表进行分区,不同日期的数据存放在不同的分区,在查询时只要指定分区字段的值就可以直接从该分区查找. 下面从用shell命令操作分区表和从hdfs文件系统查看分区表相结合的方式加深对分区表的认识. 第一,

Solr所有的查询解析器Query Parsers（转：http://blog.csdn.net/jiangchao858/article/details/53859731）

摘要: Solr除了支持常见的解析器之外,还有一些特殊用途的解析器,为了便于之后查阅,总结一下.本文整理自Solr官方文档. 解析器说明 Standard Query Parser Solr的标准查询解析器Standard Query Parser DisMax Query Parser Solr的查询解析器DisMax Query Parser Extended DisMax Query Parser Solr的查询解析器The Extended DisMax Query Parser Bl

ias指令集-IAS的指令集操作中地址修改操作STOR M（x，）

问题描述 IAS的指令集操作中地址修改操作STOR M(x,) 向量A,B,C的起始地址分别为,1001,2001,3001.做A(i)+B(i)=C(i)的计算i从1到1000.代码如下,但是从7R开始有些困惑,为什么执行完Add M(2)后,累加器AC的地址就变成1002,而不是1001呢?(感觉add M(1)是AC的地址是1呀) Location Instruction Comments 0 999 Constant (count N) 1 1 Constant 2 1000 Const

java文件操作大全

java文件操作大全文件的建立/检查与删除<%@ page contentType="text/html;charset=gb2312"%><%@ page import="java.io.*"%><html><head><title>文件的建立.检查与删除</title></head><body><%String path=request.getRealPath

win8.1update快捷键操作大全

win8.1update快捷键操作大全: 一.功能篇: • Win+T:实时显示任务栏 • 空格键:在Modern开始屏幕支持显示Modern风格工具栏 • Alt+空格键:在Modern应用下调用标题栏菜单 • Win+C:打开Win8.1 Charm超级菜单 • Win+I:打开Modern电脑设置 • Win+K:打开"设备"功能 • Win+H:打开"共享"功能 • Win+P:打开"投影"功能二.操作篇: • Win+D:返回传

系统日志的编写-使用C#语言实现系统日志的记录，即把用户名及用户登录后的所有操作记录在数据库中。主要是怎么实

问题描述使用C#语言实现系统日志的记录,即把用户名及用户登录后的所有操作记录在数据库中.主要是怎么实使用C#语言实现系统日志的记录,即把用户名及用户登录后的所有操作记录在数据库中.主要是怎么实现? 解决方案有很多方法,比如直接就插入数据库,用aop日志框架,数据库用触发器等等. 解决方案二: 用log4Net就可以轻松实现你的要求!! 解决方案三: 是的,以上两种方法均可以,但是具体的点击某一个菜单,记录此操作的id等,有没有具体的代码实现的呀? 解决方案四: 建立一个日志表,使用inse

用java来操作mongoDB,备份mongDB中的数据

问题描述用java来操作mongoDB,备份mongDB中的数据 come on 大神如题现在想每个月把数据库中的数据导出来做备份 , 怎么用java语言来实现呢 ? 谢啦!!! 解决方案 omg 我在顶顶吧解决方案二: 写一个quartz的定时任务管理, 然后创建一个机遇每月月初几点几分执行的任务... 然后就是执行你需要的业务逻辑,如果比较复杂的话,就使用异步来实现. 最后记得生成一份日志或者报表用于查看数据备份后的一些结果输出信息... 大致的思路是这样的

重新想象 Windows 8 Store Apps (24) - 文件系统: Application Data 中的文件操作, Package 中的文件操作, 可移动存储中的文件操作

原文:重新想象 Windows 8 Store Apps (24) - 文件系统: Application Data 中的文件操作, Package 中的文件操作, 可移动存储中的文件操作 [源码下载] 重新想象 Windows 8 Store Apps (24) - 文件系统: Application Data 中的文件操作, Package 中的文件操作, 可移动存储中的文件操作作者:webabcd 介绍重新想象 Windows 8 Store Apps 之文件系统 Applicatio