├── ElasticSearch-SQL ├── .gitignore ├── bin │ └── .gitignore ├── .settings │ ├── org.eclipse.core.resources.prefs │ ├── org.eclipse.m2e.core.prefs │ └── org.eclipse.jdt.core.prefs ├── src │ └── com │ │ └── es │ │ ├── sql │ │ ├── parse │ │ │ ├── NoSqlParserException.java │ │ │ ├── DeleteSqlParser.java │ │ │ ├── UpdateSqlParser.java │ │ │ ├── InsertSqlParser.java │ │ │ ├── SelectSqlParser.java │ │ │ ├── Test.java │ │ │ ├── InsertSelectSqlParser.java │ │ │ ├── SqlParserUtil.java │ │ │ ├── SingleSqlParserFactory.java │ │ │ ├── BaseSingleSqlParser.java │ │ │ ├── SqlSegment.java │ │ │ └── QuerySqlParser.java │ │ ├── util │ │ │ ├── CommonConstant.java │ │ │ ├── RegexCheck.java │ │ │ ├── sql.txt │ │ │ ├── EsUtil.java │ │ │ ├── CommonUtils.java │ │ │ ├── Test.java │ │ │ └── SqlParser.java │ │ └── query │ │ │ ├── QueryHandler.java │ │ │ ├── SyntaxCheck.java │ │ │ ├── QuerySortHandler.java │ │ │ ├── WhereConditionHandler.java │ │ │ ├── QueryParserHandler.java │ │ │ ├── QueryAggregationHandler.java │ │ │ ├── AggregationResultParser.java │ │ │ ├── TestQuery.java │ │ │ └── QueryFilterHandler.java │ │ └── api │ │ └── test │ │ ├── BankMapping.java │ │ ├── BankContentIndex.java │ │ ├── SimpleMappingTest.java │ │ ├── BankTimeTest.java │ │ └── RoutingBankTest.java ├── .project ├── .classpath ├── pom.xml └── .classpath.bak ├── .gitignore └── README.md /ElasticSearch-SQL/.gitignore: -------------------------------------------------------------------------------- 1 | /target 2 | -------------------------------------------------------------------------------- /ElasticSearch-SQL/bin/.gitignore: -------------------------------------------------------------------------------- 1 | /com 2 | -------------------------------------------------------------------------------- /ElasticSearch-SQL/.settings/org.eclipse.core.resources.prefs: -------------------------------------------------------------------------------- 1 | eclipse.preferences.version=1 2 | encoding/=UTF-8 3 | encoding/src=UTF-8 4 | -------------------------------------------------------------------------------- /ElasticSearch-SQL/.settings/org.eclipse.m2e.core.prefs: -------------------------------------------------------------------------------- 1 | activeProfiles= 2 | eclipse.preferences.version=1 3 | resolveWorkspaceProjects=true 4 | version=1 5 | -------------------------------------------------------------------------------- /.gitignore: -------------------------------------------------------------------------------- 1 | *.class 2 | 3 | # Mobile Tools for Java (J2ME) 4 | .mtj.tmp/ 5 | 6 | # Package Files # 7 | *.jar 8 | *.war 9 | *.ear 10 | 11 | # virtual machine crash logs, see http://www.java.com/en/download/help/error_hotspot.xml 12 | hs_err_pid* 13 | -------------------------------------------------------------------------------- /ElasticSearch-SQL/src/com/es/sql/parse/NoSqlParserException.java: -------------------------------------------------------------------------------- 1 | package com.es.sql.parse; 2 | 3 | public class NoSqlParserException extends Exception { 4 | private static final long serialVersionUID = 1L; 5 | 6 | NoSqlParserException() { 7 | 8 | } 9 | 10 | NoSqlParserException(String sql) { 11 | // 调用父类方法 12 | super(sql); 13 | } 14 | } 15 | -------------------------------------------------------------------------------- /ElasticSearch-SQL/src/com/es/sql/parse/DeleteSqlParser.java: -------------------------------------------------------------------------------- 1 | package com.es.sql.parse; 2 | 3 | public class DeleteSqlParser extends BaseSingleSqlParser { 4 | public DeleteSqlParser(String originalSql) { 5 | super(originalSql); 6 | } 7 | 8 | @Override 9 | protected void initializeSegments() { 10 | segments.add(new SqlSegment("(delete from)(.+)( where | ENDOFSQL)", 11 | "[,]")); 12 | segments.add(new SqlSegment("(where)(.+)( ENDOFSQL)", "(and|or)")); 13 | } 14 | } 15 | -------------------------------------------------------------------------------- /ElasticSearch-SQL/src/com/es/sql/util/CommonConstant.java: -------------------------------------------------------------------------------- 1 | package com.es.sql.util; 2 | 3 | /** 4 | * 基础类 5 | * @author wangyong 6 | * 7 | */ 8 | public class CommonConstant { 9 | 10 | public enum Operator{ 11 | EQ,//= 12 | NOTIN,//not in 13 | IN,//in 14 | LIKE,//like 15 | NE,//!= 16 | LT,//< 17 | LTE,//<= 18 | GT,//> 19 | GTE,//>= 20 | RANGE 21 | } 22 | 23 | public enum DataType{ 24 | INT, 25 | STRING, 26 | DOUBLE, 27 | BOOLEAN 28 | } 29 | 30 | } 31 | -------------------------------------------------------------------------------- /ElasticSearch-SQL/src/com/es/sql/parse/UpdateSqlParser.java: -------------------------------------------------------------------------------- 1 | package com.es.sql.parse; 2 | 3 | public class UpdateSqlParser extends BaseSingleSqlParser { 4 | public UpdateSqlParser(String originalSql) { 5 | super(originalSql); 6 | } 7 | 8 | @Override 9 | protected void initializeSegments() { 10 | segments.add(new SqlSegment("(update)(.+)(set)", "[,]")); 11 | segments.add(new SqlSegment("(set)(.+)( where | ENDOFSQL)", "[,]")); 12 | segments.add(new SqlSegment("(where)(.+)( ENDOFSQL)", "(and|or)")); 13 | } 14 | } 15 | -------------------------------------------------------------------------------- /ElasticSearch-SQL/.project: -------------------------------------------------------------------------------- 1 | 2 | 3 | ElasticSearch-SQL 4 | 5 | 6 | 7 | 8 | 9 | org.eclipse.jdt.core.javabuilder 10 | 11 | 12 | 13 | 14 | org.eclipse.m2e.core.maven2Builder 15 | 16 | 17 | 18 | 19 | 20 | org.eclipse.m2e.core.maven2Nature 21 | org.eclipse.jdt.core.javanature 22 | 23 | 24 | -------------------------------------------------------------------------------- /ElasticSearch-SQL/src/com/es/sql/parse/InsertSqlParser.java: -------------------------------------------------------------------------------- 1 | package com.es.sql.parse; 2 | 3 | public class InsertSqlParser extends BaseSingleSqlParser { 4 | public InsertSqlParser(String originalSql) { 5 | super(originalSql); 6 | } 7 | 8 | @Override 9 | protected void initializeSegments() { 10 | segments.add(new SqlSegment("(insert into)(.+)([(])", "[,]")); 11 | segments.add(new SqlSegment("([(])(.+)( [)] values )", "[,]")); 12 | segments.add(new SqlSegment("([)] values [(])(.+)( [)])", "[,]")); 13 | } 14 | 15 | @Override 16 | public String getParsedSql() { 17 | String retval = super.getParsedSql(); 18 | retval = retval + ")"; 19 | return retval; 20 | } 21 | } -------------------------------------------------------------------------------- /ElasticSearch-SQL/.settings/org.eclipse.jdt.core.prefs: -------------------------------------------------------------------------------- 1 | eclipse.preferences.version=1 2 | org.eclipse.jdt.core.compiler.codegen.inlineJsrBytecode=enabled 3 | org.eclipse.jdt.core.compiler.codegen.targetPlatform=1.7 4 | org.eclipse.jdt.core.compiler.codegen.unusedLocal=preserve 5 | org.eclipse.jdt.core.compiler.compliance=1.7 6 | org.eclipse.jdt.core.compiler.debug.lineNumber=generate 7 | org.eclipse.jdt.core.compiler.debug.localVariable=generate 8 | org.eclipse.jdt.core.compiler.debug.sourceFile=generate 9 | org.eclipse.jdt.core.compiler.problem.assertIdentifier=error 10 | org.eclipse.jdt.core.compiler.problem.enumIdentifier=error 11 | org.eclipse.jdt.core.compiler.problem.forbiddenReference=warning 12 | org.eclipse.jdt.core.compiler.source=1.7 13 | -------------------------------------------------------------------------------- /ElasticSearch-SQL/src/com/es/sql/parse/SelectSqlParser.java: -------------------------------------------------------------------------------- 1 | package com.es.sql.parse; 2 | 3 | public class SelectSqlParser extends BaseSingleSqlParser { 4 | public SelectSqlParser(String originalSql) { 5 | super(originalSql); 6 | } 7 | 8 | @Override 9 | protected void initializeSegments() { 10 | segments.add(new SqlSegment("(select)(.+)(from)", "[,]")); 11 | segments.add(new SqlSegment( 12 | "(from)(.+)( where | on | having | group by | order by | ENDOFSQL)", 13 | "(,| left join | right join | inner join )")); 14 | segments.add(new SqlSegment( 15 | "(where|on|having)(.+)( group by | order by | ENDOFSQL)", 16 | "(and|or)")); 17 | segments.add(new SqlSegment("(group by)(.+)( order by| ENDOFSQL)", 18 | "[,]")); 19 | segments.add(new SqlSegment("(order by)(.+)( ENDOFSQL)", "[,]")); 20 | 21 | 22 | } 23 | } 24 | -------------------------------------------------------------------------------- /ElasticSearch-SQL/src/com/es/sql/parse/Test.java: -------------------------------------------------------------------------------- 1 | package com.es.sql.parse; 2 | 3 | public class Test { 4 | /** *//** 5 | * 单句Sql解析器制造工厂 6 | * @author 7 | * 8 | * @since 2013-6-10 9 | * @version 1.00 10 | */ 11 | public static void main(String[] args) { 12 | // TODO Auto-generated method stub 13 | //String test="select a from b " + 14 | // "\n"+"where a=b"; 15 | //test=test.replaceAll("\\s{1,}", " "); 16 | //System.out.println(test); 17 | //程序的入口 18 | String testSql="select c1,c2,c3 from t1,t2 where condi3=3 "+"\n"+" or condi4=5 order by o1,o2"; 19 | SqlParserUtil test=new SqlParserUtil(); 20 | String result=test.getParsedSql(testSql); 21 | System.out.println(result); 22 | //List result=test.getParsedSqlList(testSql);//保存解析结果 23 | } 24 | } 25 | -------------------------------------------------------------------------------- /ElasticSearch-SQL/src/com/es/sql/parse/InsertSelectSqlParser.java: -------------------------------------------------------------------------------- 1 | package com.es.sql.parse; 2 | 3 | public class InsertSelectSqlParser extends BaseSingleSqlParser { 4 | public InsertSelectSqlParser(String originalSql) { 5 | super(originalSql); 6 | } 7 | 8 | @Override 9 | protected void initializeSegments() { 10 | segments.add(new SqlSegment("(insert into)(.+)( select )", "[,]")); 11 | segments.add(new SqlSegment("(select)(.+)(from)", "[,]")); 12 | segments.add(new SqlSegment( 13 | "(from)(.+)( where | on | having | groups+by | orders+by | ENDOFSQL)", 14 | "(,|s+lefts+joins+|s+rights+joins+|s+inners+joins+)")); 15 | segments.add(new SqlSegment( 16 | "(where|on|having)(.+)( groups+by | orders+by | ENDOFSQL)", 17 | "(and|or)")); 18 | segments.add(new SqlSegment("(groups+by)(.+)( orders+by| ENDOFSQL)", 19 | "[,]")); 20 | segments.add(new SqlSegment("(orders+by)(.+)( ENDOFSQL)", "[,]")); 21 | } 22 | } 23 | -------------------------------------------------------------------------------- /ElasticSearch-SQL/.classpath: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10 | 11 | 12 | 13 | 14 | 15 | 16 | 17 | 18 | 19 | 20 | 21 | 22 | -------------------------------------------------------------------------------- /ElasticSearch-SQL/src/com/es/sql/parse/SqlParserUtil.java: -------------------------------------------------------------------------------- 1 | package com.es.sql.parse; 2 | 3 | import java.util.List; 4 | 5 | public class SqlParserUtil { 6 | /** */ 7 | /** 8 | * 　* 方法的主要入口　* @param sql:要解析的sql语句　* @return 返回解析结果　 9 | */ 10 | public String getParsedSql(String sql) { 11 | sql = sql.trim(); 12 | sql = sql.toLowerCase(); 13 | sql = sql.replaceAll("\\s{1,}", " "); 14 | sql = "" + sql + " ENDOFSQL"; 15 | // System.out.println(sql); 16 | return SingleSqlParserFactory.generateParser(sql).getParsedSql(); 17 | } 18 | 19 | /** */ 20 | /** 21 | * 　* SQL语句解析的接口　* @param sql:要解析的sql语句　* @return 返回解析结果　 22 | */ 23 | public List getParsedSqlList(String sql) { 24 | sql = sql.trim(); 25 | sql = sql.toLowerCase(); 26 | sql = sql.replaceAll("\\s{1,}", " "); 27 | sql = "" + sql + " ENDOFSQL"; 28 | // System.out.println(sql); 29 | return SingleSqlParserFactory.generateParser(sql).RetrunSqlSegments(); 30 | } 31 | } 32 | -------------------------------------------------------------------------------- /ElasticSearch-SQL/src/com/es/sql/query/QueryHandler.java: -------------------------------------------------------------------------------- 1 | package com.es.sql.query; 2 | 3 | public class QueryHandler { 4 | 5 | //--------------------------------------------------------------------- 6 | /** 7 | * select count(distinct who) as c from index.segment 8 | * where appid='x' and what='item' and ds between 2014-08-12 and 2014-08-13 9 | * and (kingdom in('1','2') or tz='+08') 10 | * group by ds,ip 11 | * order by c desc 12 | * limit 50 13 | */ 14 | //--------------------------------------------------------------------- 15 | /** 16 | * select sum(price) as total from index.segment 17 | * where appid='x' and what='item' and ds between 2014-08-12 and 2014-08-13 18 | * and (kingdom in('1','2') or tz='+08') 19 | * group by ds,ip 20 | * order by total desc 21 | * limit 100 22 | */ 23 | //--------------------------------------------------------------------- 24 | /** 25 | * select a,b,c,d from index.type 26 | * where e not in('1','2') and p != null and t='x' 27 | * order by a desc 28 | * limit 0,100 29 | */ 30 | //--------------------------------------------------------------------- 31 | /** 32 | * select * from index1,index2 where id=1 33 | * 34 | * select count(a),sum(b) from index 35 | * 36 | */ 37 | 38 | 39 | 40 | 41 | } 42 | -------------------------------------------------------------------------------- /ElasticSearch-SQL/src/com/es/sql/parse/SingleSqlParserFactory.java: -------------------------------------------------------------------------------- 1 | package com.es.sql.parse; 2 | 3 | import java.util.regex.Matcher; 4 | import java.util.regex.Pattern; 5 | 6 | public class SingleSqlParserFactory { 7 | public static BaseSingleSqlParser generateParser(String sql) { 8 | if (contains(sql, "(insert into)(.+)(select)(.+)(from)(.+)")) { 9 | return new InsertSelectSqlParser(sql); 10 | } else if (contains(sql, "(select)(.+)(from)(.+)")) { 11 | return new SelectSqlParser(sql); 12 | } else if (contains(sql, "(delete from)(.+)")) { 13 | return new DeleteSqlParser(sql); 14 | } else if (contains(sql, "(update)(.+)(set)(.+)")) { 15 | return new UpdateSqlParser(sql); 16 | } else if (contains(sql, "(insert into)(.+)(values)(.+)")) { 17 | return new InsertSqlParser(sql); 18 | } 19 | // sql=sql.replaceAll("ENDSQL", ""); 20 | else 21 | return new InsertSqlParser(sql); 22 | // throw new NoSqlParserException(sql.replaceAll("ENDOFSQL", 23 | // ""));//对异常的抛出 24 | } 25 | 26 | /** */ 27 | /** 28 | * 　* 看word是否在lineText中存在，支持正则表达式　* @param sql:要解析的sql语句　* @param 29 | * regExp:正则表达式　* @return 　 30 | */ 31 | private static boolean contains(String sql, String regExp) { 32 | Pattern pattern = Pattern.compile(regExp, Pattern.CASE_INSENSITIVE); 33 | Matcher matcher = pattern.matcher(sql); 34 | return matcher.find(); 35 | } 36 | } 37 | -------------------------------------------------------------------------------- /ElasticSearch-SQL/src/com/es/sql/util/RegexCheck.java: -------------------------------------------------------------------------------- 1 | package com.es.sql.util; 2 | 3 | import java.util.regex.Matcher; 4 | import java.util.regex.Pattern; 5 | 6 | import com.es.sql.util.CommonConstant.DataType; 7 | 8 | /** 9 | * 正则验证 10 | * @author wangyong 11 | * 12 | */ 13 | public class RegexCheck { 14 | 15 | /** 16 | * @param args 17 | */ 18 | public static void main(String[] args) { 19 | String str = "true"; 20 | System.out.println(getDataType(str)); 21 | } 22 | 23 | 24 | // 整数 25 | public static boolean isNumber(String str) { 26 | Pattern pattern = Pattern.compile("0|[1-9][0-9]*"); 27 | Matcher match = pattern.matcher(str); 28 | if (match.matches() == false) { 29 | return false; 30 | } else { 31 | return true; 32 | } 33 | } 34 | 35 | //小数 36 | public static boolean isDouble(String str) { 37 | Pattern pattern = Pattern.compile("[0-9]+.[0-9]{1,6}"); 38 | Matcher match = pattern.matcher(str); 39 | if (match.matches() == false) { 40 | return false; 41 | } else { 42 | return true; 43 | } 44 | } 45 | public static boolean isBoolean(String str) { 46 | Pattern pattern = Pattern.compile("(true|false)"); 47 | Matcher match = pattern.matcher(str); 48 | if (match.matches() == false) { 49 | return false; 50 | } else { 51 | return true; 52 | } 53 | } 54 | //字符 55 | public static boolean isString(String str) { 56 | if(str.startsWith("'") ||str.startsWith("\"")){ 57 | return true; 58 | }else{ 59 | return false; 60 | } 61 | } 62 | 63 | public static DataType getDataType(String str){ 64 | if(isString(str)){ 65 | return DataType.STRING; 66 | }else if(isNumber(str)){ 67 | return DataType.INT; 68 | }else if(isDouble(str)){ 69 | return DataType.DOUBLE; 70 | }else if(isBoolean(str)){ 71 | return DataType.BOOLEAN; 72 | }else{ 73 | return DataType.STRING; 74 | } 75 | } 76 | } 77 | -------------------------------------------------------------------------------- /ElasticSearch-SQL/src/com/es/sql/query/SyntaxCheck.java: -------------------------------------------------------------------------------- 1 | package com.es.sql.query; 2 | 3 | import java.util.ArrayList; 4 | import java.util.List; 5 | 6 | import org.apache.commons.lang.StringUtils; 7 | 8 | import com.es.sql.parse.QuerySqlParser; 9 | 10 | /** 11 | * group 语法检查 12 | * @author wangyong 13 | * 14 | */ 15 | public class SyntaxCheck { 16 | 17 | /** 18 | * @param args 19 | */ 20 | public static void main(String[] args) { 21 | // TODO Auto-generated method stub 22 | 23 | } 24 | 25 | /** 26 | * 语法检查 27 | * @param qsp 28 | * @return 29 | */ 30 | public static boolean checkSyntax(QuerySqlParser qsp){ 31 | boolean b = true; 32 | if(StringUtils.isEmpty(qsp.getSelectCol())){ 33 | b = false; 34 | } 35 | if(StringUtils.isEmpty(qsp.getFromTable())){ 36 | b = false; 37 | } 38 | if(StringUtils.isNotEmpty(qsp.getSelectCol()) && StringUtils.isNotEmpty(qsp.getGroupCondition())){//存在group by条件，检查select 39 | String select = qsp.getSelectCol(); 40 | String group = qsp.getGroupCondition(); 41 | String[] arrSelect = select.split(","); 42 | String[] arrGroup = group.split(","); 43 | int num = 0; 44 | List list = new ArrayList(); 45 | for(String g:arrGroup){ 46 | for(String s:arrSelect){ 47 | if(s.trim().equals(g.trim())){ 48 | num++; 49 | list.add(s.trim()); 50 | break; 51 | }else{ 52 | if(s.trim().startsWith("count(") || s.trim().startsWith("sum(") || s.trim().startsWith("avg(") || s.trim().startsWith("max(") || s.trim().startsWith("min(")|| s.trim().startsWith("stats(")){ 53 | 54 | }else{ 55 | b = false; 56 | for(String x:list){ 57 | if(x.trim().equals(s.trim())){ 58 | b = true;//纠正 59 | break; 60 | } 61 | } 62 | //存在select域，在执行group by情况下不属于聚合函数或者group字段的域 63 | } 64 | } 65 | } 66 | } 67 | 68 | } 69 | return b; 70 | } 71 | 72 | } 73 | -------------------------------------------------------------------------------- /ElasticSearch-SQL/src/com/es/sql/parse/BaseSingleSqlParser.java: -------------------------------------------------------------------------------- 1 | package com.es.sql.parse; 2 | 3 | import java.util.ArrayList; 4 | import java.util.List; 5 | 6 | public abstract class BaseSingleSqlParser { 7 | /** */ 8 | /** 9 | * 　* 原始Sql语句　 10 | */ 11 | protected String originalSql; 12 | /** */ 13 | /** 14 | * 　* Sql语句片段　 15 | */ 16 | protected List segments; 17 | 18 | /** */ 19 | /** 20 | * 　* 构造函数，传入原始Sql语句，进行劈分。　* @param originalSql 　 21 | */ 22 | public BaseSingleSqlParser(String originalSql) { 23 | this.originalSql = originalSql; 24 | segments = new ArrayList(); 25 | initializeSegments(); 26 | splitSql2Segment(); 27 | } 28 | 29 | /** */ 30 | /** 31 | * 　* 初始化segments，强制子类实现　* 　 32 | */ 33 | protected abstract void initializeSegments(); 34 | 35 | /** */ 36 | /** 37 | * 　* 将originalSql劈分成一个个片段　* 　 38 | */ 39 | protected void splitSql2Segment() { 40 | for (SqlSegment sqlSegment : segments) { 41 | sqlSegment.parse(originalSql); 42 | } 43 | } 44 | 45 | /** */ 46 | /** 47 | * 　* 得到解析完毕的Sql语句　* @return 　 48 | */ 49 | public String getParsedSql() { 50 | 51 | // 测试输出各个片段的信息 52 | 53 | for(SqlSegment sqlSegment:segments) { 54 | String start=sqlSegment.getStart(); 55 | String end=sqlSegment.getEnd(); 56 | System.out.println(start); 57 | System.out.println(end); 58 | } 59 | 60 | 61 | StringBuffer sb = new StringBuffer(); 62 | for (SqlSegment sqlSegment : segments) { 63 | sb.append(sqlSegment.getParsedSqlSegment()); 64 | } 65 | String retval = sb.toString().replaceAll("@+", "\n"); 66 | return retval; 67 | } 68 | 69 | /** */ 70 | /** 71 | * 得到解析的Sql片段 72 | * 73 | * @return 74 | */ 75 | public List RetrunSqlSegments() { 76 | int SegmentLength = this.segments.size(); 77 | if (SegmentLength != 0) { 78 | List result = this.segments; 79 | return result; 80 | } else { 81 | // throw new Exception(); 82 | return null; 83 | } 84 | } 85 | } 86 | -------------------------------------------------------------------------------- /ElasticSearch-SQL/src/com/es/sql/query/QuerySortHandler.java: -------------------------------------------------------------------------------- 1 | package com.es.sql.query; 2 | 3 | import java.util.ArrayList; 4 | import java.util.List; 5 | 6 | import org.apache.commons.lang.StringUtils; 7 | import org.elasticsearch.search.sort.SortBuilder; 8 | import org.elasticsearch.search.sort.SortBuilders; 9 | import org.elasticsearch.search.sort.SortOrder; 10 | 11 | import com.es.sql.parse.QuerySqlParser; 12 | 13 | /** 14 | * 构建sort 15 | * @author wangyong 16 | * 17 | */ 18 | public class QuerySortHandler { 19 | 20 | /** 21 | * @param args 22 | */ 23 | public static void main(String[] args) { 24 | // TODO Auto-generated method stub 25 | 26 | } 27 | /** 28 | * 处理排序 29 | * @param qsp 30 | * @return 31 | */ 32 | public static List getSortBuilder(QuerySqlParser qsp){ 33 | List list = null; 34 | try{ 35 | 36 | String orderBy = qsp.getOrderCondition(); 37 | if(StringUtils.isEmpty(orderBy)){ 38 | return null; 39 | } 40 | list = handlerSortCondition(orderBy); 41 | 42 | }catch (Exception e) { 43 | e.printStackTrace(); 44 | } 45 | 46 | return list; 47 | } 48 | 49 | /** 50 | * 处理排序条件 51 | * @param orderby 52 | * @return 53 | */ 54 | private static List handlerSortCondition(String orderby){ 55 | if(StringUtils.isEmpty(orderby)){ 56 | return null; 57 | } 58 | List list = new ArrayList(); 59 | 60 | try{ 61 | String[] orderArr = orderby.split(","); 62 | for(String str:orderArr){// order by a ,b desc,c asc 63 | String[] arr = str.trim().split(" "); 64 | SortBuilder sortBuilder = null; 65 | if(arr.length==1){ 66 | sortBuilder = SortBuilders.fieldSort(arr[0].trim()).order(SortOrder.ASC); 67 | }else{ 68 | if("asc".equals(arr[1].trim().toLowerCase())){ 69 | sortBuilder = SortBuilders.fieldSort(arr[0].trim()).order(SortOrder.ASC); 70 | }else{ 71 | sortBuilder = SortBuilders.fieldSort(arr[0].trim()).order(SortOrder.DESC); 72 | } 73 | } 74 | 75 | list.add(sortBuilder); 76 | } 77 | 78 | }catch (Exception e) { 79 | e.printStackTrace(); 80 | } 81 | 82 | return list; 83 | } 84 | } 85 | -------------------------------------------------------------------------------- /ElasticSearch-SQL/src/com/es/api/test/BankMapping.java: -------------------------------------------------------------------------------- 1 | package com.es.api.test; 2 | 3 | import org.elasticsearch.action.admin.indices.mapping.put.PutMappingRequest; 4 | import org.elasticsearch.client.Client; 5 | import org.elasticsearch.client.Requests; 6 | import org.elasticsearch.common.xcontent.XContentBuilder; 7 | import org.elasticsearch.common.xcontent.XContentFactory; 8 | 9 | import com.es.sql.util.EsUtil; 10 | 11 | /** 12 | * 项目测试对应的测试index 13 | * @author wangyong 14 | * 15 | */ 16 | public class BankMapping { 17 | 18 | /** 19 | * @param args 20 | */ 21 | public static void main(String[] args) { 22 | 23 | PutMappingRequest mRequest = Requests.putMappingRequest("bank1").type("account1").source(getMapping()); 24 | Client client = EsUtil.getClient(); 25 | client.admin().indices().prepareCreate("bank1").execute().actionGet(); 26 | client.admin().indices().putMapping(mRequest).actionGet(); 27 | 28 | client.close(); 29 | } 30 | 31 | private static XContentBuilder getMapping(){ 32 | XContentBuilder mapping = null; 33 | try{ 34 | mapping = XContentFactory.jsonBuilder().startObject().startObject("account1").startObject("properties"); 35 | mapping.startObject("account_number").field("type", "integer").field("store","yes").endObject() 36 | .startObject("balance").field("type","integer").field("store","yes").endObject() 37 | .startObject("firstname").field("type","string").field("store","yes").endObject() 38 | .startObject("lastname").field("type","string").field("store","yes").endObject() 39 | .startObject("age").field("type","integer").field("store","yes").endObject() 40 | .startObject("gender").field("type","string").field("store","yes").endObject() 41 | .startObject("address").field("type","string").field("store","yes").endObject() 42 | .startObject("employer").field("type","string").field("store","yes").endObject() 43 | .startObject("email").field("type","string").field("store","yes").endObject() 44 | .startObject("city").field("type","string").field("store","yes").endObject() 45 | .startObject("state").field("type","string").field("store","yes").endObject(); 46 | mapping.endObject().endObject().endObject(); 47 | 48 | 49 | }catch (Exception e) { 50 | e.printStackTrace(); 51 | } 52 | return mapping; 53 | } 54 | } 55 | -------------------------------------------------------------------------------- /ElasticSearch-SQL/src/com/es/api/test/BankContentIndex.java: -------------------------------------------------------------------------------- 1 | package com.es.api.test; 2 | 3 | import java.io.BufferedReader; 4 | import java.io.File; 5 | import java.io.FileReader; 6 | 7 | import net.sf.json.JSONObject; 8 | 9 | import org.elasticsearch.action.index.IndexResponse; 10 | import org.elasticsearch.common.xcontent.XContentBuilder; 11 | import org.elasticsearch.common.xcontent.XContentFactory; 12 | 13 | import com.es.sql.util.EsUtil; 14 | 15 | /** 16 | * 测试数据 17 | * @author wangyong 18 | * 19 | */ 20 | public class BankContentIndex { 21 | 22 | /** 23 | * @param args 24 | */ 25 | public static void main(String[] args) { 26 | // TODO Auto-generated method stub 27 | String path = "E:\\new\\accounts.json"; 28 | readFile(path); 29 | } 30 | 31 | public static void readFile(String path){ 32 | try{ 33 | File file = new File(path);// Text文件 34 | BufferedReader br = new BufferedReader(new FileReader(file));// 构造一个BufferedReader类来读取文件 35 | String s = null; 36 | while ((s = br.readLine()) != null) {// 使用readLine方法，一次读一行 37 | System.out.println(s); 38 | if(s.indexOf("index")<0){ 39 | createXContentBuilder(s); 40 | } 41 | } 42 | br.close(); 43 | }catch (Exception e) { 44 | e.printStackTrace(); 45 | } 46 | } 47 | 48 | private static void createXContentBuilder(String content){ 49 | try{ 50 | JSONObject bean = JSONObject.fromString(content); 51 | XContentBuilder doc = XContentFactory.jsonBuilder().startObject(); 52 | doc.field("account_number",bean.get("account_number")) 53 | .field("balance",bean.get("balance")) 54 | .field("firstname", bean.get("firstname")) 55 | .field("lastname", bean.get("lastname")) 56 | .field("age", bean.get("age")) 57 | .field("gender", bean.get("gender")) 58 | .field("address", bean.get("address")) 59 | .field("employer", bean.get("employer")) 60 | .field("email", bean.get("email")) 61 | .field("city", bean.get("city")) 62 | .field("state", bean.get("state")) 63 | .endObject(); 64 | 65 | indexContent(doc); 66 | 67 | }catch (Exception e) { 68 | e.printStackTrace(); 69 | } 70 | } 71 | 72 | private static void indexContent(XContentBuilder content){ 73 | try{ 74 | 75 | IndexResponse response = EsUtil.getClient().prepareIndex("bank1", "account1").setSource(content).execute().actionGet(); 76 | System.out.println(response.getId() + "====" + response.getIndex() + "====" + response.getType()); 77 | 78 | }catch (Exception e) { 79 | e.printStackTrace(); 80 | } 81 | } 82 | } 83 | -------------------------------------------------------------------------------- /ElasticSearch-SQL/src/com/es/sql/parse/SqlSegment.java: -------------------------------------------------------------------------------- 1 | package com.es.sql.parse; 2 | 3 | import java.util.ArrayList; 4 | import java.util.List; 5 | import java.util.regex.Matcher; 6 | import java.util.regex.Pattern; 7 | 8 | public class SqlSegment { 9 | private static final String Crlf = "@"; 10 | private static final String FourSpace = "　　"; 11 | /** */ 12 | /** 13 | * 　* Sql语句片段开头部分　 14 | */ 15 | private String start; 16 | /** */ 17 | /** 18 | * 　* Sql语句片段中间部分　 19 | */ 20 | private String body; 21 | /** */ 22 | /** 23 | * 　* Sql语句片段结束部分　 24 | */ 25 | private String end; 26 | /** */ 27 | /** 28 | * 　* 用于分割中间部分的正则表达式　 29 | */ 30 | private String bodySplitPattern; 31 | /** */ 32 | /** 33 | * 　* 表示片段的正则表达式　 34 | */ 35 | private String segmentRegExp; 36 | /** */ 37 | /** 38 | * 　* 分割后的Body小片段　 39 | */ 40 | private List bodyPieces; 41 | 42 | /** */ 43 | /** 44 | * 　* 构造函数　* @param segmentRegExp 表示这个Sql片段的正则表达式　* @param 45 | * bodySplitPattern 用于分割body的正则表达式　 46 | */ 47 | public SqlSegment(String segmentRegExp, String bodySplitPattern) { 48 | start = ""; 49 | body = ""; 50 | end = ""; 51 | this.segmentRegExp = segmentRegExp; 52 | this.bodySplitPattern = bodySplitPattern; 53 | this.bodyPieces = new ArrayList(); 54 | 55 | } 56 | 57 | /** */ 58 | /** 59 | * 　* 从sql中查找符合segmentRegExp的部分，并赋值到start,body,end等三个属性中　* @param sql 　 60 | */ 61 | public void parse(String sql) { 62 | Pattern pattern = Pattern.compile(segmentRegExp, 63 | Pattern.CASE_INSENSITIVE); 64 | for (int i = 0; i <= sql.length(); i++) { 65 | String shortSql = sql.substring(0, i); 66 | // 测试输出的子句是否正确 67 | System.out.println(shortSql); 68 | Matcher matcher = pattern.matcher(shortSql); 69 | while (matcher.find()) { 70 | start = matcher.group(1); 71 | body = matcher.group(2); 72 | // 测试body部分 73 | // System.out.println(body); 74 | end = matcher.group(3); 75 | // 测试相应的end部分 76 | // System.out.println(end); 77 | parseBody(); 78 | return; 79 | } 80 | } 81 | } 82 | 83 | /** */ 84 | /** 85 | * 　* 解析body部分　* 　 86 | */ 87 | private void parseBody() { 88 | 89 | List ls = new ArrayList(); 90 | Pattern p = Pattern.compile(bodySplitPattern, Pattern.CASE_INSENSITIVE); 91 | // 先清除掉前后空格 92 | body = body.trim(); 93 | Matcher m = p.matcher(body); 94 | StringBuffer sb = new StringBuffer(); 95 | boolean result = m.find(); 96 | while (result) { 97 | m.appendReplacement(sb, m.group(0) + Crlf); 98 | result = m.find(); 99 | } 100 | m.appendTail(sb); 101 | // 再按空格断行 102 | String[] arr = sb.toString().split(" "); 103 | int arrLength = arr.length; 104 | for (int i = 0; i < arrLength; i++) { 105 | String temp = FourSpace + arr[i]; 106 | if (i != arrLength - 1) { 107 | // temp=temp+Crlf; 108 | } 109 | ls.add(temp); 110 | } 111 | bodyPieces = ls; 112 | } 113 | 114 | /** */ 115 | /** 116 | * 　* 取得解析好的Sql片段　* @return 　 117 | */ 118 | public String getParsedSqlSegment() { 119 | StringBuffer sb = new StringBuffer(); 120 | sb.append(start + Crlf); 121 | for (String piece : bodyPieces) { 122 | sb.append(piece + Crlf); 123 | } 124 | return sb.toString(); 125 | } 126 | 127 | public String getBody() { 128 | return body; 129 | } 130 | 131 | public void setBody(String body) { 132 | this.body = body; 133 | } 134 | 135 | public String getEnd() { 136 | return end; 137 | } 138 | 139 | public void setEnd(String end) { 140 | this.end = end; 141 | } 142 | 143 | public String getStart() { 144 | return start; 145 | } 146 | 147 | public void setStart(String start) { 148 | this.start = start; 149 | } 150 | 151 | } 152 | -------------------------------------------------------------------------------- /ElasticSearch-SQL/src/com/es/api/test/SimpleMappingTest.java: -------------------------------------------------------------------------------- 1 | package com.es.api.test; 2 | 3 | import org.elasticsearch.action.bulk.BulkRequestBuilder; 4 | import org.elasticsearch.action.search.SearchResponse; 5 | import org.elasticsearch.client.Client; 6 | import org.elasticsearch.client.Requests; 7 | import org.elasticsearch.common.xcontent.XContentBuilder; 8 | import org.elasticsearch.common.xcontent.XContentFactory; 9 | import org.elasticsearch.index.query.QueryStringQueryBuilder; 10 | 11 | import com.es.sql.util.EsUtil; 12 | 13 | /** 14 | * 创建index mapping测试 15 | * @author wangyong 16 | * 17 | */ 18 | public class SimpleMappingTest { 19 | 20 | /** 21 | * @param args 22 | */ 23 | public static void main(String[] args) { 24 | Client client = EsUtil.getClient(); 25 | String indexName = "index1"; 26 | String typeName = "type1"; 27 | 28 | createMapping(client, indexName, typeName); 29 | 30 | System.out.println(batchAddDocument(client, indexName, typeName)); 31 | 32 | search(client, indexName, typeName); 33 | 34 | } 35 | 36 | /** 37 | * 字符串搜索 38 | * @param client 39 | * @param indexName 40 | * @param typeName 41 | */ 42 | public static void search(Client client,String indexName,String typeName){ 43 | try{ 44 | SearchResponse response = client.prepareSearch(indexName).setTypes(typeName) 45 | .setQuery(new QueryStringQueryBuilder("png|jpg").field("thumb")) 46 | .setFrom(0).setSize(50).execute().actionGet(); 47 | System.out.println(response.toString()); 48 | 49 | }catch (Exception e) { 50 | e.printStackTrace(); 51 | } 52 | } 53 | 54 | 55 | /** 56 | * 批量建立index 57 | * @param client 58 | * @param indexName 59 | * @param typeName 60 | * @return 61 | */ 62 | private static Integer batchAddDocument(Client client,String indexName,String typeName){ 63 | BulkRequestBuilder bulkRequestBuilder = client.prepareBulk(); 64 | try{ 65 | for(int i = 0;i<100;i++){ 66 | try{ 67 | bulkRequestBuilder.add(client.prepareIndex(indexName, typeName, i+"") 68 | .setSource(XContentFactory.jsonBuilder().startObject() 69 | .field("id",i+"") 70 | .field("thumb","http://www.chepoo.com/imges/"+i+".jpg") 71 | .endObject() 72 | ) 73 | ); 74 | 75 | }catch (Exception e) { 76 | e.printStackTrace(); 77 | } 78 | } 79 | 80 | try{ 81 | bulkRequestBuilder.add(client.prepareIndex(indexName, typeName, ""+101) 82 | .setSource(XContentFactory.jsonBuilder() 83 | .startObject() 84 | .field("id", ""+101) 85 | .field("thumb", "http://www.chepoo.com/imges/"+5+".png") 86 | .endObject()) 87 | ); 88 | }catch(Exception e){ 89 | e.printStackTrace(); 90 | } 91 | bulkRequestBuilder.execute().actionGet(); 92 | 93 | }catch (Exception e) { 94 | e.printStackTrace(); 95 | } 96 | return bulkRequestBuilder.numberOfActions(); 97 | } 98 | 99 | /** 100 | * 构建index mapping 101 | * @param client 102 | * @param indexName 103 | */ 104 | private static void createMapping(Client client,String indexName,String typeName){ 105 | try{ 106 | XContentBuilder mapping = XContentFactory.jsonBuilder() 107 | .startObject() 108 | .startObject(typeName) 109 | .startObject("properties") 110 | .startObject("id") 111 | .field("type","long") 112 | .field("store","yes") 113 | .field("index","no_analyzed") 114 | .field("include_in_all","false") 115 | .endObject() 116 | .startObject("thumb") 117 | .field("type","string") 118 | .field("store","yes") 119 | .field("include_in_all","false") 120 | .endObject() 121 | .endObject() 122 | .endObject() 123 | .endObject(); 124 | 125 | client.admin().indices().putMapping(Requests.putMappingRequest(indexName).type(typeName).source(mapping)).actionGet(); 126 | 127 | }catch (Exception e) { 128 | e.printStackTrace(); 129 | } 130 | } 131 | 132 | 133 | 134 | 135 | } 136 | -------------------------------------------------------------------------------- /ElasticSearch-SQL/src/com/es/sql/util/sql.txt: -------------------------------------------------------------------------------- 1 | 2 | select sum(price),count(1),ds(day),gender,agerange 3 | from payment 4 | where ( (price between 1 and 10000) and userid not in('0','1','2','3','4') and location='beijing' ) or ( is_pre=1 ) 5 | group by age(0-20,20-30,30-40,40-50,50-100),gender,ds(day) 6 | order by sum(price) desc,count(1) desc; 7 | 8 | 9 | 10 | curl -XPOST 'localhost:9200/bank/_search?pretty' -d ' 11 | { 12 | "query": { 13 | "filtered": { 14 | "query": { "match_all": {} }, 15 | "filter": { 16 | "bool":{ 17 | "should":[ 18 | { 19 | "bool":{ 20 | "must":[ 21 | { 22 | "range":{ 23 | "price":{ 24 | "gte":1, 25 | "lte":10000 26 | } 27 | } 28 | }, 29 | { 30 | "match":{"location":"beijing"} 31 | } 32 | ] 33 | "must_not":[ 34 | {"match":{"userid":"0"}}, 35 | {"match":{"userid":"1"}}, 36 | {"match":{"userid":"2"}}, 37 | {"match":{"userid":"3"}}, 38 | {"match":{"userid":"4"}} 39 | ] 40 | } 41 | }, 42 | {"match":{"is_pre":"1"}} 43 | ] 44 | } 45 | "aggs":{ 46 | "group_by_age":{ 47 | "range":{ 48 | "field":"age", 49 | "ranges":[ 50 | {"from":0,"to":20}, 51 | {"from":20,"to":30}, 52 | {"from":30,"to":40}, 53 | {"from":40,"to":50}, 54 | {"from":50,"to":100} 55 | ] 56 | }, 57 | "aggs":{ 58 | "group_by_gender":{ 59 | "trems":{ 60 | "field":"gender" 61 | } 62 | } 63 | } 64 | } 65 | } 66 | "sort": { "balance": { "gender": "desc" } } 67 | } 68 | } 69 | } 70 | } 71 | 72 | 73 | 74 | ------------------------------------------------------------------------------------------ 75 | curl -XPOST 'localhost:9200/bank/_search?pretty' -d ' 76 | { 77 | "query": { 78 | "filtered": { 79 | "query": { "match_all": {} }, 80 | "filter": { 81 | "bool":{ 82 | "should":[ 83 | { 84 | "bool":{ 85 | "must":[ 86 | { 87 | "range":{ 88 | "price":{ 89 | "gte":1, 90 | "lte":10000 91 | } 92 | } 93 | }, 94 | { 95 | "match":{"location":"beijing"} 96 | } 97 | ] 98 | "must_not":[ 99 | {"match":{"userid":"0"}}, 100 | {"match":{"userid":"1"}}, 101 | {"match":{"userid":"2"}}, 102 | {"match":{"userid":"3"}}, 103 | {"match":{"userid":"4"}} 104 | ] 105 | } 106 | }, 107 | {"match":{"is_pre":"1"}} 108 | ] 109 | } 110 | "facets":{ 111 | "range1":{ 112 | "range":{ 113 | "age":[ 114 | {"from":0,"to":20}, 115 | {"from":20,"to":30}, 116 | {"from":30,"to":40}, 117 | {"from":40,"to":50}, 118 | {"from":50,"to":100} 119 | ] 120 | }, 121 | "aggs":{ 122 | "group_by_gender":{ 123 | "trems":{ 124 | "field":"gender" 125 | } 126 | } 127 | } 128 | } 129 | } 130 | "sort": { "balance": { "gender": "desc" } } 131 | } 132 | } 133 | } 134 | } 135 | -------------------------------------------------------------------------------- /ElasticSearch-SQL/pom.xml: -------------------------------------------------------------------------------- 1 | 3 | 4.0.0 4 | ElasticSearch-SQL 5 | ElasticSearch-SQL 6 | 0.0.1-SNAPSHOT 7 | 8 | 9 | UTF-8 10 | 4.11 11 | 1.7 12 | 13 | 14 | 15 | 16 | org.elasticsearch 17 | elasticsearch 18 | 1.3.2 19 | 20 | 21 | commons-logging 22 | commons-logging 23 | 1.1 24 | 25 | 26 | commons-lang 27 | commons-lang 28 | 2.5 29 | 30 | 31 | commons-collections 32 | commons-collections 33 | 3.2.1 34 | 35 | 36 | commons-beanutils 37 | commons-beanutils-core 38 | 1.8.0 39 | 40 | 41 | net.sf.ezmorph 42 | ezmorph 43 | 1.0.6 44 | 45 | 46 | net.sf.json-lib 47 | json-lib 48 | 0.9 49 | 50 | 51 | 52 | 53 | src 54 | 55 | 56 | src 57 | 58 | **/*.java 59 | 60 | 61 | 62 | 63 | 64 | maven-compiler-plugin 65 | 3.1 66 | 67 | 1.7 68 | 1.7 69 | 70 | 71 | 72 | 73 | org.apache.maven.plugins 74 | maven-jar-plugin 75 | 2.4 76 | 77 | loader 78 | 79 | 80 | true 81 | lib/ 82 | 83 | 84 | 85 | 86 | 87 | 88 | org.apache.maven.plugins 89 | maven-dependency-plugin 90 | 2.8 91 | 92 | 93 | copy-dependencies 94 | package 95 | 96 | copy-dependencies 97 | 98 | 99 | ${project.build.directory}/lib 100 | runtime 101 | 102 | 103 | 104 | 105 | 106 | 107 | 108 | 109 | 110 | org.eclipse.m2e 111 | lifecycle-mapping 112 | 1.0.0 113 | 114 | 115 | 116 | 117 | 118 | org.apache.maven.plugins 119 | maven-dependency-plugin 120 | [1.0.0,) 121 | 122 | copy-dependencies 123 | 124 | 125 | 126 | 127 | 128 | 129 | 130 | 131 | 132 | 133 | 134 | 135 | 136 | -------------------------------------------------------------------------------- /README.md: -------------------------------------------------------------------------------- 1 | #ElasticSearch-SQL 2 | ================= 3 | 4 | 该项目主要是为了熟悉sql的人员能够很方便的进行elasticsearch数据的查询，降低学习成本。 5 | 6 | ##目前项目可以支持的查询如下： 7 | 8 | ``` 9 | //String sql = "filter:select state,city,count(distinct account_number) as count from bank where gender='M' and age>10 group by state,city"; 10 | 11 | //String sql = "filter:select state,city,sum(balance) as total from bank where gender='M' and age>10 group by state,city"; 12 | 13 | //String sql = "filter:select state,avg(balance) as total from bank where gender='M' and age>20 group by state"; 14 | 15 | //String sql = "filter:select state,max(balance) as total from bank where gender='M' group by state"; 16 | 17 | //String sql = "query:select * from bank where gender='M' and age>30"; 18 | 19 | //String sql = "query:select * from bank where gender='M' and age in(30,31,32)"; 20 | 21 | //String sql = "query:select * from bank where gender='M'"; 22 | 23 | //String sql = "query:select * from bank where id=9BnH0MToTvWMHwikTb-uhA"; 24 | 25 | //String sql = "query:select * from bank where (gender='M' and age>=40) or (balance>40000)"; 26 | 27 | //String sql = "query:select * from bank where (gender='M' and age>=40) or (balance between 40000 and 44000)"; 28 | 29 | //String sql = "query:select * from bank where (gender='M' and age>=40) or (balance>40000) limit 10"; 30 | 31 | //String sql = "query:select * from bank where gender='M' and age>=30 and (balance between 40000 and 44000)"; 32 | 33 | //String sql = "query:select * from bank where gender='M' and age>=30 and (balance between 40000 and 44000) and state in('id','wy')"; 34 | 35 | //String sql = "query:select state,max(balance) from bank where gender='M' and age>=30 and state in('id','wy') group by state"; 36 | 37 | //String sql = "query:select * from bank where firstname like '%beck%'"; 38 | 39 | //String sql = "query:select * from bank where gender='M' and (age>=30 and age<35)"; 40 | 41 | //String sql = "select sum(who.s) from events where context.channlid.s in(1,2,3,4) and context.serverid.s in('s1','s2') and what.s='item' group by context.serverid.s"; 42 | 43 | //String sql = "select * from bank.account order by age desc,account_number asc"; 44 | 45 | //------------------------------------------------------------------------------ 46 | //String sql = "select stats(balance) from bank.account group by age"; 47 | 48 | //String sql = "select stats(balance) from bank.account group by state,age[*-20|20-25|25-30|30-35|35-40|40-*]"; 49 | 50 | //String sql = "select stats(balance) from bank.account group by (age[*-20|20-25|25-30|30-35|35-40|40-*]),(state)"; 51 | 52 | //String sql = "select stats(balance) from bank.account group by (state,age[*-20|20-25|25-30|30-35|35-40|40-*]),(city)"; 53 | 54 | //String sql = "select account_number,age,balance from bank where age>25"; 55 | 56 | //String sql = "select account_number,age,balance from bank where age>25 order by balance desc"; 57 | 58 | //---------------------------------------------------------------------------------------- 59 | 60 | //String sql = "select stats(balance) from bank2.account2 group by age[histogram-5]"; 61 | 62 | //String sql = "select stats(balance) from bank2.account2 group by state,age[histogram-5]"; 63 | 64 | //String sql = "select stats(balance) from bank2.account2 group by createtime[datehistogram-2day]"; 65 | 66 | //String sql = "select stats(balance) from bank2.account2 group by state,createtime[datehistogram-2day]"; 67 | 68 | ``` 69 | 70 | 71 | ##测试数据导入 72 | ``` 73 | 路径：/com/es/api/test/accounts.json 74 | ``` 75 | ##执行测试： 76 | 77 | * /com/es/api/test/BankMapping.java 创建index ，根据需求修改index和type 78 | * /com/es/api/test/BankContentIndex.java 根据需求修改index和type，已经accounts.json路径 79 | * 其他测试类可自行修改之后测试 80 | 81 | ##ElasticSearch - JAVA API 测试用例 82 | ``` 83 | /com/es/sql/query/TestQuery.java 84 | ``` 85 | 86 | 87 | ##已经支持功能如下： 88 | ``` 89 | count 90 | count(distinct ..) 91 | sum 92 | max 93 | avg 94 | min 95 | stats 96 | 97 | between ... and ... 98 | like 99 | in 100 | not in 101 | = 102 | != 103 | > 104 | >= 105 | < 106 | <= 107 | 108 | id查询 109 | 110 | 自定义查询结果维度 select a,b,c,d from .... 111 | 112 | 多层group :实例 group by a,b,c,d 113 | 114 | 多组group :实例 group by (a,b),(c,d),(e,f) 115 | 116 | range group:实例 group by age[*-20|20-25|25-30|30-35|35-40|40-*] 117 | 118 | histogram :实例 group by age[histogram-5] 119 | 120 | datehistogram ：实例 createtime[datehistogram-2day] 121 | ``` 122 | ##使用的公司 123 | 124 | *热云科技：http://reyun.com/ 125 | 126 | -------------------------------------------------------------------------------- /ElasticSearch-SQL/src/com/es/sql/util/EsUtil.java: -------------------------------------------------------------------------------- 1 | package com.es.sql.util; 2 | 3 | import java.util.ArrayList; 4 | import java.util.List; 5 | 6 | import org.elasticsearch.client.Client; 7 | import org.elasticsearch.client.transport.TransportClient; 8 | import org.elasticsearch.common.mvel2.optimizers.impl.refl.nodes.ThisValueAccessor; 9 | import org.elasticsearch.common.settings.ImmutableSettings; 10 | import org.elasticsearch.common.settings.Settings; 11 | import org.elasticsearch.common.transport.InetSocketTransportAddress; 12 | 13 | /** 14 | * elasticsearch 工具类 15 | * @author wangyong 16 | * 17 | */ 18 | public class EsUtil { 19 | 20 | private static Client client; 21 | 22 | private static boolean sniff; 23 | private static String clusterName; 24 | private static String[] hosts; 25 | 26 | public static long precisionThreshold = 1000; 27 | public static boolean ignore_unavailable = true; 28 | public static boolean allow_no_indices = true; 29 | 30 | public static long minDocCount = 0; 31 | 32 | /** 33 | * 获取客户端 34 | * @return 35 | */ 36 | public synchronized static Client getClient(){ 37 | try{ 38 | if(client == null){ 39 | 40 | /*Settings settings = ImmutableSettings.settingsBuilder().put("client.transport.sniff", true) 41 | .put("cluster.name","elasticsearch").build(); 42 | client = new TransportClient(settings) 43 | .addTransportAddress(new InetSocketTransportAddress("x00", 9300)) 44 | .addTransportAddress(new InetSocketTransportAddress("x01", 9300));*/ 45 | client = initClient(isSniff(), getClusterName(), getHosts()); 46 | 47 | } 48 | }catch (Exception e) { 49 | System.out.println(e.getMessage()); 50 | } 51 | return client; 52 | } 53 | 54 | /** 55 | * 初始化信息 56 | * @param sniff 57 | * @param clusterName 58 | * @param hosts 59 | * @return 60 | */ 61 | public synchronized static Client initClient(boolean sniff,String clusterName,String...hosts ){ 62 | try{ 63 | setSniff(sniff); 64 | setClusterName(clusterName); 65 | setHosts(hosts); 66 | 67 | if(client == null){ 68 | 69 | Settings settings = ImmutableSettings.settingsBuilder().put("client.transport.sniff", sniff) 70 | .put("cluster.name",clusterName).build(); 71 | if(hosts!=null && hosts.length>0){ 72 | List list = new ArrayList(); 73 | for(String hostport : hosts){ 74 | String[] arr = hostport.split(":"); 75 | if(arr.length==2){ 76 | list.add(new InetSocketTransportAddress(arr[0], Integer.parseInt(arr[1]))); 77 | } 78 | } 79 | if(list.size()>0){ 80 | InetSocketTransportAddress[] staarr = new InetSocketTransportAddress[list.size()]; 81 | for(int i=0;i 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10 | 11 | 12 | 13 | 14 | 15 | 16 | 17 | 18 | 19 | 20 | 21 | 22 | 23 | 24 | 25 | 26 | 27 | 28 | 29 | 30 | 31 | 32 | 33 | 34 | 35 | 36 | 37 | 38 | 39 | 40 | 41 | 42 | 43 | 44 | 45 | 46 | 47 | 48 | 49 | 50 | 51 | 52 | 53 | 54 | 55 | 56 | 57 | 58 | 59 | 60 | -------------------------------------------------------------------------------- /ElasticSearch-SQL/src/com/es/sql/util/CommonUtils.java: -------------------------------------------------------------------------------- 1 | package com.es.sql.util; 2 | 3 | import java.util.HashMap; 4 | import java.util.Map; 5 | 6 | import com.es.sql.util.CommonConstant.DataType; 7 | 8 | /** 9 | * 工具类 10 | * @author wangyong 11 | * 12 | */ 13 | public class CommonUtils { 14 | 15 | /** 16 | * @param args 17 | */ 18 | public static void main(String[] args) { 19 | //(ds between 1 and 2) 20 | //(a>10 and a<20) 21 | //b not in(3,54,10) 22 | //Map map = getValues("(atx>=10 and atx<20)", 3); 23 | //Map map = getValues("(atx between '10' and '20')", 2); 24 | /*Map map = getValues("atx in('1','2','3')", 1); 25 | for(Map.Entry entry : map.entrySet()){ 26 | System.out.println(entry.getKey()); 27 | System.out.println(entry.getValue()+"------------------------"); 28 | for(String x:entry.getValue()){ 29 | System.out.println(x); 30 | } 31 | }*/ 32 | System.out.println(getFieldIncludeLowerUpper("(atx>=10 and atx<20)")); 33 | 34 | String t = "'2014-09-29'"; 35 | t = t.substring(1,t.lastIndexOf("'")); 36 | System.out.println(t); 37 | } 38 | 39 | public static Map getValues(String str,int type){ 40 | Map map = new HashMap(); 41 | String[] values = null; 42 | if(type == 1){//in 43 | int start = str.indexOf("in("); 44 | int start1 = str.indexOf("in ("); 45 | String tmp = null; 46 | if(start>start1){ 47 | tmp = str.substring(start+3,str.length()); 48 | }else{ 49 | tmp = str.substring(start1+4,str.length()); 50 | } 51 | String[] arr = tmp.split(","); 52 | arr[arr.length-1] = arr[arr.length-1].substring(0,arr[arr.length-1].length()-1); 53 | DataType dataType = RegexCheck.getDataType(arr[0]); 54 | values = new String[arr.length]; 55 | if(dataType==DataType.STRING){ 56 | int i = 0; 57 | for(String a:arr){ 58 | String b = a.trim(); 59 | b = b.substring(1,b.length()-1); 60 | values[i++] = b; 61 | } 62 | }else{ 63 | values = arr; 64 | } 65 | map.put(dataType, values); 66 | }else if(type == 2){//between and 67 | String[] arr = str.split(" and "); 68 | if(arr.length==2){ 69 | arr[1] = arr[1].substring(0,arr[1].length()-1).trim(); 70 | DataType dataType = RegexCheck.getDataType(arr[1].trim()); 71 | values = new String[arr.length]; 72 | String tmp = arr[0].split("between")[1].trim(); 73 | if(dataType==DataType.STRING){ 74 | values[0] = tmp.substring(1,tmp.length()-1); 75 | values[1] = arr[1].trim().substring(1,arr[1].trim().length()-1); 76 | }else{ 77 | values[0] = tmp; 78 | values[1] = arr[1].trim(); 79 | } 80 | map.put(dataType, values); 81 | } 82 | }else if(type == 3){// a>10 and a <20 83 | String[] arr = str.split(" and "); 84 | values = new String[arr.length]; 85 | DataType dataType = DataType.STRING; 86 | if(arr.length == 2){ 87 | int i = 0; 88 | for(String t:arr){ 89 | if(t.indexOf(">=")>0){ 90 | t = t.substring(t.indexOf(">=")+2).trim(); 91 | }else if(t.indexOf("<=")>0){ 92 | t = t.substring(t.indexOf("<=")+2).trim(); 93 | }else if(t.indexOf(">")>0){ 94 | t = t.substring(t.indexOf(">")+1).trim(); 95 | }else if(t.indexOf("<")>0){ 96 | t = t.substring(t.indexOf("<")+1).trim(); 97 | } 98 | if(t.endsWith(")")){ 99 | t = t.substring(0,t.length()-1); 100 | } 101 | dataType = RegexCheck.getDataType(t); 102 | if(dataType == DataType.STRING){ 103 | t = t.substring(1,t.lastIndexOf("'")).trim(); 104 | } 105 | values[i++] = t; 106 | } 107 | } 108 | map.put(dataType, values); 109 | } 110 | 111 | return map; 112 | 113 | } 114 | 115 | 116 | public static String getFieldIncludeLowerUpper(String str){ 117 | StringBuffer sBuffer = new StringBuffer(); 118 | String[] arr = str.split(" and "); 119 | int lower = 0; 120 | int upper = 0; 121 | String field = ""; 122 | if(arr.length == 2){ 123 | for(String t:arr){ 124 | if(t.indexOf(">=")>0){ 125 | lower = 1; 126 | t = t.substring(0,t.indexOf(">=")).trim(); 127 | }else if(t.indexOf("<=")>0){ 128 | upper = 1; 129 | t = t.substring(0,t.indexOf("<=")).trim(); 130 | }else if(t.indexOf(">")>0){ 131 | t = t.substring(0,t.indexOf(">")).trim(); 132 | }else if(t.indexOf("<")>0){ 133 | t = t.substring(0,t.indexOf("<")).trim(); 134 | } 135 | 136 | field = t; 137 | 138 | } 139 | } 140 | 141 | return sBuffer.append(field).append("_").append(lower).append("_").append(upper).toString(); 142 | } 143 | 144 | public static String[] trimStrings(String[] args){ 145 | if(args==null || args.length<=0){ 146 | return args; 147 | } 148 | String[] tmp = new String[args.length]; 149 | for(int i = 0 ;i list = splitGroupBy(); 23 | for(String str:list){ 24 | System.out.println(str); 25 | }*/ 26 | //rangeGroupBySplit("age[*-20|20-25|25-30|30-35|35-40|40-*]"); 27 | splitIndex("[index.2014]"); 28 | } 29 | 30 | private static void splitIndex(String index){ 31 | if(index.startsWith("[") && index.indexOf("]")>0){ 32 | String x = index.substring(1,index.indexOf("]")); 33 | System.out.println(x); 34 | if(x.length()+2==index.length()){ 35 | 36 | }else{ 37 | String y = index.substring(index.lastIndexOf(".")+1); 38 | System.out.println(y); 39 | } 40 | 41 | 42 | } 43 | } 44 | 45 | private static void rangeGroupBySplit(String g){ 46 | String field = g.substring(0,g.indexOf("[")).trim(); 47 | String value = g.substring(g.indexOf("[")+1,g.indexOf("]")); 48 | String[] arr = value.split("\\|"); 49 | 50 | System.out.println("--------field="+field); 51 | if(arr.length==1){ 52 | System.out.println("---------arr[0]"+arr[0]); 53 | String[] tmp = arr[0].split("-"); 54 | if(tmp.length==2){ 55 | if("*".equals(tmp[0].trim())){ 56 | 57 | if(isIntegerOrDouble(tmp[1])){//必须是数字或者小数 58 | AggregationBuilders.range(field).field(field).addUnboundedTo(arr[0].trim(),Double.parseDouble(tmp[1])); 59 | } 60 | }else if("*".equals(tmp[1].trim())){ 61 | if(isIntegerOrDouble(tmp[0])){//必须是数字或者小数 62 | AggregationBuilders.range(field).field(field).addUnboundedFrom(arr[0].trim(),Double.parseDouble(tmp[0])); 63 | } 64 | } 65 | }else{ 66 | //格式错误 67 | } 68 | }else if(arr.length>1){ 69 | RangeBuilder rg = AggregationBuilders.range(field).field(field); 70 | for(int i=0;i splitGroupBy(){ 121 | String str = "(city,age[*-20|20-25|25-30|30-35|35-40|40-*],state),(city,state),(age,account_number)"; 122 | int num =0; 123 | boolean start = false; 124 | List list = new ArrayList(); 125 | StringBuffer stringBuffer = new StringBuffer(); 126 | for(int i=0;i0 || whereCondition.indexOf(" or ")>0){ 176 | flag = 0; 177 | if(whereCondition.indexOf(" between ")>0 && whereCondition.indexOf(" or ")<0){ 178 | if(whereCondition.indexOf(" and ") == whereCondition.lastIndexOf(" and ")){//只有一个and 没有or 有between 179 | flag = 2; 180 | } 181 | } 182 | }else if(whereCondition.startsWith("id") && 183 | (whereCondition.indexOf("=")>0 && 184 | !((whereCondition.indexOf("in(")>0||whereCondition.indexOf("in (")>0) || 185 | (whereCondition.indexOf("not in(")>0||whereCondition.indexOf("not in (")>0)))){ 186 | flag = 1; 187 | }else{ 188 | flag = 2; 189 | } 190 | }catch (Exception e) { 191 | e.printStackTrace(); 192 | } 193 | 194 | return flag; 195 | } 196 | 197 | } 198 | -------------------------------------------------------------------------------- /ElasticSearch-SQL/src/com/es/sql/query/WhereConditionHandler.java: -------------------------------------------------------------------------------- 1 | package com.es.sql.query; 2 | 3 | import java.util.ArrayList; 4 | import java.util.HashMap; 5 | import java.util.List; 6 | import java.util.Map; 7 | 8 | import org.apache.commons.lang.StringUtils; 9 | 10 | public class WhereConditionHandler { 11 | 12 | /** 13 | * @param args 14 | */ 15 | public static void main(String[] args) { 16 | //String sql = "select ds,serverid,count(distinc userid) as count from index.segment where appid='10xxxx' and what='item' and ds between 2014-08-12 and 2014-08-13 and tz='+8' group by ds,serverid order by count desc limit 0,100"; 17 | //String where = "appid = 'x' and what='item' and (ds between 1 and 2) and (a>10 and a<20) and b not in(3,54,10) and c like '%x'"; 18 | //String where = "(a=x and b=y) or (c=z)"; 19 | //String where = "a=x and b = y or c=z";//非严格语句，不处理 20 | //String where = "a=x or b=y or (c=z and d=t)"; 21 | String where = " (appid='10xxxx' and what='item' and (ds between '2014-08-12' and '2014-08-13') and tz='+8') or (axt in(1,2,3) and t='p') or is_admin=1"; 22 | 23 | handlerWhereCondition(where); 24 | 25 | } 26 | 27 | /** 28 | * where condition handler 29 | * @param whereCondition 30 | * @return 31 | */ 32 | public static Map> handlerWhereCondition(String whereCondition){ 33 | int split = sqlStartLogic(whereCondition); 34 | List list = splitWhereConditionLevelOne(whereCondition, split); 35 | Map> map = splitLevelOneGetLevelTwo(list, split); 36 | return map; 37 | } 38 | 39 | 40 | /** 41 | * 对一级处理数据进行二级拆分处理 42 | * @param list 43 | * @param split 44 | * @return 45 | */ 46 | private static Map> splitLevelOneGetLevelTwo(List list,int split){ 47 | //---------------------------------一级拆分完毕，进行二级拆分处理------------------------- 48 | 49 | List levelOneList = new ArrayList(); 50 | List levelTwoList = null; 51 | Map> map = new HashMap>();//key = level_split 52 | 53 | int second_split = 1; 54 | int second_depth = 0; 55 | for(String str:list){ 56 | if(str.trim().startsWith("(") && str.trim().endsWith(")")){//括弧配对完整,存在二级处理条件的可能性 57 | if((str.indexOf("in(")>0 || str.indexOf("in (")>0 ) && str.trim().indexOf(" and ")<0 && str.trim().indexOf(" or ")<0){//in 或者 not in ，不满足二级处理条件 58 | levelOneList.add(str); 59 | }else if((str.indexOf("not in(")>0 || str.indexOf("not in (")>0 ) && str.trim().indexOf(" and ")<0 && str.trim().indexOf(" or ")<0){//in 或者 not in ，不满足二级处理条件 60 | levelOneList.add(str); 61 | }else if(str.trim().indexOf(" between ")>0 && str.trim().indexOf(" and ")>0 && (str.trim().lastIndexOf(" and ")==str.trim().indexOf(" and "))){//between and 62 | levelOneList.add(str); 63 | }else if(str.trim().indexOf(" like ")>0 && str.trim().indexOf(" and ")<0 && str.trim().indexOf(" or ")<0){//只有like一条语句 64 | levelOneList.add(str); 65 | }else {//可能需要二级处理的(a=x and b=y and c=z) (a>10 and a<=20) (a=t or b=c or t=0) (a in(1,2,3) and b=1 and c like='10%') ((a between 1 and 10) and x) 66 | if(str.trim().indexOf(" and ")>0 || str.trim().indexOf(" or ")>0){//包含and语句 67 | int andor = sqlStartLogic(str.trim().substring(1));//丢掉第一个原始括弧进行处理 68 | second_split = andor; 69 | 70 | String[] secondArr = null; 71 | String tmp = str.trim().substring(1,str.trim().length()-1);//去掉两端的括弧 72 | if(andor==1){//and 73 | secondArr = tmp.trim().split(" and "); 74 | }else{//or 75 | secondArr = tmp.trim().split(" or "); 76 | } 77 | if(secondArr!=null && secondArr.length>1){ 78 | if(andor==1 && secondArr.length==2){//考虑range情况 (a>10 and a<20) 79 | if(getColumn(secondArr[0]).equals(getColumn(secondArr[1]))){//域相同 80 | if(tmp.indexOf(">")>0 && tmp.indexOf("<")>0){ 81 | levelOneList.add(str); 82 | } 83 | }else{ 84 | levelTwoList = new ArrayList(); 85 | for(String s : secondArr){ 86 | levelTwoList.add(s);//二级查询,不涉及多级包含 87 | } 88 | } 89 | }else if(str.trim().indexOf(" between ")>0){ 90 | StringBuffer stringBuffer = new StringBuffer(); 91 | int i = 0; 92 | levelTwoList = new ArrayList(); 93 | for(String s : secondArr){ 94 | if(i==1){ 95 | stringBuffer.append(" and ").append(s); 96 | levelTwoList.add(stringBuffer.toString()); 97 | stringBuffer = null; 98 | } 99 | if(s.indexOf(" between ")>0){ 100 | stringBuffer.append(s); 101 | i = 1; 102 | }else if(i==0){ 103 | levelTwoList.add(s);//二级查询,不涉及多级包含 104 | } 105 | if(i==1 && stringBuffer == null){ 106 | i=0; 107 | } 108 | } 109 | }else{ 110 | levelTwoList = new ArrayList(); 111 | for(String s : secondArr){ 112 | levelTwoList.add(s);//二级查询,不涉及多级包含 113 | } 114 | } 115 | }else if(secondArr.length==1){//(c='x') 116 | levelOneList.add(tmp); 117 | } 118 | }else{ 119 | String tmp = str.trim().substring(1,str.trim().length()-1);//去掉两端的括弧 120 | levelOneList.add(tmp); 121 | } 122 | } 123 | }else{ 124 | levelOneList.add(str); 125 | } 126 | if(levelTwoList!=null && levelTwoList.size()>0){ 127 | map.put("2_"+second_split+"_"+second_depth++, levelTwoList); 128 | levelTwoList = null; 129 | } 130 | 131 | } 132 | 133 | 134 | map.put("1_"+split, levelOneList); 135 | 136 | for(Map.Entry> entry:map.entrySet()){ 137 | String key = entry.getKey(); 138 | List listx = entry.getValue(); 139 | if(key.startsWith("1_")){ 140 | //System.out.println("---------------------------level one -------------------"); 141 | for(String l1:listx){ 142 | //System.out.println(l1); 143 | } 144 | }else{ 145 | //System.out.println("---------------------------level two -------------------"); 146 | for(String l2:listx){ 147 | //System.out.println(l2); 148 | } 149 | } 150 | } 151 | 152 | 153 | 154 | 155 | return map; 156 | } 157 | 158 | 159 | /** 160 | * where Condition 第一层拆分 161 | * @param whereCondition 162 | * @param split 163 | * @return 164 | */ 165 | private static List splitWhereConditionLevelOne(String whereCondition,int split){ 166 | List list = new ArrayList(); 167 | String[] arr = null; 168 | if(split==1){ 169 | arr = whereCondition.split(" and "); 170 | }else if(split==2){ 171 | arr = whereCondition.split(" or "); 172 | }else if(split==0){ 173 | arr = new String[1]; 174 | arr[0] = whereCondition; 175 | } 176 | for(String str:arr){ 177 | //System.out.println(str); 178 | } 179 | 180 | //System.out.println("-----------------------------------"); 181 | 182 | StringBuffer sBuffer = new StringBuffer(); 183 | 184 | for(String str:arr){ 185 | boolean b = false; 186 | if(str.trim().indexOf("in(")>0){ 187 | b = false; 188 | }else if(str.trim().startsWith("(") ){ 189 | if(str.trim().startsWith("(") && str.trim().endsWith(")")){//括弧配对完整 190 | b=false; 191 | }else{ 192 | sBuffer.append(str); 193 | b = true; 194 | } 195 | }else if(sBuffer.length()>0){ 196 | if(split==1){ 197 | sBuffer.append(" and "+str); 198 | }else if(split==2){ 199 | sBuffer.append(" or "+str); 200 | } 201 | if(str.trim().endsWith(")")){ 202 | list.add(sBuffer.toString()); 203 | sBuffer = new StringBuffer(); 204 | } 205 | b = true; 206 | } 207 | 208 | if(!b){ 209 | list.add(str); 210 | } 211 | } 212 | 213 | for(String string:list){ 214 | //System.out.println(string); 215 | } 216 | return list; 217 | } 218 | 219 | /** 220 | * >= 221 | * <= 222 | * > 223 | * < 224 | * = 225 | * != 226 | * @param str 227 | * @return 228 | */ 229 | private static String getColumn(String str){ 230 | String tmp = ""; 231 | if(str.indexOf(">=")>0){ 232 | tmp = str.substring(0,str.indexOf(">=")).trim(); 233 | }else if(str.indexOf("<=")>0){ 234 | tmp = str.substring(0,str.indexOf("<=")).trim(); 235 | }else if(str.indexOf("!=")>0){ 236 | tmp = str.substring(0,str.indexOf("!=")).trim(); 237 | }else if(str.indexOf("=")>0){ 238 | tmp = str.substring(0,str.indexOf("=")).trim(); 239 | }else if(str.indexOf("<")>0){ 240 | tmp = str.substring(0,str.indexOf("<")).trim(); 241 | }else if(str.indexOf(">")>0){ 242 | tmp = str.substring(0,str.indexOf(">")).trim(); 243 | } 244 | //System.out.println("--------getField-----"+tmp); 245 | return tmp; 246 | } 247 | 248 | /** 249 | * 拆分where Condition ，获取第一层拆分使用and或者or进行 250 | * 0:语句为null，1：and 2：or 251 | * @param whereCondition 252 | * @return 253 | */ 254 | private static int sqlStartLogic(String whereCondition){ 255 | 256 | String where = whereCondition; 257 | if(StringUtils.isEmpty(where)){ 258 | return 0; 259 | } 260 | int split = 1;//and 261 | if(where.trim().startsWith("(")){ 262 | 263 | String tmp = where.substring(getPoint(whereCondition)+1); 264 | if(tmp.trim().startsWith("and")){ 265 | split =1; 266 | }else if(tmp.trim().startsWith("or")){ 267 | split=2; 268 | } 269 | }else if(where.indexOf(" and ")>0 || where.indexOf(" or ")>0){ 270 | int x = where.indexOf("and"); 271 | int y = where.indexOf("or"); 272 | if(x>0 && y>0){ 273 | if(x>y){ 274 | split =2; 275 | }else{ 276 | split =1; 277 | } 278 | }else if(x>0 && y<0){ 279 | split =1; 280 | }else if(x<0 && y>0){ 281 | split =2; 282 | } 283 | }else{//单一条件 284 | split = 0; 285 | } 286 | return split; 287 | } 288 | 289 | private static int getPoint(String whereCondition){ 290 | int x = 0; 291 | int y = 0; 292 | int point = 0; 293 | for(int i=0;i0){ 303 | break; 304 | } 305 | } 306 | return point; 307 | } 308 | 309 | } 310 | -------------------------------------------------------------------------------- /ElasticSearch-SQL/src/com/es/sql/util/SqlParser.java: -------------------------------------------------------------------------------- 1 | package com.es.sql.util; 2 | 3 | import java.util.ArrayList; 4 | import java.util.List; 5 | import java.util.regex.Matcher; 6 | import java.util.regex.Pattern; 7 | 8 | /** 9 | * SQL语句解析器类 10 | */ 11 | public class SqlParser{ 12 | /** 13 | * 逗号 14 | */ 15 | private static final String Comma = ","; 16 | 17 | /** 18 | * 四个空格 19 | */ 20 | private static final String FourSpace = " "; 21 | 22 | /** 23 | * 是否单行显示字段，表，条件的标识量 24 | */ 25 | private static boolean isSingleLine=true; 26 | 27 | /** 28 | * 待解析的SQL语句 29 | */ 30 | private String sql; 31 | 32 | /** 33 | * SQL中选择的列 34 | */ 35 | private String cols; 36 | 37 | /** 38 | * SQL中查找的表 39 | */ 40 | private String tables; 41 | 42 | /** 43 | * 查找条件 44 | */ 45 | private String conditions; 46 | 47 | /** 48 | * Group By的字段 49 | */ 50 | private String groupCols; 51 | 52 | /** 53 | * Order by的字段 54 | */ 55 | private String orderCols; 56 | 57 | /** 58 | * 构造函数 59 | * 功能：传入构造函数，解析成字段，表，条件等 60 | * @param sql：传入的SQL语句 61 | */ 62 | public SqlParser(String sql){ 63 | this.sql=sql.trim(); 64 | 65 | parseCols(); 66 | parseTables(); 67 | parseConditions(); 68 | parseGroupCols(); 69 | parseOrderCols(); 70 | } 71 | 72 | /** 73 | * 解析选择的列 74 | * 75 | */ 76 | private void parseCols(){ 77 | String regex="(select)(.+)(from)"; 78 | cols=getMatchedString(regex,sql); 79 | } 80 | 81 | /** 82 | * 解析选择的表 83 | * 84 | */ 85 | private void parseTables(){ 86 | String regex=""; 87 | 88 | if(isContains(sql,"\\s+where\\s+")){ 89 | regex="(from)(.+)(where)"; 90 | } 91 | else{ 92 | regex="(from)(.+)($)"; 93 | } 94 | 95 | tables=getMatchedString(regex,sql); 96 | } 97 | 98 | /** 99 | * 解析查找条件 100 | * 101 | */ 102 | private void parseConditions(){ 103 | String regex=""; 104 | 105 | if(isContains(sql,"\\s+where\\s+")){ 106 | // 包括Where，有条件 107 | 108 | if(isContains(sql,"group\\s+by")){ 109 | // 条件在where和group by之间 110 | regex="(where)(.+)(group\\s+by)"; 111 | } 112 | else if(isContains(sql,"order\\s+by")){ 113 | // 条件在where和order by之间 114 | regex="(where)(.+)(order\\s+by)"; 115 | } 116 | else{ 117 | // 条件在where到字符串末尾 118 | regex="(where)(.+)($)"; 119 | } 120 | } 121 | else{ 122 | // 不包括where则条件无从谈起，返回即可 123 | return; 124 | } 125 | 126 | conditions=getMatchedString(regex,sql); 127 | System.out.println(conditions); 128 | } 129 | 130 | /** 131 | * 解析GroupBy的字段 132 | * 133 | */ 134 | private void parseGroupCols(){ 135 | String regex=""; 136 | 137 | if(isContains(sql,"group\\s+by")){ 138 | // 包括GroupBy，有分组字段 139 | 140 | if(isContains(sql,"order\\s+by")){ 141 | // group by 后有order by 142 | regex="(group\\s+by)(.+)(order\\s+by)"; 143 | } 144 | else{ 145 | // group by 后无order by 146 | regex="(group\\s+by)(.+)($)"; 147 | } 148 | } 149 | else{ 150 | // 不包括GroupBy则分组字段无从谈起，返回即可 151 | return; 152 | } 153 | 154 | groupCols=getMatchedString(regex,sql); 155 | } 156 | 157 | /** 158 | * 解析OrderBy的字段 159 | * 160 | */ 161 | private void parseOrderCols(){ 162 | String regex=""; 163 | 164 | if(isContains(sql,"order\\s+by")){ 165 | // 包括GroupBy，有分组字段 166 | regex="(order\\s+by)(.+)($)"; 167 | } 168 | else{ 169 | // 不包括GroupBy则分组字段无从谈起，返回即可 170 | return; 171 | } 172 | 173 | orderCols=getMatchedString(regex,sql); 174 | } 175 | 176 | 177 | /** 178 | * 从文本text中找到regex首次匹配的字符串，不区分大小写 179 | * @param regex：正则表达式 180 | * @param text：欲查找的字符串 181 | * @return regex首次匹配的字符串，如未匹配返回空 182 | */ 183 | private static String getMatchedString(String regex,String text){ 184 | Pattern pattern=Pattern.compile(regex,Pattern.CASE_INSENSITIVE); 185 | 186 | Matcher matcher=pattern.matcher(text); 187 | 188 | while(matcher.find()){ 189 | return matcher.group(2); 190 | } 191 | 192 | return null; 193 | } 194 | 195 | /** 196 | * 看word是否在lineText中存在，支持正则表达式 197 | * @param lineText 198 | * @param word 199 | * @return 200 | */ 201 | private static boolean isContains(String lineText,String word){ 202 | Pattern pattern=Pattern.compile(word,Pattern.CASE_INSENSITIVE); 203 | Matcher matcher=pattern.matcher(lineText); 204 | return matcher.find(); 205 | } 206 | 207 | 208 | public String toString(){ 209 | // 无法解析则原样返回 210 | if(cols==null && tables==null && conditions==null && groupCols==null && orderCols==null ){ 211 | return sql; 212 | } 213 | 214 | StringBuffer sb=new StringBuffer(); 215 | sb.append("原SQL为"+sql+"\n"); 216 | sb.append("解析后的SQL为\n"); 217 | 218 | 219 | for(String str:getParsedSqlList()){ 220 | sb.append(str); 221 | } 222 | 223 | sb.append("\n"); 224 | 225 | return sb.toString(); 226 | } 227 | 228 | /** 229 | * 在分隔符后加上回车 230 | * @param str 231 | * @param splitStr 232 | * @return 233 | */ 234 | private static String getAddEnterStr(String str,String splitStr){ 235 | Pattern p = Pattern.compile(splitStr,Pattern.CASE_INSENSITIVE); 236 | 237 | // 用Pattern类的matcher()方法生成一个Matcher对象 238 | Matcher m = p.matcher(str); 239 | StringBuffer sb = new StringBuffer(); 240 | 241 | // 使用find()方法查找第一个匹配的对象 242 | boolean result = m.find(); 243 | 244 | // 使用循环找出模式匹配的内容替换之,再将内容加到sb里 245 | while (result) { 246 | m.appendReplacement(sb, m.group(0) + "\n "); 247 | result = m.find(); 248 | } 249 | // 最后调用appendTail()方法将最后一次匹配后的剩余字符串加到sb里； 250 | m.appendTail(sb); 251 | 252 | return FourSpace+sb.toString(); 253 | } 254 | 255 | /** 256 | * 取得解析的SQL字符串列表 257 | * @return 258 | */ 259 | public List getParsedSqlList(){ 260 | List sqlList=new ArrayList(); 261 | 262 | // 无法解析则原样返回 263 | if(cols==null && tables==null && conditions==null && groupCols==null && orderCols==null ){ 264 | sqlList.add(sql); 265 | return sqlList; 266 | } 267 | 268 | if(cols!=null){ 269 | sqlList.add("select\n"); 270 | if(isSingleLine){ 271 | sqlList.add(getAddEnterStr(cols,Comma)); 272 | } 273 | else{ 274 | sqlList.add(FourSpace+cols); 275 | } 276 | } 277 | 278 | if(tables!=null){ 279 | sqlList.add(" \nfrom\n"); 280 | 281 | if(isSingleLine){ 282 | sqlList.add(getAddEnterStr(tables,Comma)); 283 | } 284 | else{ 285 | sqlList.add(FourSpace+tables); 286 | } 287 | } 288 | 289 | if(conditions!=null){ 290 | sqlList.add(" \nwhere\n"); 291 | 292 | if(isSingleLine){ 293 | sqlList.add(getAddEnterStr(conditions,"(and|or)")); 294 | } 295 | else{ 296 | sqlList.add(FourSpace+conditions); 297 | } 298 | } 299 | 300 | if(groupCols!=null){ 301 | sqlList.add(" \ngroup by\n"); 302 | 303 | if(isSingleLine){ 304 | sqlList.add(getAddEnterStr(groupCols,Comma)); 305 | } 306 | else{ 307 | sqlList.add(FourSpace+groupCols); 308 | } 309 | } 310 | 311 | if(orderCols!=null){ 312 | sqlList.add(" \norder by\n"); 313 | 314 | if(isSingleLine){ 315 | sqlList.add(getAddEnterStr(orderCols,Comma)); 316 | } 317 | else{ 318 | sqlList.add(FourSpace+orderCols); 319 | } 320 | } 321 | 322 | return sqlList; 323 | } 324 | 325 | /** 326 | * 设置是否单行显示表，字段，条件等 327 | * @param isSingleLine 328 | */ 329 | public static void setSingleLine(boolean isSingleLine) { 330 | SqlParser.isSingleLine = isSingleLine; 331 | } 332 | 333 | /** 334 | * 测试 335 | * @param args 336 | */ 337 | public static void main(String[] args){ 338 | List ls=new ArrayList(); 339 | /* 340 | ls.add("select * from dual"); 341 | ls.add("SELECT * frOm dual"); 342 | ls.add("Select C1,c2 From tb"); 343 | ls.add("select c1,c2 from tb"); 344 | ls.add("select count(*) from t1"); 345 | ls.add("select c1,c2,c3 from t1 where condi1=1 "); 346 | ls.add("Select c1,c2,c3 From t1 Where condi1=1 "); 347 | ls.add("select c1,c2,c3 from t1,t2 where condi3=3 or condi4=5 order by o1,o2"); 348 | ls.add("Select c1,c2,c3 from t1,t2 Where condi3=3 or condi4=5 Order by o1,o2"); 349 | ls.add("select c1,c2,c3 from t1,t2,t3 where condi1=5 and condi6=6 or condi7=7 group by g1,g2"); 350 | ls.add("Select c1,c2,c3 From t1,t2,t3 Where condi1=5 and condi6=6 or condi7=7 Group by g1,g2"); 351 | ls.add("Select c1,c2,c3 From t1,t2,t3 Where condi1=5 and condi6=6 or condi7=7 Group by g1,g2,g3 order by g2,g3"); 352 | */ 353 | ls.add("select vip.userid ,hti.install_date ,vip.economy_date ,datediff(vip.economy_date,hti.install_date) as age ,vip.amount ,vip.val ,vip.classfield ,vip.family from (select t2.userid,t1.economy_date,t1.classfield,t1.family,t1.val,t1.amount from (select userid as game_uid,economy_date,classfield,family,val,amount,clientid from shenqu.shenqu_economy where snid=11 and gameid=91 and ds>='2013-12-21' and currency='diamond' and kingdom='expenditure' and phylum='VIP' ) t1 join (select distinct userid as game_uid,platformid as userid,clientid from shenqu.shenqu_nickname where snid=11 and gameid=91 and ds>='2013-12-21')t2 on t1.game_uid=t2.game_uid and t1.clientid=t2.clientid ) vip join (select userid,MIN(install_date) install_date from ht_install where snid=11 and gameid=91 and ds>='2013-12-21' group by userid) hti on hti.userid=vip.userid"); 354 | for(String sql:ls){ 355 | System.out.println(new SqlParser(sql)); 356 | //System.out.println(sql); 357 | //new SqlParser(sql); 358 | } 359 | } 360 | } 361 | -------------------------------------------------------------------------------- /ElasticSearch-SQL/src/com/es/sql/query/QueryParserHandler.java: -------------------------------------------------------------------------------- 1 | package com.es.sql.query; 2 | 3 | import java.util.List; 4 | import java.util.Map; 5 | import java.util.Map.Entry; 6 | 7 | import org.apache.commons.lang.StringUtils; 8 | import org.elasticsearch.action.search.SearchRequestBuilder; 9 | import org.elasticsearch.action.search.SearchResponse; 10 | import org.elasticsearch.action.support.IndicesOptions; 11 | import org.elasticsearch.client.Client; 12 | import org.elasticsearch.common.settings.Settings; 13 | import org.elasticsearch.index.query.FilterBuilder; 14 | import org.elasticsearch.index.query.QueryBuilder; 15 | import org.elasticsearch.index.query.QueryBuilders; 16 | import org.elasticsearch.search.aggregations.AggregationBuilder; 17 | import org.elasticsearch.search.aggregations.AggregationBuilders; 18 | import org.elasticsearch.search.sort.SortBuilder; 19 | 20 | import com.es.sql.parse.QuerySqlParser; 21 | import com.es.sql.util.CommonUtils; 22 | import com.es.sql.util.EsUtil; 23 | import com.es.sql.util.CommonConstant.DataType; 24 | import com.es.sql.util.CommonConstant.Operator; 25 | 26 | /** 27 | * Api入口 28 | * @author wangyong 29 | * 30 | */ 31 | public class QueryParserHandler { 32 | 33 | 34 | public static void main(String[] args) { 35 | //分组 36 | /*String sql = "query:select ds,serverid,count(distinct userid) as count from index.segment where (appid='10xxxx' and what='item' and (ds between '2014-08-12' and '2014-08-13') and tz='+8') or (axt in(1,2,3) and a='t') or is_admin=1 group by ds,serverid order by count desc limit 0,100"; 37 | 38 | SearchResponse searchResponse = handler(sql.trim()); 39 | 40 | System.out.println(searchResponse.toString());*/ 41 | //String sql = "filter:select state,city,count(distinct account_number) as count from bank where gender='M' and age>10 group by state,city"; 42 | //String sql = "filter:select state,city,sum(balance) as total from bank where gender='M' and age>10 group by state,city"; 43 | //String sql = "filter:select state,avg(balance) as total from bank where gender='M' and age>20 group by state"; 44 | //String sql = "filter:select state,max(balance) as total from bank where gender='M' group by state"; 45 | //String sql = "query:select * from bank where gender='M' and age>30"; 46 | //String sql = "query:select * from bank where gender='M' and age in(30,31,32)"; 47 | //String sql = "query:select * from bank where gender='M'"; 48 | //String sql = "query:select * from bank where id=9BnH0MToTvWMHwikTb-uhA"; 49 | //String sql = "query:select * from bank where (gender='M' and age>=40) or (balance>40000)"; 50 | //String sql = "query:select * from bank where (gender='M' and age>=40) or (balance between 40000 and 44000)"; 51 | //String sql = "query:select * from bank where (gender='M' and age>=40) or (balance>40000) limit 10"; 52 | //String sql = "query:select * from bank where gender='M' and age>=30 and (balance between 40000 and 44000)"; 53 | //String sql = "query:select * from bank where gender='M' and age>=30 and (balance between 40000 and 44000) and state in('id','wy')"; 54 | //String sql = "query:select state,max(balance) from bank where gender='M' and age>=30 and state in('id','wy') group by state"; 55 | //String sql = "query:select * from bank where firstname like '%beck%'"; 56 | //String sql = "query:select * from bank where gender='M' and (age>=30 and age<35)"; 57 | 58 | //String sql = "select sum(who.s) from events where context.channlid.s in(1,2,3,4) and context.serverid.s in('s1','s2') and what.s='item' group by context.serverid.s"; 59 | 60 | //对多index支持，对sort排序测试， 61 | //String sql = "select * from bank.account order by age desc,account_number asc"; 62 | //String sql = "select age,sum(balance) from bank.account group by age order by age desc"; 63 | 64 | //------------------------------------------------------------------------------ 65 | //String sql = "select stats(balance) from bank.account group by age"; 66 | //String sql = "select count(distinct account_number) from bank.account group by age"; 67 | //String sql = "select stats(balance) from bank.account group by state,age[*-20|20-25|25-30|30-35|35-40|40-*]"; 68 | 69 | //String sql = "select stats(balance) from bank.account group by (age[*-20|20-25|25-30|30-35|35-40|40-*]),(state)"; 70 | 71 | //String sql = "select stats(balance) from bank.account group by (state,age[*-20|20-25|25-30|30-35|35-40|40-*]),(city)"; 72 | 73 | //String sql = "select account_number,age,balance from bank where age>25"; 74 | 75 | //String sql = "select account_number,age,balance from bank where age>25 order by balance desc"; 76 | 77 | //String sql = "select stats(balance) from bank2.account2 group by age[histogram_5]"; 78 | 79 | //String sql = "select stats(balance) from bank2.account2 group by state,age[histogram_5]"; 80 | 81 | //String sql = "select stats(balance) from bank2.account2 group by createtime[datehistogram_2day]"; 82 | 83 | //String sql = "select stats(balance) from bank2.account2 group by state,createtime[datehistogram_2day]"; 84 | 85 | //String sql = "select appid.s,what.s from [segments.20140902].segments group by appid.s,what.s"; 86 | 87 | //对query/filter分离查询 88 | 89 | //String sql = "select appid.s,what.s from [segments.20140909-new] group by appid.s,what.s"; 90 | 91 | //String sql = "select * from [segments.20140902].segments where appid.s ='982da2ae92188e5f73fbf7f82e41ed65' and what.s='item' limit 1"; 92 | 93 | //String sql = "select appid.s, count(who.s) from [events.20140909].events group by appid.s,when.d[datehistogram_5minute_(yyyy-MM-dd HH:mm)_{min:2014-09-09 00:00&max:2014-09-09 23:55}]"; 94 | 95 | String sql = "select count(who.s) from [events.20140910].events,[events.2014] where what.s='hb' and appid.s='982da2ae92188e5f73fbf7f82e41ed65' group by when.d[datehistogram_5minute_(yyyy-MM-dd HH:mm)_{min#2014-09-10 00:00&max#2014-09-10 23:55}]"; 96 | 97 | //String sql = "select count(who.s) from [events.20140909].events where what.s='hb' and appid.s='982da2ae92188e5f73fbf7f82e41ed65' and (when.d between '2014-09-09' and '2014-09-09') group by when.d[datehistogram_5minute_(HH:mm)]"; 98 | 99 | EsUtil.initClient(true, "elasticsearch", new String[]{"x00:9300","x01:9300"}); 100 | 101 | QuerySqlParser qsp = new QuerySqlParser(sql.trim()); 102 | 103 | SearchResponse response = handler(qsp,sql.trim()); 104 | 105 | 106 | System.out.println(response.toString()); 107 | 108 | //聚合结果集解析。。。。。。。。。。。。。。。。。。。。只针对聚合函数，普通查询可以API接口直接查询 109 | 110 | Map> map = AggregationResultParser.resultParser3(response,qsp); 111 | 112 | for(Map.Entry> entry : map.entrySet()){ 113 | Integer key = entry.getKey(); 114 | Map rmap = entry.getValue(); 115 | System.out.println(key+"---------------------------------------------------"); 116 | for(Map.Entry entry2:rmap.entrySet()){ 117 | System.out.println(entry2.getKey()+" "+entry2.getValue()); 118 | } 119 | 120 | } 121 | 122 | } 123 | 124 | 125 | 126 | public static SearchResponse handler(QuerySqlParser qsp,String sql){ 127 | sql = sql.trim(); 128 | int handler_type = 1;//1:filter 2:query 129 | if(sql.startsWith("filter:")){ 130 | sql = sql.substring("filter:".length()); 131 | handler_type = 1; 132 | }else if(sql.startsWith("query:")){ 133 | sql = sql.substring("query:".length()); 134 | handler_type = 2; 135 | }else{ 136 | handler_type = 1; 137 | } 138 | //System.out.println(sql.toString()); 139 | 140 | 141 | SearchResponse searchResponse = null; 142 | if(SyntaxCheck.checkSyntax(qsp)){ 143 | 144 | Client client = EsUtil.getClient(); 145 | 146 | int flag = 0; 147 | if(StringUtils.isNotEmpty(qsp.getWhereCondition())){ 148 | flag = isIdQuery(qsp.getWhereCondition().trim()); 149 | } 150 | 151 | if(StringUtils.isNotEmpty(qsp.getGroupCondition())){//聚合查询 152 | 153 | searchResponse = aggregationHandler(qsp, client); 154 | 155 | }else if(flag==1){//id查询 156 | 157 | searchResponse = queryById(qsp, client); 158 | 159 | }else if(flag ==2){//单一条件查询,已经冗余在普通查询中 160 | 161 | searchResponse = singleConditionQuery(qsp, client); 162 | 163 | }else {//普通查询 164 | 165 | searchResponse = commonQueryHandler(qsp, client); 166 | 167 | } 168 | 169 | }else{ 170 | System.out.println("sql 语法错误，请检查后在提交查询！"); 171 | } 172 | 173 | return searchResponse; 174 | } 175 | 176 | 177 | /** 178 | * 单一条件查询 179 | * @param qsp 180 | * @param client 181 | * @return 182 | */ 183 | private static SearchResponse singleConditionQuery(QuerySqlParser qsp,Client client){ 184 | SearchResponse searchResponse = null; 185 | try{ 186 | searchResponse = commonQueryHandler(qsp, client); 187 | }catch (Exception e) { 188 | e.printStackTrace(); 189 | } 190 | return searchResponse; 191 | } 192 | 193 | /** 194 | * 直接进行id查询 195 | * @param qsp 196 | * @param client 197 | * @return 198 | */ 199 | private static SearchResponse queryById(QuerySqlParser qsp,Client client){ 200 | SearchResponse searchResponse = null; 201 | try{ 202 | String[] values = null; 203 | 204 | //id 查询 205 | String where = qsp.getWhereCondition(); 206 | if(where.indexOf(" in")>0){//in条件查询,一次查询多个id 207 | Map map = CommonUtils.getValues(where, 1); 208 | for(Map.Entry entry : map.entrySet()){ 209 | values = entry.getValue(); 210 | //System.out.println(values+"------------------------"); 211 | } 212 | 213 | }else{ 214 | String[] arr = where.split("="); 215 | values = new String[1]; 216 | values[0] = arr[1].trim(); 217 | } 218 | QueryBuilder queryBuilder = null; 219 | if(values.length>0){ 220 | queryBuilder = QueryBuilders.idsQuery().ids(values); 221 | } 222 | 223 | String from = qsp.getFromTable(); 224 | String[] indexArr = from.split(",");//index1.x,index2.y,index3 225 | 226 | StringBuffer indexBuffer = new StringBuffer(); 227 | StringBuffer typeBuffer = new StringBuffer(); 228 | for(String str:indexArr){ 229 | str = str.trim(); 230 | if(str.startsWith("[") && str.indexOf("]")>0){ 231 | String x = str.substring(1,str.indexOf("]")); 232 | if(x.length()+2==str.length()){ 233 | indexBuffer.append(x).append("\001"); 234 | }else{ 235 | String y = str.substring(str.lastIndexOf(".")+1); 236 | indexBuffer.append(x).append("\001"); 237 | typeBuffer.append(y).append("\001"); 238 | } 239 | }else{ 240 | String[] x = str.split("\\."); 241 | if(x.length==1){ 242 | indexBuffer.append(x[0]).append("\001"); 243 | }else{ 244 | indexBuffer.append(x[0]).append("\001"); 245 | typeBuffer.append(x[1]).append("\001"); 246 | } 247 | } 248 | } 249 | String[] index = indexBuffer.toString().substring(0,(indexBuffer.toString().length()-"\001".length())).split("\001"); 250 | 251 | String[] type = null; 252 | if(typeBuffer.toString().length()>0){ 253 | type = typeBuffer.toString().substring(0,(typeBuffer.toString().length()-"\001".length())).split("\001"); 254 | } 255 | IndicesOptions options = IndicesOptions.fromOptions(EsUtil.isIgnore_unavailable(), EsUtil.isAllow_no_indices(), true, true); 256 | 257 | SearchRequestBuilder sqb = client.prepareSearch(CommonUtils.trimStrings(index)).setIndicesOptions(options); 258 | 259 | 260 | if(type!=null && type.length>0){ 261 | sqb.setTypes(CommonUtils.trimStrings(type)); 262 | } 263 | 264 | if(queryBuilder!=null){ 265 | sqb.setQuery(queryBuilder); 266 | } 267 | 268 | 269 | String select = qsp.getSelectCol().trim(); 270 | String[] fields = null; 271 | if(StringUtils.isNotEmpty(select)){ 272 | if(select.length()==1 && select.indexOf("*")>0){//select * from 。。。 273 | 274 | }else{ 275 | fields = select.split(","); 276 | 277 | } 278 | 279 | } 280 | if(fields!=null && fields.length>0){ 281 | searchResponse = sqb.execute().actionGet(); 282 | }else{ 283 | searchResponse = sqb.addFields(fields).execute().actionGet(); 284 | } 285 | }catch (Exception e) { 286 | e.printStackTrace(); 287 | } 288 | 289 | return searchResponse; 290 | } 291 | 292 | /** 293 | * 普通查询 294 | * @param qsp 295 | * @param client 296 | * @return 297 | */ 298 | private static SearchResponse commonQueryHandler(QuerySqlParser qsp,Client client){ 299 | SearchResponse searchResponse = null; 300 | try{ 301 | QueryBuilder queryBuilder = QueryCommonHandler.getQueryBuilder(qsp); 302 | 303 | List list = QuerySortHandler.getSortBuilder(qsp); 304 | int start = 0; 305 | int size = 100; 306 | String limit = qsp.getLimitCondition(); 307 | if(StringUtils.isNotEmpty(limit)){ 308 | String[] arr = limit.split(","); 309 | 310 | if(arr.length<=2){ 311 | if(arr.length==2){ 312 | start = Integer.parseInt(arr[0].trim()); 313 | size = Integer.parseInt(arr[1].trim()); 314 | }else{ 315 | size = Integer.parseInt(arr[0].trim()); 316 | } 317 | } 318 | } 319 | String from = qsp.getFromTable(); 320 | String[] indexArr = from.split(",");//index1.x,index2.y,index3 321 | 322 | StringBuffer indexBuffer = new StringBuffer(); 323 | StringBuffer typeBuffer = new StringBuffer(); 324 | for(String str:indexArr){ 325 | str = str.trim(); 326 | if(str.startsWith("[") && str.indexOf("]")>0){ 327 | String x = str.substring(1,str.indexOf("]")); 328 | if(x.length()+2==str.length()){ 329 | indexBuffer.append(x).append("\001"); 330 | }else{ 331 | String y = str.substring(str.lastIndexOf(".")+1); 332 | indexBuffer.append(x).append("\001"); 333 | typeBuffer.append(y).append("\001"); 334 | } 335 | }else{ 336 | String[] x = str.split("\\."); 337 | if(x.length==1){ 338 | indexBuffer.append(x[0]).append("\001"); 339 | }else{ 340 | indexBuffer.append(x[0]).append("\001"); 341 | typeBuffer.append(x[1]).append("\001"); 342 | } 343 | } 344 | } 345 | String[] index = indexBuffer.toString().substring(0,(indexBuffer.toString().length()-"\001".length())).split("\001"); 346 | String[] type = null; 347 | if(typeBuffer.toString().length()>0){ 348 | type = typeBuffer.toString().substring(0,(typeBuffer.toString().length()-"\001".length())).split("\001"); 349 | } 350 | IndicesOptions options = IndicesOptions.fromOptions(EsUtil.isIgnore_unavailable(), EsUtil.isAllow_no_indices(), true, true); 351 | 352 | SearchRequestBuilder sqb = client.prepareSearch(CommonUtils.trimStrings(index)).setIndicesOptions(options); 353 | 354 | 355 | if(type!=null && type.length>0){ 356 | sqb.setTypes(CommonUtils.trimStrings(type)); 357 | } 358 | if(queryBuilder!=null){ 359 | sqb.setQuery(queryBuilder); 360 | } 361 | if(list!=null && list.size()>0){ 362 | for(SortBuilder sBuilder:list){ 363 | sqb.addSort(sBuilder); 364 | } 365 | } 366 | 367 | String select = qsp.getSelectCol().trim(); 368 | String[] fields = null; 369 | if(StringUtils.isNotEmpty(select)){ 370 | if(select.length()==1 && select.indexOf("*")>=0){//select * from 。。。 371 | 372 | }else{ 373 | fields = select.split(","); 374 | 375 | } 376 | 377 | } 378 | if(fields!=null && fields.length>0){ 379 | sqb.addFields(fields); 380 | } 381 | 382 | sqb.setFrom(start).setSize(size); 383 | 384 | searchResponse = sqb.execute().actionGet(); 385 | }catch (Exception e) { 386 | e.printStackTrace(); 387 | } 388 | 389 | return searchResponse; 390 | } 391 | 392 | /** 393 | * 聚合处理 394 | * @param qsp 395 | * @param client 396 | * @return 397 | */ 398 | private static SearchResponse aggregationHandler(QuerySqlParser qsp,Client client){ 399 | SearchResponse searchResponse = null; 400 | try{ 401 | 402 | /** 403 | * 使用Filter Query 进行拼接 404 | */ 405 | FilterBuilder filterBuilder = QueryFilterHandler.getFilterBuilder(qsp); 406 | 407 | /** 408 | * 获取聚合查询条件 409 | */ 410 | AggregationBuilder aggregationBuilder = QueryAggregationHandler.getAggregationBuilder(qsp,filterBuilder); 411 | 412 | 413 | //System.out.println(aggregationBuilder.toString()); 414 | //System.out.println("------------------------------------------------"); 415 | if(filterBuilder!=null){ 416 | //System.out.println(filterBuilder.toString()); 417 | } 418 | 419 | List list = QuerySortHandler.getSortBuilder(qsp); 420 | 421 | int start = 0; 422 | int size = 100; 423 | String limit = qsp.getLimitCondition(); 424 | if(StringUtils.isNotEmpty(limit)){ 425 | String[] arr = limit.split(","); 426 | if(arr.length<=2){ 427 | if(arr.length==2){ 428 | start = Integer.parseInt(arr[0].trim()); 429 | size = Integer.parseInt(arr[1].trim()); 430 | }else{ 431 | size = Integer.parseInt(arr[0].trim()); 432 | } 433 | } 434 | } 435 | String from = qsp.getFromTable(); 436 | String[] indexArr = from.split(",");//index1.x,index2.y,index3 437 | StringBuffer indexBuffer = new StringBuffer(); 438 | StringBuffer typeBuffer = new StringBuffer(); 439 | for(String str:indexArr){ 440 | str = str.trim(); 441 | if(str.startsWith("[") && str.indexOf("]")>0){ 442 | String x = str.substring(1,str.indexOf("]")); 443 | if(x.length()+2==str.length()){ 444 | indexBuffer.append(x).append("\001"); 445 | }else{ 446 | String y = str.substring(str.lastIndexOf(".")+1); 447 | indexBuffer.append(x).append("\001"); 448 | typeBuffer.append(y).append("\001"); 449 | } 450 | }else{ 451 | String[] x = str.split("\\."); 452 | if(x.length==1){ 453 | indexBuffer.append(x[0]).append("\001"); 454 | }else{ 455 | indexBuffer.append(x[0]).append("\001"); 456 | typeBuffer.append(x[1]).append("\001"); 457 | } 458 | } 459 | } 460 | String[] index = indexBuffer.toString().substring(0,(indexBuffer.toString().length()-"\001".length())).split("\001"); 461 | String[] type = null; 462 | if(typeBuffer.toString().length()>0){ 463 | type = typeBuffer.toString().substring(0,(typeBuffer.toString().length()-"\001".length())).split("\001"); 464 | } 465 | IndicesOptions options = IndicesOptions.fromOptions(EsUtil.isIgnore_unavailable(), EsUtil.isAllow_no_indices(), true, true); 466 | 467 | SearchRequestBuilder sqb = client.prepareSearch(CommonUtils.trimStrings(index)).setIndicesOptions(options); 468 | 469 | 470 | if(type!=null && type.length>0){ 471 | sqb.setTypes(CommonUtils.trimStrings(type)); 472 | } 473 | /*if(filterBuilder!=null){ 474 | sqb.setPostFilter(filterBuilder); 475 | }*/ 476 | if(aggregationBuilder!=null){ 477 | sqb.addAggregation(aggregationBuilder); 478 | } 479 | 480 | if(list!=null && list.size()>0){ 481 | for(SortBuilder sBuilder:list){ 482 | sqb.addSort(sBuilder); 483 | } 484 | } 485 | 486 | //sqb.setFrom(start).setSize(size); 487 | sqb.setSize(0);//聚合函数，不需要设置size，size针对普通query sql 488 | 489 | searchResponse = sqb.execute().actionGet(); 490 | }catch (Exception e) { 491 | e.printStackTrace(); 492 | } 493 | 494 | return searchResponse; 495 | } 496 | 497 | /** 498 | * 判断是否是id查询 499 | * @param whereCondition 500 | * @return 501 | */ 502 | private static int isIdQuery(String whereCondition){ 503 | int flag =0;//0:多条件查询 1：id查询 2：单一条件查询 504 | try{ 505 | if(whereCondition.indexOf(" and ")>0 || whereCondition.indexOf(" or ")>0){ 506 | flag = 0; 507 | if(whereCondition.indexOf(" between ")>0 && whereCondition.indexOf(" or ")<0){ 508 | if(whereCondition.indexOf(" and ") == whereCondition.lastIndexOf(" and ")){//只有一个and 没有or 有between 509 | flag = 2; 510 | } 511 | } 512 | }else if(whereCondition.startsWith("id") && 513 | (whereCondition.indexOf("=")>0 && 514 | !((whereCondition.indexOf("in(")>0||whereCondition.indexOf("in (")>0) || 515 | (whereCondition.indexOf("not in(")>0||whereCondition.indexOf("not in (")>0)))){ 516 | flag = 1; 517 | }else{ 518 | flag = 2; 519 | } 520 | }catch (Exception e) { 521 | e.printStackTrace(); 522 | } 523 | 524 | return flag; 525 | } 526 | 527 | 528 | 529 | 530 | } 531 | -------------------------------------------------------------------------------- /ElasticSearch-SQL/src/com/es/sql/query/QueryAggregationHandler.java: -------------------------------------------------------------------------------- 1 | package com.es.sql.query; 2 | 3 | import java.util.ArrayList; 4 | import java.util.HashMap; 5 | import java.util.List; 6 | import java.util.Map; 7 | 8 | import org.apache.commons.lang.StringUtils; 9 | import org.elasticsearch.index.query.FilterBuilder; 10 | import org.elasticsearch.index.query.FilterBuilders; 11 | import org.elasticsearch.search.aggregations.AggregationBuilder; 12 | import org.elasticsearch.search.aggregations.AggregationBuilders; 13 | import org.elasticsearch.search.aggregations.bucket.filter.FilterAggregationBuilder; 14 | import org.elasticsearch.search.aggregations.bucket.histogram.DateHistogram.Interval; 15 | import org.elasticsearch.search.aggregations.bucket.range.RangeBuilder; 16 | 17 | import com.es.sql.parse.QuerySqlParser; 18 | import com.es.sql.util.EsUtil; 19 | 20 | /** 21 | * 聚合处理 22 | * 23 | * @author wangyong 24 | * 25 | */ 26 | public class QueryAggregationHandler { 27 | 28 | private enum Operation { 29 | COUNT, SUM, AVG, MAX, MIN, STATS 30 | } 31 | 32 | /** 33 | * @param args 34 | */ 35 | public static void main(String[] args) { 36 | // TODO Auto-generated method stub 37 | System.out.println(getField("distinct", 38 | "count(distinct account_number)")); 39 | System.out.println(getField("(", "sum(balance)")); 40 | } 41 | 42 | /** 43 | * group by handler 44 | * 45 | * @param qsp 46 | * @return 47 | */ 48 | public static AggregationBuilder getAggregationBuilder(QuerySqlParser qsp, 49 | FilterBuilder filterBuilder) { 50 | 51 | AggregationBuilder aggregationBuilder = null; 52 | 53 | String group = qsp.getGroupCondition().trim(); 54 | if (StringUtils.isEmpty(group)) { 55 | return null; 56 | } 57 | try { 58 | Map> map = new HashMap>(); 59 | if (group.startsWith("(")) {// 可能多层嵌套group存在 60 | //(city,age[*-20|20-25|25-30|30-35|35-40|40-*],state),(city,state),(age,account_number) 61 | 62 | List list = splitGroupBy(group); 63 | for(int i=0;i list1 = getAggregationBuilderSimpleGroupBy(list.get(i)); 65 | map.put(i, list1); 66 | } 67 | 68 | } else{// 普通 69 | //city,age[*-20|20-25|25-30|30-35|35-40|40-*],state 70 | //city,state 71 | List list1 = getAggregationBuilderSimpleGroupBy(group); 72 | map.put(1, list1); 73 | } 74 | 75 | aggregationBuilder = AggregationBuilders.global("all_agg"); 76 | 77 | List mutliValues = new ArrayList(); 78 | 79 | for(Map.Entry> entry: map.entrySet()){ 80 | List list = entry.getValue(); 81 | AggregationBuilder aggregationBuilder2 = null; 82 | if (list.size() > 0) { 83 | aggregationBuilder2 = list.get(list.size() - 1); 84 | 85 | aggregationBuilder2 = getAggregationBuilderFuncation(qsp.getSelectCol().trim(),aggregationBuilder2); 86 | 87 | for (int i = list.size() - 2; i >= 0; i--) { 88 | 89 | aggregationBuilder2 = list.get(i).subAggregation( 90 | aggregationBuilder2); 91 | 92 | } 93 | } 94 | if(aggregationBuilder2!=null){ 95 | mutliValues.add(aggregationBuilder2); 96 | } 97 | 98 | } 99 | if (filterBuilder != null) { 100 | FilterAggregationBuilder fab = AggregationBuilders.filter("filter").filter(filterBuilder); 101 | for(AggregationBuilder agg:mutliValues){ 102 | fab.subAggregation(agg); 103 | } 104 | aggregationBuilder.subAggregation(fab); 105 | }else{ 106 | for(AggregationBuilder agg:mutliValues){ 107 | aggregationBuilder.subAggregation(agg); 108 | } 109 | 110 | } 111 | 112 | 113 | } catch (Exception e) { 114 | e.printStackTrace(); 115 | } 116 | 117 | return aggregationBuilder; 118 | } 119 | 120 | /** 121 | * group by handler (simple group by ) 122 | * 123 | * @param qsp 124 | * @return 125 | */ 126 | private static List getAggregationBuilderSimpleGroupBy(String group) { 127 | //int size = 1000; 128 | List list = new ArrayList(); 129 | try { 130 | String[] arrGroup = group.split(","); 131 | for (String g : arrGroup) { 132 | g = g.trim(); 133 | if(g.indexOf("[")>0 && g.indexOf("]")>0){//group range 134 | 135 | String field = g.substring(0,g.indexOf("[")).trim(); 136 | String value = g.substring(g.indexOf("[")+1,g.indexOf("]")); 137 | String[] arr = value.split("\\|"); 138 | if(arr.length==1){ 139 | //System.out.println("---------arr[0]="+arr[0]); 140 | String[] tmp = arr[0].split("_"); 141 | if(tmp.length>=2){ 142 | //先处理垂直直方图或者时间垂直直方图 143 | if("datehistogram".equals(tmp[0].trim().toLowerCase())){//时间垂直直方图 144 | String x = tmp[1].trim().toLowerCase(); 145 | Interval interval = null; 146 | int i = 0; 147 | if(x.endsWith("second")){ 148 | interval = Interval.SECOND; 149 | if(!"second".equals(x)){ 150 | String t = x.substring(0,x.indexOf("second")); 151 | if(isIntegerOrDouble(t)){ 152 | i = Integer.parseInt(t); 153 | } 154 | interval = Interval.seconds(i); 155 | } 156 | }else if(x.endsWith("minute")){ 157 | interval = Interval.MINUTE; 158 | if(!"minute".equals(x)){ 159 | String t = x.substring(0,x.indexOf("minute")); 160 | if(isIntegerOrDouble(t)){ 161 | i = Integer.parseInt(t); 162 | } 163 | interval = Interval.minutes(i); 164 | } 165 | }else if(x.endsWith("hour")){ 166 | interval = Interval.HOUR; 167 | if(!"hour".equals(x)){ 168 | String t = x.substring(0,x.indexOf("hour")); 169 | if(isIntegerOrDouble(t)){ 170 | i = Integer.parseInt(t); 171 | } 172 | interval = Interval.hours(i); 173 | } 174 | }else if(x.endsWith("day")){ 175 | interval = Interval.DAY; 176 | if(!"day".equals(x)){ 177 | String t = x.substring(0,x.indexOf("day")); 178 | if(isIntegerOrDouble(t)){ 179 | i = Integer.parseInt(t); 180 | } 181 | interval = Interval.days(i); 182 | } 183 | 184 | }else if(x.endsWith("week")){ 185 | interval = Interval.WEEK; 186 | if(!"week".equals(x)){ 187 | String t = x.substring(0,x.indexOf("week")); 188 | if(isIntegerOrDouble(t)){ 189 | i = Integer.parseInt(t); 190 | } 191 | interval = Interval.weeks(i); 192 | } 193 | }else if(x.endsWith("month")){ 194 | interval = Interval.MONTH; 195 | }else if(x.endsWith("quarter")){ 196 | interval = Interval.QUARTER; 197 | }else if(x.endsWith("year")){ 198 | interval = Interval.YEAR; 199 | } 200 | if(tmp.length>=3){//tmp[2]表示格式 201 | if(tmp.length==3){ 202 | if(tmp[2].startsWith("(")){ 203 | String formate = tmp[2].trim(); 204 | formate = formate.substring(1,formate.length()-1).trim(); 205 | list.add(AggregationBuilders.dateHistogram("datehistogram").field(field).interval(interval).format(formate)); 206 | }else if(tmp[2].startsWith("{")){ 207 | String ex = tmp[2].trim(); 208 | ex = ex.substring(1,ex.length()-1).trim(); 209 | String[] exArr = ex.split("&"); 210 | String min = null; 211 | String max = null; 212 | for(String str:exArr){ 213 | if(str.trim().startsWith("min")){ 214 | String[] tt = str.trim().split("#"); 215 | if(tt.length==2){ 216 | min = tt[1].trim(); 217 | } 218 | }else if(str.trim().startsWith("max")){ 219 | String[] tt = str.trim().split("#"); 220 | if(tt.length==2){ 221 | max = tt[1].trim(); 222 | } 223 | } 224 | } 225 | if(min!=null && max!=null){ 226 | list.add(AggregationBuilders.dateHistogram("datehistogram").field(field).interval(interval).extendedBounds(min, max).minDocCount(EsUtil.getMinDocCount())); 227 | }else{ 228 | list.add(AggregationBuilders.dateHistogram("datehistogram").field(field).interval(interval)); 229 | } 230 | 231 | } 232 | }else if(tmp.length==4){ 233 | String formate = tmp[2].trim(); 234 | formate = formate.substring(1,formate.length()-1).trim(); 235 | 236 | String ex = tmp[3].trim(); 237 | ex = ex.substring(1,ex.length()-1).trim(); 238 | String[] exArr = ex.split("&"); 239 | String min = null; 240 | String max = null; 241 | for(String str:exArr){ 242 | if(str.trim().startsWith("min")){ 243 | String[] tt = str.trim().split("#"); 244 | if(tt.length==2){ 245 | min = tt[1].trim(); 246 | } 247 | }else if(str.trim().startsWith("max")){ 248 | String[] tt = str.trim().split("#"); 249 | if(tt.length==2){ 250 | max = tt[1].trim(); 251 | } 252 | } 253 | } 254 | if(min!=null && max!=null){ 255 | list.add(AggregationBuilders.dateHistogram("datehistogram").field(field).interval(interval).format(formate).extendedBounds(min, max).minDocCount(EsUtil.getMinDocCount())); 256 | }else{ 257 | list.add(AggregationBuilders.dateHistogram("datehistogram").field(field).interval(interval).format(formate)); 258 | } 259 | 260 | } 261 | }else{ 262 | list.add(AggregationBuilders.dateHistogram("datehistogram").field(field).interval(interval)); 263 | } 264 | }else if("histogram".equals(tmp[0].trim().toLowerCase())){//垂直直方图 265 | String x = tmp[1].trim().toLowerCase(); 266 | if(isIntegerOrDouble(x)){ 267 | long interval = Long.parseLong(x); 268 | list.add(AggregationBuilders.histogram("histogram").field(field).interval(interval)); 269 | } 270 | 271 | }else if("*".equals(tmp[0].trim())){ 272 | 273 | if(isIntegerOrDouble(tmp[1])){//必须是数字或者小数 274 | 275 | list.add(AggregationBuilders.range(field).field(field).addUnboundedTo(arr[0].trim(),Double.parseDouble(tmp[1]))); 276 | } 277 | }else if("*".equals(tmp[1].trim())){ 278 | if(isIntegerOrDouble(tmp[0])){//必须是数字或者小数 279 | 280 | 281 | list.add(AggregationBuilders.range(field).field(field).addUnboundedFrom(arr[0].trim(),Double.parseDouble(tmp[0]))); 282 | } 283 | } 284 | }else{ 285 | //格式错误 286 | 287 | } 288 | }else if(arr.length>1){ 289 | RangeBuilder rg = AggregationBuilders.range(field).field(field); 290 | for(int i=0;i 0) { 351 | field = getField("distinct", s.trim()); 352 | isDestinct = true; 353 | } else { 354 | field = getField("(", s.trim()); 355 | } 356 | break; 357 | } else if (s.trim().startsWith("sum(")) { 358 | optr = Operation.SUM; 359 | field = getField("(", s.trim()); 360 | break; 361 | } else if (s.trim().startsWith("avg(")) { 362 | optr = Operation.AVG; 363 | field = getField("(", s.trim()); 364 | break; 365 | } else if (s.trim().startsWith("max(")) { 366 | optr = Operation.MAX; 367 | field = getField("(", s.trim()); 368 | break; 369 | } else if (s.trim().startsWith("min(")) { 370 | optr = Operation.MIN; 371 | field = getField("(", s.trim()); 372 | break; 373 | } else if (s.trim().startsWith("stats(")) { 374 | optr = Operation.STATS; 375 | field = getField("(", s.trim()); 376 | break; 377 | } 378 | } 379 | 380 | if (optr == Operation.COUNT) { 381 | if (isDestinct) { 382 | aggregationBuilder2.subAggregation(AggregationBuilders 383 | .cardinality("distinct").field(field).precisionThreshold(EsUtil.getPrecisionThreshold()));// distinct 384 | } 385 | } else if (optr == Operation.AVG) { 386 | aggregationBuilder2.subAggregation(AggregationBuilders.avg( 387 | "avg").field(field)); 388 | } else if (optr == Operation.SUM) { 389 | aggregationBuilder2.subAggregation(AggregationBuilders.sum( 390 | "sum").field(field)); 391 | } else if (optr == Operation.MAX) { 392 | aggregationBuilder2.subAggregation(AggregationBuilders.max( 393 | "max").field(field)); 394 | } else if (optr == Operation.MIN) { 395 | aggregationBuilder2.subAggregation(AggregationBuilders.min( 396 | "min").field(field)); 397 | } else if (optr == Operation.STATS) { 398 | aggregationBuilder2.subAggregation(AggregationBuilders.stats( 399 | "stats").field(field)); 400 | } 401 | 402 | } catch (Exception e) { 403 | e.printStackTrace(); 404 | } 405 | return aggregationBuilder2; 406 | } 407 | 408 | /** 409 | * group by handler 410 | * 411 | * @param qsp 412 | * @return 413 | */ 414 | public static AggregationBuilder getAggregationBuilder2(QuerySqlParser qsp, 415 | FilterBuilder filterBuilder) { 416 | int size = 100; 417 | AggregationBuilder aggregationBuilder = null; 418 | 419 | try { 420 | String select = qsp.getSelectCol(); 421 | String group = qsp.getGroupCondition(); 422 | String[] arrSelect = select.split(","); 423 | String[] arrGroup = group.split(","); 424 | String field = null; 425 | boolean isDestinct = false; 426 | Operation optr = Operation.COUNT; 427 | for (String s : arrSelect) { 428 | if (s.trim().startsWith("count(")) { 429 | optr = Operation.COUNT; 430 | // String tmp = 431 | // s.trim().substring(s.trim().indexOf("distinct")+8,s.trim().length()-2); 432 | if (s.trim().indexOf("distinct") > 0) { 433 | field = getField("distinct", s.trim()); 434 | isDestinct = true; 435 | } else { 436 | field = getField("(", s.trim()); 437 | } 438 | break; 439 | } else if (s.trim().startsWith("sum(")) { 440 | optr = Operation.SUM; 441 | field = getField("(", s.trim()); 442 | break; 443 | } else if (s.trim().startsWith("avg(")) { 444 | optr = Operation.AVG; 445 | field = getField("(", s.trim()); 446 | break; 447 | } else if (s.trim().startsWith("max(")) { 448 | optr = Operation.MAX; 449 | field = getField("(", s.trim()); 450 | break; 451 | } else if (s.trim().startsWith("min(")) { 452 | optr = Operation.MIN; 453 | field = getField("(", s.trim()); 454 | break; 455 | } else if (s.trim().startsWith("stats(")) { 456 | optr = Operation.STATS; 457 | field = getField("(", s.trim()); 458 | break; 459 | } 460 | } 461 | // select count(distinct who) ....group by ds,serverid 462 | // select sum(price) group by ds,serverid 463 | int num = 0; 464 | List list = new ArrayList(); 465 | aggregationBuilder = AggregationBuilders.global("all_agg"); 466 | 467 | for (String g : arrGroup) { 468 | list.add(AggregationBuilders.terms(g.trim()).field(g.trim()) 469 | .size(size)); 470 | } 471 | AggregationBuilder aggregationBuilder2 = null; 472 | 473 | if (list.size() > 0) { 474 | aggregationBuilder2 = list.get(list.size() - 1); 475 | if (optr == Operation.COUNT) { 476 | if (isDestinct) { 477 | aggregationBuilder2.subAggregation(AggregationBuilders 478 | .cardinality("distinct").field(field));// distinct 479 | } 480 | } else if (optr == Operation.AVG) { 481 | aggregationBuilder2.subAggregation(AggregationBuilders.avg( 482 | "avg").field(field)); 483 | } else if (optr == Operation.SUM) { 484 | aggregationBuilder2.subAggregation(AggregationBuilders.sum( 485 | "sum").field(field)); 486 | } else if (optr == Operation.MAX) { 487 | aggregationBuilder2.subAggregation(AggregationBuilders.max( 488 | "max").field(field)); 489 | } else if (optr == Operation.MIN) { 490 | aggregationBuilder2.subAggregation(AggregationBuilders.min( 491 | "min").field(field)); 492 | } else if (optr == Operation.STATS) { 493 | aggregationBuilder2.subAggregation(AggregationBuilders 494 | .stats("stats").field(field)); 495 | } 496 | 497 | for (int i = list.size() - 2; i >= 0; i--) { 498 | 499 | aggregationBuilder2 = list.get(i).subAggregation( 500 | aggregationBuilder2); 501 | 502 | } 503 | } 504 | if (aggregationBuilder2 != null) { 505 | if (filterBuilder != null) { 506 | aggregationBuilder.subAggregation(AggregationBuilders 507 | .filter("filter").filter(filterBuilder) 508 | .subAggregation(aggregationBuilder2)); 509 | } else { 510 | aggregationBuilder.subAggregation(aggregationBuilder2); 511 | } 512 | } 513 | 514 | } catch (Exception e) { 515 | e.printStackTrace(); 516 | } 517 | return aggregationBuilder; 518 | } 519 | 520 | private static String getField(String indexOf, String s) { 521 | String tmp = s.substring(s.indexOf(indexOf) + indexOf.length(), 522 | s.indexOf(")")).trim(); 523 | return tmp; 524 | } 525 | 526 | /** 527 | * 整数或者小数 528 | * @param str 529 | * @return 530 | */ 531 | private static boolean isIntegerOrDouble(String str) 532 | { 533 | java.util.regex.Pattern pattern=java.util.regex.Pattern.compile("[0-9]+\\.{0,1}[0-9]{0,2}"); 534 | java.util.regex.Matcher match=pattern.matcher(str); 535 | if(match.matches()==false) 536 | { 537 | return false; 538 | } 539 | else 540 | { 541 | return true; 542 | } 543 | } 544 | 545 | /** 546 | * group by split 547 | * @param str 548 | * @return 549 | */ 550 | private static List splitGroupBy(String str){ 551 | //String str = "(city,age[*-20|20-25|25-30|30-35|35-40|40-*],state),(city,state),(age,account_number)"; 552 | int num =0; 553 | boolean start = false; 554 | List list = new ArrayList(); 555 | StringBuffer stringBuffer = new StringBuffer(); 556 | for(int i=0;i> resultParser3(SearchResponse response,QuerySqlParser qsp){ 45 | Map> resultMap = new TreeMap>(); 46 | 47 | try{ 48 | 49 | InternalGlobal global = response.getAggregations().get("all_agg"); 50 | 51 | String where = qsp.getWhereCondition();//where条件 52 | InternalFilter filter = null; 53 | if(StringUtils.isNotEmpty(where)){ 54 | filter = global.getAggregations().get("filter"); 55 | } 56 | 57 | String group = qsp.getGroupCondition().trim();//获取group 条件 58 | 59 | Map> map = new TreeMap>(); 60 | if (group.startsWith("(")) {// 可能多层嵌套group存在 61 | //(city,age[*-20|20-25|25-30|30-35|35-40|40-*],state),(city,state),(age,account_number) 62 | 63 | List list = splitGroupBy(group); 64 | for(int i=0;i map1 = getNameMap(list.get(i).trim()); 66 | map.put(i, map1); 67 | } 68 | 69 | } else{// 普通 70 | //city,age[*-20|20-25|25-30|30-35|35-40|40-*],state 71 | //city,state 72 | Map map1 = getNameMap(group.trim()); 73 | map.put(0, map1); 74 | } 75 | 76 | String functionName = getFunctionName(qsp.getSelectCol()); 77 | 78 | if(map.size()==1){//只有一层 79 | Map rMap = getResult(map.get(0),functionName,global,filter); 80 | resultMap.put(0, rMap); 81 | }else if(map.size()>1){//多层 82 | for(Map.Entry> entry:map.entrySet()){ 83 | Map rMap = getResult(entry.getValue(),functionName,global,filter); 84 | resultMap.put(entry.getKey(), rMap); 85 | } 86 | } 87 | 88 | }catch(Exception e){ 89 | e.printStackTrace(); 90 | } 91 | 92 | return resultMap; 93 | } 94 | 95 | private static Map getResult(Map map,String functionName,InternalGlobal global,InternalFilter filter){ 96 | Map result = new TreeMap(); 97 | try{ 98 | InternalSingleBucketAggregation tmp = global; 99 | if(filter != null){ 100 | tmp = filter; 101 | } 102 | String type = "terms";//last type 103 | List tmpList = new ArrayList(); 104 | 105 | for(Map.Entry entry : map.entrySet()){ 106 | 107 | String value = entry.getValue(); 108 | 109 | tmpList.add(value); 110 | 111 | String[] arr = value.split("\001"); 112 | if(arr.length ==1 ){ 113 | if("datehistogram".equals(arr[0].trim())){ 114 | type = "datehistogram"; 115 | 116 | }else if("histogram".equals(arr[0].trim())){ 117 | type = "histogram"; 118 | } 119 | }else if(arr.length>1){ 120 | if("range".equals(arr[0].trim())){ 121 | type = "range"; 122 | }else if("terms".equals(arr[0].trim())){ 123 | type = "terms"; 124 | } 125 | } 126 | 127 | } 128 | List keyList = new ArrayList(); 129 | keyList = recursiveAllLevel(tmp.getAggregations(),"",keyList,0,tmpList,functionName); 130 | 131 | 132 | for(String key : keyList){ 133 | String[] arr = key.split("\002"); 134 | if(arr.length==2){ 135 | String mapkey = arr[0].substring("\001".length()); 136 | if(StringUtils.isEmpty(functionName)){//count 137 | result.put(mapkey, arr[1]); 138 | }else{ 139 | String[] valueArr = arr[1].split("\003"); 140 | if(valueArr.length==2){ 141 | result.put(mapkey, valueArr[1]);//如果查询stats，其结果使用\004分隔,顺序分别是：count、sum、avg、max、min 142 | } 143 | } 144 | } 145 | } 146 | 147 | 148 | 149 | 150 | }catch(Exception e){ 151 | e.printStackTrace(); 152 | } 153 | 154 | return result; 155 | } 156 | 157 | /** 158 | * 递归分析数据 159 | * @param list 160 | * @param value 161 | * @return 162 | */ 163 | private static List recursiveAllLevel(Aggregations tmp,String value,List list,int level,List nameList,String functionName){ 164 | try{ 165 | String name = nameList.get(level); 166 | int type = getType(name); 167 | switch (type) { 168 | case 1: 169 | InternalTerms terms = tmp.get(getName(name)); 170 | if(level==nameList.size()-1){ 171 | for(org.elasticsearch.search.aggregations.bucket.terms.Terms.Bucket bucket: terms.getBuckets()){ 172 | String x = value+"\001"+bucket.getKeyAsText()+"\002"+bucket.getDocCount(); 173 | if(StringUtils.isNotEmpty(functionName)){ 174 | if("distinct".equals(functionName)){ 175 | InternalCardinality distinct = bucket.getAggregations().get("distinct"); 176 | x = x+"\003"+distinct.getValue(); 177 | }else if("sum".equals(functionName)){ 178 | InternalSum sum = bucket.getAggregations().get("sum"); 179 | x = x+"\003"+sum.getValue(); 180 | }else if("avg".equals(functionName)){ 181 | InternalAvg avg = bucket.getAggregations().get("avg"); 182 | x = x+"\003"+avg.getValue(); 183 | }else if("max".equals(functionName)){ 184 | InternalMax max = bucket.getAggregations().get("max"); 185 | x = x+"\003"+max.getValue(); 186 | }else if("min".equals(functionName)){ 187 | InternalMin min = bucket.getAggregations().get("min"); 188 | x = x+"\003"+min.getValue(); 189 | }else if("stats".equals(functionName)){ 190 | InternalStats stats = bucket.getAggregations().get("stats"); 191 | x = x+"\003"+stats.getCount()+"\004"+stats.getSum()+"\004"+stats.getAvg()+"\004"+stats.getMax()+"\004"+stats.getMin(); 192 | } 193 | } 194 | list.add(x); 195 | } 196 | }else{ 197 | level++; 198 | for(org.elasticsearch.search.aggregations.bucket.terms.Terms.Bucket bucket: terms.getBuckets()){ 199 | list.addAll(recursiveAllLevel(bucket.getAggregations(),value+"\001"+bucket.getKeyAsText(),list,level,nameList,functionName)); 200 | } 201 | } 202 | break; 203 | case 2: 204 | InternalRange range = tmp.get(getName(name)); 205 | if(level==nameList.size()-1){ 206 | for(Object bucketr: range.getBuckets()){ 207 | org.elasticsearch.search.aggregations.bucket.range.Range.Bucket bucket = (org.elasticsearch.search.aggregations.bucket.range.Range.Bucket)bucketr; 208 | //list.add(value+"\001"+bucket.getKeyAsText()+"\002"+bucket.getDocCount()); 209 | String x = value+"\001"+bucket.getKeyAsText()+"\002"+bucket.getDocCount(); 210 | if(StringUtils.isNotEmpty(functionName)){ 211 | if("distinct".equals(functionName)){ 212 | InternalCardinality distinct = bucket.getAggregations().get("distinct"); 213 | x = x+"\003"+distinct.getValue(); 214 | }else if("sum".equals(functionName)){ 215 | InternalSum sum = bucket.getAggregations().get("sum"); 216 | x = x+"\003"+sum.getValue(); 217 | }else if("avg".equals(functionName)){ 218 | InternalAvg avg = bucket.getAggregations().get("avg"); 219 | x = x+"\003"+avg.getValue(); 220 | }else if("max".equals(functionName)){ 221 | InternalMax max = bucket.getAggregations().get("max"); 222 | x = x+"\003"+max.getValue(); 223 | }else if("min".equals(functionName)){ 224 | InternalMin min = bucket.getAggregations().get("min"); 225 | x = x+"\003"+min.getValue(); 226 | }else if("stats".equals(functionName)){ 227 | InternalStats stats = bucket.getAggregations().get("stats"); 228 | x = x+"\003"+stats.getCount()+"\004"+stats.getSum()+"\004"+stats.getAvg()+"\004"+stats.getMax()+"\004"+stats.getMin(); 229 | } 230 | } 231 | list.add(x); 232 | } 233 | }else{ 234 | level++; 235 | for(Object bucketr: range.getBuckets()){ 236 | org.elasticsearch.search.aggregations.bucket.range.Range.Bucket bucket = (org.elasticsearch.search.aggregations.bucket.range.Range.Bucket)bucketr; 237 | recursiveAllLevel(bucket.getAggregations(),value+"\001"+bucket.getKeyAsText(),list,level,nameList,functionName); 238 | } 239 | } 240 | break; 241 | case 3: 242 | Histogram histogram = tmp.get(getName(name)); 243 | if(level==nameList.size()-1){ 244 | for(org.elasticsearch.search.aggregations.bucket.histogram.Histogram.Bucket bucket: histogram.getBuckets()){ 245 | //list.add(value+"\001"+bucket.getKeyAsText()+"\002"+bucket.getDocCount()); 246 | String x = value+"\001"+bucket.getKeyAsText()+"\002"+bucket.getDocCount(); 247 | if(StringUtils.isNotEmpty(functionName)){ 248 | if("distinct".equals(functionName)){ 249 | InternalCardinality distinct = bucket.getAggregations().get("distinct"); 250 | x = x+"\003"+distinct.getValue(); 251 | }else if("sum".equals(functionName)){ 252 | InternalSum sum = bucket.getAggregations().get("sum"); 253 | x = x+"\003"+sum.getValue(); 254 | }else if("avg".equals(functionName)){ 255 | InternalAvg avg = bucket.getAggregations().get("avg"); 256 | x = x+"\003"+avg.getValue(); 257 | }else if("max".equals(functionName)){ 258 | InternalMax max = bucket.getAggregations().get("max"); 259 | x = x+"\003"+max.getValue(); 260 | }else if("min".equals(functionName)){ 261 | InternalMin min = bucket.getAggregations().get("min"); 262 | x = x+"\003"+min.getValue(); 263 | }else if("stats".equals(functionName)){ 264 | InternalStats stats = bucket.getAggregations().get("stats"); 265 | x = x+"\003"+stats.getCount()+"\004"+stats.getSum()+"\004"+stats.getAvg()+"\004"+stats.getMax()+"\004"+stats.getMin(); 266 | } 267 | } 268 | list.add(x); 269 | } 270 | }else{ 271 | level++; 272 | for(org.elasticsearch.search.aggregations.bucket.histogram.Histogram.Bucket bucket: histogram.getBuckets()){ 273 | recursiveAllLevel(bucket.getAggregations(),value+"\001"+bucket.getKeyAsText(),list,level,nameList,functionName); 274 | } 275 | } 276 | break; 277 | case 4: 278 | DateHistogram dateHistogram = tmp.get(getName(name)); 279 | if(level==nameList.size()-1){ 280 | for(Bucket bucket: dateHistogram.getBuckets()){ 281 | //list.add(value+"\001"+bucket.getKeyAsText()+"\002"+bucket.getDocCount()); 282 | String x = value+"\001"+bucket.getKeyAsText()+"\002"+bucket.getDocCount(); 283 | if(StringUtils.isNotEmpty(functionName)){ 284 | if("distinct".equals(functionName)){ 285 | InternalCardinality distinct = bucket.getAggregations().get("distinct"); 286 | x = x+"\003"+distinct.getValue(); 287 | }else if("sum".equals(functionName)){ 288 | InternalSum sum = bucket.getAggregations().get("sum"); 289 | x = x+"\003"+sum.getValue(); 290 | }else if("avg".equals(functionName)){ 291 | InternalAvg avg = bucket.getAggregations().get("avg"); 292 | x = x+"\003"+avg.getValue(); 293 | }else if("max".equals(functionName)){ 294 | InternalMax max = bucket.getAggregations().get("max"); 295 | x = x+"\003"+max.getValue(); 296 | }else if("min".equals(functionName)){ 297 | InternalMin min = bucket.getAggregations().get("min"); 298 | x = x+"\003"+min.getValue(); 299 | }else if("stats".equals(functionName)){ 300 | InternalStats stats = bucket.getAggregations().get("stats"); 301 | x = x+"\003"+stats.getCount()+"\004"+stats.getSum()+"\004"+stats.getAvg()+"\004"+stats.getMax()+"\004"+stats.getMin(); 302 | } 303 | } 304 | list.add(x); 305 | } 306 | }else{ 307 | level++; 308 | for(Bucket bucket: dateHistogram.getBuckets()){ 309 | recursiveAllLevel(bucket.getAggregations(),value+"\001"+bucket.getKeyAsText(),list,level,nameList,functionName); 310 | } 311 | } 312 | break; 313 | default: 314 | break; 315 | } 316 | 317 | } catch (Exception e) { 318 | e.printStackTrace(); 319 | } 320 | 321 | return list; 322 | } 323 | 324 | 325 | 326 | private static String getName(String value){ 327 | String[] arr = value.split("\001"); 328 | if(arr.length ==1 ){ 329 | return arr[0].trim(); 330 | }else{ 331 | return arr[1].trim(); 332 | } 333 | } 334 | 335 | private static int getType(String x){ 336 | if(x.startsWith("datehistogram")){ 337 | return 4; 338 | }else if(x.startsWith("histogram")){ 339 | return 3; 340 | }else if(x.startsWith("range")){ 341 | return 2; 342 | }else if(x.startsWith("terms")){ 343 | return 1; 344 | }else{ 345 | return 0; 346 | } 347 | } 348 | 349 | /** 350 | * 解析group by 对于的分组字段名称 351 | * @param qsp 352 | * @return 353 | */ 354 | private static Map getNameMap(String group){ 355 | Map tmpMap = new TreeMap(); 356 | try{ 357 | String[] arrGroup = group.split(","); 358 | int num = 0; 359 | for (String g : arrGroup) { 360 | num++; 361 | g = g.trim(); 362 | if(g.indexOf("[")>0 && g.indexOf("]")>0){//group range 363 | 364 | String field = g.substring(0,g.indexOf("[")).trim(); 365 | String value = g.substring(g.indexOf("[")+1,g.indexOf("]")); 366 | String[] arr = value.split("\\|"); 367 | if(arr.length==1){ 368 | //System.out.println("---------arr[0]"+arr[0]); 369 | String[] tmp = arr[0].split("_"); 370 | if(tmp.length>=2){ 371 | //先处理垂直直方图或者时间垂直直方图 372 | if("datehistogram".equals(tmp[0].trim().toLowerCase())){//时间垂直直方图 373 | tmpMap.put(num, "datehistogram"); 374 | }else if("histogram".equals(tmp[0].trim().toLowerCase())){//垂直直方图 375 | tmpMap.put(num, "histogram"); 376 | }else if("*".equals(tmp[0].trim())){ 377 | tmpMap.put(num, "range"+"\001"+field); 378 | }else if("*".equals(tmp[1].trim())){ 379 | tmpMap.put(num, "range"+"\001"+field); 380 | } 381 | }else{ 382 | //格式错误 383 | 384 | } 385 | }else if(arr.length>1){ 386 | tmpMap.put(num, "range"+"\001"+field); 387 | } 388 | 389 | }else{ 390 | tmpMap.put(num, "terms"+"\001"+g); 391 | } 392 | } 393 | 394 | 395 | }catch(Exception e){ 396 | e.printStackTrace(); 397 | } 398 | 399 | return tmpMap; 400 | } 401 | 402 | /** 403 | * 获取聚合函数对于的名字 404 | * @param select 405 | * @return 406 | */ 407 | private static String getFunctionName(String select) { 408 | String functionName = null; 409 | try { 410 | String[] arrSelect = select.split(","); 411 | String field = null; 412 | boolean isDestinct = false; 413 | Operation optr = Operation.COUNT; 414 | for (String s : arrSelect) { 415 | if (s.trim().startsWith("count(")) { 416 | optr = Operation.COUNT; 417 | if (s.trim().indexOf("distinct") > 0) { 418 | field = getField("distinct", s.trim()); 419 | isDestinct = true; 420 | } else { 421 | field = getField("(", s.trim()); 422 | } 423 | break; 424 | } else if (s.trim().startsWith("sum(")) { 425 | optr = Operation.SUM; 426 | field = getField("(", s.trim()); 427 | break; 428 | } else if (s.trim().startsWith("avg(")) { 429 | optr = Operation.AVG; 430 | field = getField("(", s.trim()); 431 | break; 432 | } else if (s.trim().startsWith("max(")) { 433 | optr = Operation.MAX; 434 | field = getField("(", s.trim()); 435 | break; 436 | } else if (s.trim().startsWith("min(")) { 437 | optr = Operation.MIN; 438 | field = getField("(", s.trim()); 439 | break; 440 | } else if (s.trim().startsWith("stats(")) { 441 | optr = Operation.STATS; 442 | field = getField("(", s.trim()); 443 | break; 444 | } 445 | } 446 | 447 | if (optr == Operation.COUNT) { 448 | if (isDestinct) { 449 | functionName = "distinct";// distinct 450 | } 451 | } else if (optr == Operation.AVG) { 452 | functionName ="avg"; 453 | } else if (optr == Operation.SUM) { 454 | functionName ="sum"; 455 | } else if (optr == Operation.MAX) { 456 | functionName ="max"; 457 | } else if (optr == Operation.MIN) { 458 | functionName ="min"; 459 | } else if (optr == Operation.STATS) { 460 | functionName ="stats"; 461 | } 462 | 463 | } catch (Exception e) { 464 | e.printStackTrace(); 465 | } 466 | return functionName; 467 | } 468 | 469 | 470 | private static String getField(String indexOf, String s) { 471 | String tmp = s.substring(s.indexOf(indexOf) + indexOf.length(), 472 | s.indexOf(")")).trim(); 473 | return tmp; 474 | } 475 | 476 | /** 477 | * group by split 478 | * @param str 479 | * @return 480 | */ 481 | private static List splitGroupBy(String str){ 482 | //String str = "(city,age[*-20|20-25|25-30|30-35|35-40|40-*],state),(city,state),(age,account_number)"; 483 | int num =0; 484 | boolean start = false; 485 | List list = new ArrayList(); 486 | StringBuffer stringBuffer = new StringBuffer(); 487 | for(int i=0;i> tmp = response.getMappings(); 75 | 76 | for(ObjectCursor key :tmp.keys()){ 77 | ImmutableOpenMap map= tmp.get(key.value); 78 | System.out.println(key.value); 79 | 80 | for(ObjectCursor ck:map.keys()){ 81 | System.out.println(ck.value); 82 | MappingMetaData mmData = map.get(ck.value); 83 | Map cMap = mmData.sourceAsMap(); 84 | for(Map.Entry entry:cMap.entrySet()){ 85 | System.out.println(entry.getKey()); 86 | //System.out.println(entry.getValue().toString()); 87 | 88 | JSONObject bean = JSONObject.fromString(entry.getValue().toString()); 89 | 90 | //System.out.println(bean.get("context").toString()); 91 | 92 | JSONObject context = JSONObject.fromString(bean.get("context").toString()); 93 | JSONObject context_c = JSONObject.fromString(context.get("properties").toString()); 94 | 95 | Iterator iterator = context_c.keys(); 96 | 97 | while(iterator.hasNext()){ 98 | String ckey = (String) iterator.next(); 99 | System.out.println(ckey); 100 | } 101 | } 102 | } 103 | } 104 | 105 | //System.out.println(response.toString()); 106 | 107 | }catch (Exception e) { 108 | e.printStackTrace(); 109 | } 110 | } 111 | 112 | 113 | @Test 114 | /** 115 | * 获取index下面的mapping信息 116 | */ 117 | public void testQuery18(){ 118 | try{ 119 | Client client = EsUtil.initClient(true, "elasticsearch", new String[]{"x00:9300","x01:9300"}); 120 | 121 | GetMappingsRequest request = new GetMappingsRequest(); 122 | request.indices("segments.20140909-new"); 123 | 124 | GetMappingsResponse response = client.admin().indices().getMappings(request).actionGet(); 125 | 126 | ImmutableOpenMap> tmp = response.getMappings(); 127 | 128 | for(ObjectCursor key :tmp.keys()){ 129 | ImmutableOpenMap map= tmp.get(key.value); 130 | System.out.println(key.value); 131 | 132 | for(ObjectCursor ck:map.keys()){ 133 | System.out.println(ck.value); 134 | MappingMetaData mmData = map.get(ck.value); 135 | Map cMap = mmData.sourceAsMap(); 136 | for(Map.Entry entry:cMap.entrySet()){ 137 | System.out.println(entry.getKey()); 138 | //System.out.println(entry.getValue().toString()); 139 | 140 | JSONObject bean = JSONObject.fromString(entry.getValue().toString()); 141 | 142 | //System.out.println(bean.get("context").toString()); 143 | 144 | JSONObject context = JSONObject.fromString(bean.get("context").toString()); 145 | JSONObject context_c = JSONObject.fromString(context.get("properties").toString()); 146 | 147 | Iterator iterator = context_c.keys(); 148 | while(iterator.hasNext()){ 149 | String ckey = (String) iterator.next(); 150 | System.out.println(ckey); 151 | } 152 | } 153 | } 154 | } 155 | 156 | //System.out.println(response.toString()); 157 | 158 | }catch (Exception e) { 159 | e.printStackTrace(); 160 | } 161 | } 162 | 163 | @Test 164 | /** 165 | * 垂直直方图-时间 166 | */ 167 | public void testQuery17_1(){ 168 | try{ 169 | Client client = EsUtil.initClient(true, "elasticsearch", new String[]{"x00:9300","x01:9300"}); 170 | 171 | AggregationBuilder aggregationBuilder2 = AggregationBuilders.global("all").subAggregation( 172 | AggregationBuilders.dateHistogram("datehistogram").field("when.d").interval(Interval.minutes(5)).format("HH:mm") 173 | ); 174 | FilterBuilder filterBuilder = FilterBuilders.termFilter("appid.s", "982da2ae92188e5f73fbf7f82e41ed65"); 175 | 176 | SearchResponse response = client.prepareSearch("events.20140909").setTypes("events") 177 | .setPostFilter(filterBuilder) 178 | .addAggregation(aggregationBuilder2) 179 | .setFrom(0).setSize(1) 180 | .execute().actionGet(); 181 | 182 | System.out.println(response); 183 | 184 | }catch (Exception e) { 185 | e.printStackTrace(); 186 | } 187 | } 188 | 189 | @Test 190 | /** 191 | * 垂直直方图-时间 192 | */ 193 | public void testQuery17(){ 194 | try{ 195 | Client client = EsUtil.initClient(true, "elasticsearch", new String[]{"x00:9300","x01:9300"}); 196 | 197 | QueryBuilder queryBuilder = QueryBuilders.boolQuery().must(QueryBuilders.queryString("982da2ae92188e5f73fbf7f82e41ed65").field("appid.s")) 198 | .must(QueryBuilders.queryString("item").field("what.s")); 199 | 200 | SearchResponse response = client.prepareSearch("segments.20140902").setTypes("segments").setQuery(queryBuilder) 201 | .setFrom(0).setSize(1) 202 | .execute().actionGet(); 203 | 204 | System.out.println(response); 205 | 206 | }catch (Exception e) { 207 | e.printStackTrace(); 208 | } 209 | } 210 | 211 | @Test 212 | /** 213 | * 垂直直方图-时间 214 | */ 215 | public void testQuery16(){ 216 | try{ 217 | Client client = EsUtil.initClient(true, "elasticsearch", new String[]{"x00:9300","x01:9300"}); 218 | 219 | AggregationBuilder aggregationBuilder = AggregationBuilders.global("all").subAggregation( 220 | AggregationBuilders.dateHistogram("datehistogram").field("createtime").interval(Interval.hours(3)) 221 | ); 222 | 223 | //Interval.HOUR hours() 224 | //Interval.DAY days() 225 | //Interval.MINUTE minutes() 226 | //Interval.MONTH 227 | //Interval.SECOND seconds() 228 | //Interval.YEAR 229 | //Interval.WEEK weeks() 230 | //Interval.QUARTER 231 | 232 | AggregationBuilder aggregationBuilder2 = AggregationBuilders.global("all").subAggregation( 233 | AggregationBuilders.dateHistogram("datehistogram").field("createtime").interval(Interval.HOUR) 234 | ); 235 | 236 | SearchResponse response = client.prepareSearch("bank2").addAggregation(aggregationBuilder2) 237 | .setFrom(0).setSize(10) 238 | .execute().actionGet(); 239 | 240 | System.out.println(response); 241 | 242 | }catch (Exception e) { 243 | e.printStackTrace(); 244 | } 245 | } 246 | 247 | 248 | 249 | @Test 250 | /** 251 | * 垂直直方图-普通 252 | */ 253 | public void testQuery15(){ 254 | try{ 255 | Client client = EsUtil.initClient(true, "elasticsearch", new String[]{"x00:9300","x01:9300"}); 256 | 257 | AggregationBuilder aggregationBuilder = AggregationBuilders.global("all").subAggregation( 258 | AggregationBuilders.histogram("xx").field("age").interval(5) 259 | ); 260 | 261 | SearchResponse response = client.prepareSearch("bank").addAggregation(aggregationBuilder) 262 | .setFrom(0).setSize(10) 263 | .execute().actionGet(); 264 | 265 | System.out.println(response); 266 | 267 | }catch (Exception e) { 268 | e.printStackTrace(); 269 | } 270 | } 271 | 272 | 273 | @Test 274 | /** 275 | * agg range 276 | */ 277 | public void testQuery14(){ 278 | try{ 279 | Client client = EsUtil.getClient(); 280 | 281 | AggregationBuilder aggregationBuilder = AggregationBuilders.global("all").subAggregation( 282 | AggregationBuilders.range("age-range").field("age") 283 | .addUnboundedTo("*-20", 20) 284 | .addRange("20-25", 20, 25) 285 | .addRange("25-30", 25,30) 286 | .addRange("30-35", 30, 35) 287 | .addRange("35-40", 35, 40) 288 | .addUnboundedFrom("40-*", 40) 289 | .subAggregation(AggregationBuilders.stats("x").field("balance") 290 | )); 291 | 292 | SearchResponse response = client.prepareSearch("bank").addAggregation(aggregationBuilder) 293 | .setFrom(0).setSize(10) 294 | .execute().actionGet(); 295 | 296 | System.out.println(response); 297 | }catch (Exception e) { 298 | e.printStackTrace(); 299 | } 300 | } 301 | 302 | 303 | 304 | @Test 305 | /** 306 | * stats 307 | */ 308 | public void testQuery13(){ 309 | try{ 310 | Client client = EsUtil.getClient(); 311 | 312 | AggregationBuilder aggregationBuilder = AggregationBuilders.global("all").subAggregation( 313 | AggregationBuilders.terms("age").field("age") 314 | .subAggregation(AggregationBuilders.stats("x").field("balance")) 315 | ); 316 | 317 | SearchResponse response = client.prepareSearch("bank").addAggregation(aggregationBuilder) 318 | .addFields(new String[]{"account_number","balance","age","tt"}) 319 | .setFrom(0).setSize(10) 320 | .execute().actionGet(); 321 | 322 | System.out.println(response); 323 | }catch (Exception e) { 324 | e.printStackTrace(); 325 | } 326 | } 327 | 328 | @Test 329 | /** 330 | * 设置显示的fields 331 | */ 332 | public void testQuery12(){ 333 | try{ 334 | Client client = EsUtil.getClient(); 335 | 336 | SearchResponse response = client.prepareSearch("bank").addAggregation(AggregationBuilders.stats("x").field("balance")) 337 | .addFields(new String[]{"account_number","balance","age"}) 338 | .setFrom(0).setSize(10) 339 | .execute().actionGet(); 340 | 341 | System.out.println(response); 342 | }catch (Exception e) { 343 | e.printStackTrace(); 344 | } 345 | } 346 | 347 | 348 | @Test 349 | public void testQuery11(){ 350 | try{ 351 | Client client = EsUtil.getClient(); 352 | 353 | StatisticalFacetBuilder statisticalFacetBuilder = FacetBuilders.statisticalFacet("facet_balance") 354 | .field("balance"); 355 | 356 | SearchResponse response = client.prepareSearch("bank").addFacet(statisticalFacetBuilder) 357 | .addFields(new String[]{"account_number","balance","age"}) 358 | .setFrom(0).setSize(10) 359 | .execute().actionGet(); 360 | 361 | System.out.println(response); 362 | }catch (Exception e) { 363 | e.printStackTrace(); 364 | } 365 | } 366 | 367 | @Test 368 | public void testQuery10(){ 369 | try{ 370 | Client client = EsUtil.getClient(); 371 | 372 | AggregationBuilder aggregation = AggregationBuilders.global("all").subAggregation( 373 | AggregationBuilders.terms("age").field("age") 374 | .subAggregation(AggregationBuilders.dateHistogram("x").field("timestamp").interval(new Interval("1").HOUR)) 375 | .subAggregation(AggregationBuilders.sum("b").field("balance") 376 | ) 377 | ); 378 | 379 | //StatisticalFacetBuilder statisticalFacetBuilder = FacetBuilders.statisticalFacet("facet_balance").field("balance"); 380 | 381 | 382 | SearchResponse response = client.prepareSearch("bank").addAggregation(aggregation) 383 | .setFrom(0).setSize(10) 384 | .execute().actionGet(); 385 | 386 | System.out.println(response); 387 | }catch (Exception e) { 388 | e.printStackTrace(); 389 | } 390 | } 391 | 392 | @Test 393 | public void testQuery9(){ 394 | try{ 395 | Client client = EsUtil.getClient(); 396 | /*FilterBuilder filterBuilder = FilterBuilders.andFilter( 397 | FilterBuilders.queryFilter(QueryBuilders.queryString("F").field("gender")), 398 | FilterBuilders.rangeFilter("balance").gt(30000).filterName("balance"), 399 | FilterBuilders.inFilter("age", new Integer[]{30,31,32}).filterName("age") 400 | );*/ 401 | Terms.Order order = org.elasticsearch.search.aggregations.bucket.terms.Terms.Order.count(false); 402 | /*AggregationBuilder aggregation = AggregationBuilders.global("all").subAggregation(AggregationBuilders.filter("xx").filter(filterBuilder) 403 | .subAggregation(AggregationBuilders.terms("state").field("state").order(org.elasticsearch.search.aggregations.bucket.terms.Terms.Order.count(false)))); 404 | */ 405 | AggregationBuilder aggregation = AggregationBuilders.global("all").subAggregation( 406 | AggregationBuilders.terms("age").field("age") 407 | .subAggregation(AggregationBuilders.sum("b").field("balance")) 408 | ); 409 | 410 | SearchResponse response = client.prepareSearch("bank").addAggregation(aggregation) 411 | .setFrom(0).setSize(10) 412 | .execute().actionGet(); 413 | 414 | System.out.println(response); 415 | }catch (Exception e) { 416 | e.printStackTrace(); 417 | } 418 | } 419 | 420 | 421 | 422 | @Test 423 | public void testQuery8(){ 424 | try{ 425 | Client client = EsUtil.getClient(); 426 | QueryBuilder queryBuilder = QueryBuilders.matchAllQuery(); 427 | AggregationBuilders.global("").subAggregation(AggregationBuilders.dateHistogram("")); 428 | SortBuilder sort = SortBuilders.fieldSort("age").order(SortOrder.DESC); 429 | SortBuilder sort1 = SortBuilders.fieldSort("account_number").order(SortOrder.ASC); 430 | 431 | SearchResponse response = client.prepareSearch("bank").setQuery(queryBuilder).addSort(sort).addSort(sort1) 432 | .setFrom(0).setSize(20) 433 | .execute().actionGet(); 434 | 435 | System.out.println(response); 436 | }catch (Exception e) { 437 | e.printStackTrace(); 438 | } 439 | } 440 | 441 | 442 | @Test 443 | public void testQuery7(){ 444 | try{ 445 | Client client = EsUtil.getClient(); 446 | QueryBuilder queryBuilder = QueryBuilders.wildcardQuery("firstname", "*beck*"); 447 | AggregationBuilders.global("").subAggregation(AggregationBuilders.dateHistogram("")); 448 | //最终由type决定了数据获取 449 | //bank.account=bank.account,bank1=bank.account,bank.account1 450 | //bank.account,bank1.account1 = bank,bank1 451 | //可以看出最终是index和type的组合，如果有对应的关系就可以查询对应的数据 452 | SearchResponse response = client.prepareSearch("bank","bank1").setTypes("account","account1").setQuery(queryBuilder) 453 | .setFrom(0).setSize(100) 454 | .execute().actionGet(); 455 | System.out.println(response); 456 | }catch (Exception e) { 457 | e.printStackTrace(); 458 | } 459 | } 460 | 461 | 462 | @Test 463 | public void testQuery6(){ 464 | try{ 465 | Client client = EsUtil.getClient(); 466 | QueryBuilder queryBuilder = QueryBuilders.wildcardQuery("firstname", "*beck*"); 467 | AggregationBuilders.global("").subAggregation(AggregationBuilders.dateHistogram("")); 468 | SearchResponse response = client.prepareSearch("bank").setTypes("account").setQuery(queryBuilder) 469 | .setFrom(0).setSize(100) 470 | .execute().actionGet(); 471 | System.out.println(response); 472 | }catch (Exception e) { 473 | e.printStackTrace(); 474 | } 475 | } 476 | 477 | @Test 478 | public void testQuery5(){ 479 | try{ 480 | Client client = EsUtil.getClient(); 481 | QueryBuilder queryBuilder = QueryBuilders.fuzzyLikeThisFieldQuery("firstname").likeText("Beck").queryName("like"); 482 | QueryBuilder queryBuilder2 = QueryBuilders.fuzzyLikeThisQuery("firstname").likeText("Beck").queryName("like"); 483 | SearchResponse response = client.prepareSearch("bank").setQuery(queryBuilder2) 484 | .setFrom(0).setSize(100) 485 | .execute().actionGet(); 486 | System.out.println(response); 487 | }catch (Exception e) { 488 | e.printStackTrace(); 489 | } 490 | } 491 | 492 | @Test 493 | public void testQuery4(){ 494 | try{ 495 | Client client = EsUtil.getClient(); 496 | QueryBuilder queryBuilder = QueryBuilders.inQuery("state", new String[]{"id","wy"}); 497 | SearchResponse response = client.prepareSearch("bank").setQuery(queryBuilder) 498 | .setFrom(0).setSize(100) 499 | .execute().actionGet(); 500 | System.out.println(response); 501 | }catch (Exception e) { 502 | e.printStackTrace(); 503 | } 504 | } 505 | 506 | @Test 507 | public void testQuery3(){ 508 | try{ 509 | Client client = EsUtil.getClient(); 510 | FilterBuilder filterBuilder = FilterBuilders.andFilter( 511 | FilterBuilders.queryFilter(QueryBuilders.queryString("F").field("gender")), 512 | FilterBuilders.rangeFilter("balance").gt(30000).filterName("balance"), 513 | FilterBuilders.inFilter("age", new Integer[]{30,31,32}).filterName("age") 514 | ); 515 | AggregationBuilder aggregation = AggregationBuilders.global("all").subAggregation(AggregationBuilders.filter("xx").filter(filterBuilder) 516 | .subAggregation(AggregationBuilders.terms("state").field("state"))); 517 | SearchResponse response = client.prepareSearch("bank").setPostFilter(filterBuilder) 518 | .setFrom(0).setSize(10) 519 | .execute().actionGet(); 520 | /*SearchResponse response = client.prepareSearch("bank").addAggregation(aggregation) 521 | .setFrom(0).setSize(10) 522 | .execute().actionGet();*/ 523 | System.out.println(response); 524 | }catch (Exception e) { 525 | e.printStackTrace(); 526 | } 527 | } 528 | 529 | 530 | 531 | @Test 532 | public void testQuery2(){ 533 | try{ 534 | Client client = EsUtil.getClient(); 535 | QueryBuilder queryBuilder = QueryBuilders.rangeQuery("age").gt(10); 536 | QueryBuilder queryBuilder2 = QueryBuilders.matchAllQuery(); 537 | SearchResponse response = client.prepareSearch("bank").setQuery(queryBuilder2) 538 | .addAggregation(AggregationBuilders.global("_counter").subAggregation(AggregationBuilders.terms("state").field("state").size(100) 539 | .subAggregation(AggregationBuilders.terms("city").field("city").size(100)) 540 | .subAggregation(AggregationBuilders.cardinality("distinct").field("account_number")))) 541 | .setFrom(0).setSize(100) 542 | .execute().actionGet(); 543 | System.out.println(response); 544 | }catch (Exception e) { 545 | e.printStackTrace(); 546 | } 547 | } 548 | 549 | 550 | 551 | 552 | @Test 553 | public void testQuery1(){ 554 | Client client = EsUtil.getClient(); 555 | 556 | QueryBuilders.boolQuery().should( 557 | QueryBuilders.boolQuery().must(QueryBuilders.termQuery("location", "beijing")) 558 | .must(QueryBuilders.rangeQuery("age").from(18).to(35)) 559 | .mustNot(QueryBuilders.inQuery("userid", "1","2","3")) 560 | ).should(QueryBuilders.termQuery("is_pre", 1)) 561 | .should(QueryBuilders.fuzzyQuery("val", "china")) 562 | ; 563 | 564 | 565 | QueryBuilders.multiMatchQuery("China", "location","state"); 566 | QueryBuilders.boolQuery().must(QueryBuilders.termQuery("name", "park")) 567 | .must(QueryBuilders.termQuery("home", "beijing")) 568 | .mustNot(QueryBuilders.termQuery("isRealMan", false)) 569 | .should(QueryBuilders.termQuery("location", "beijing")); 570 | 571 | QueryBuilders.filteredQuery(QueryBuilders.matchAllQuery(), 572 | FilterBuilders.boolFilter() 573 | .must(FilterBuilders.termFilter("x", "y")) 574 | 575 | ); 576 | //TemplateQueryBuilder 577 | FilterBuilder fBuilder = FilterBuilders.andFilter( 578 | FilterBuilders.termFilter("appid", "jaidjisleiis"), 579 | FilterBuilders.termFilter("what", "item"), 580 | FilterBuilders.rangeFilter("ds").from("2014-08-12").to("2014-08-13"), 581 | FilterBuilders.orFilter( 582 | FilterBuilders.termFilter("memo", "1"), 583 | FilterBuilders.inFilter("val", "1","2") 584 | ), 585 | FilterBuilders.missingFilter("ip") 586 | 587 | ); 588 | 589 | 590 | client.prepareSearch("index").setTypes("segment").setPostFilter(fBuilder) 591 | .addAggregation(AggregationBuilders.global("ds").subAggregation(AggregationBuilders.global("context.serverid").subAggregation(AggregationBuilders.cardinality("who")))) 592 | .addSort(SortBuilders.fieldSort("context.serverid").sortMode("desc")).setFrom(0).setSize(100).execute().addListener(new ActionListener() { 593 | 594 | @Override 595 | public void onResponse(SearchResponse paramResponse) { 596 | Aggregations aggregations = paramResponse.getAggregations(); 597 | Map map = aggregations.getAsMap(); 598 | for(Map.Entry entry : map.entrySet()){ 599 | String key = entry.getKey(); 600 | Aggregation aggr = entry.getValue(); 601 | 602 | } 603 | } 604 | 605 | @Override 606 | public void onFailure(Throwable paramThrowable) { 607 | 608 | } 609 | }); 610 | 611 | } 612 | 613 | } 614 | -------------------------------------------------------------------------------- /ElasticSearch-SQL/src/com/es/sql/query/QueryFilterHandler.java: -------------------------------------------------------------------------------- 1 | package com.es.sql.query; 2 | 3 | import java.util.ArrayList; 4 | import java.util.HashMap; 5 | import java.util.List; 6 | import java.util.Map; 7 | 8 | import org.apache.commons.lang.StringUtils; 9 | import org.elasticsearch.index.query.FilterBuilder; 10 | import org.elasticsearch.index.query.FilterBuilders; 11 | import org.elasticsearch.index.query.QueryBuilders; 12 | import org.elasticsearch.index.query.QueryStringQueryBuilder; 13 | 14 | import com.es.sql.parse.QuerySqlParser; 15 | import com.es.sql.util.CommonConstant.DataType; 16 | import com.es.sql.util.CommonConstant.Operator; 17 | import com.es.sql.util.CommonUtils; 18 | import com.es.sql.util.RegexCheck; 19 | 20 | /** 21 | * filter查询 22 | * @author wangyong 23 | * 24 | */ 25 | public class QueryFilterHandler { 26 | 27 | 28 | /** 29 | * @param args 30 | */ 31 | public static void main(String[] args) { 32 | String sql = "select ds,serverid,count(distinc userid) as count from index.segment where (appid='10xxxx' and what='item' and (ds between '2014-08-12' and '2014-08-13') and tz='+8') or (axt in(1,2,3) and a='t') or is_admin=1 group by ds,serverid order by count desc limit 0,100"; 33 | //String where = "appid = 'x' and what='item' and (ds between 1 and 2) and (a>10 and a<20) and b not in(3,54,10) and c like '%x'"; 34 | //String where = "(a=x and b=y) or (c=z)"; 35 | //String where = "a=x and b = y or c=z";//非严格语句，不处理 36 | //String where = "a=x or b=y or (c=z and d=t)"; 37 | QuerySqlParser qsp = new QuerySqlParser(sql); 38 | 39 | getFilterBuilder(qsp); 40 | } 41 | 42 | public static FilterBuilder getFilterBuilder(QuerySqlParser qsp){ 43 | FilterBuilder filterBuilder = null; 44 | try{ 45 | String where = qsp.getWhereCondition();//where条件 46 | if(StringUtils.isEmpty(where)){ 47 | return null; 48 | } 49 | Map> map = WhereConditionHandler.handlerWhereCondition(where); 50 | int split1 = 1; 51 | List list1 = null; 52 | Map> map2 = new HashMap>(); 53 | for(Map.Entry> entry : map.entrySet()){ 54 | String key = entry.getKey(); 55 | if(key.startsWith("1_")){//第一层 56 | split1 = getSplit(key); 57 | list1 = getLevelOneFilterBuilder(entry.getValue()); 58 | }else if(key.startsWith("2_")){//第二层 59 | map2.put(key,getLevelTwoFilterBuilder(entry.getValue())); 60 | } 61 | } 62 | List list2 = new ArrayList(); 63 | if(map2!=null && map2.size()>0){ 64 | for(Map.Entry> entry : map2.entrySet()){ 65 | String key = entry.getKey(); 66 | List tmpList = entry.getValue(); 67 | FilterBuilder[] filters = new FilterBuilder[tmpList.size()]; 68 | for(int j=0;j0){ 81 | int length = list1.size(); 82 | if(list2!=null && list2.size()>0){ 83 | length+=list2.size(); 84 | } 85 | FilterBuilder[] filters = new FilterBuilder[length]; 86 | for(int i=0;i0){ 90 | for(int j = 0;j getLevelTwoFilterBuilder(List list){ 114 | List fbList = new ArrayList(); 115 | try{ 116 | if(list!=null && list.size()>0){ 117 | for(String str:list){ 118 | fbList.add(getFilterBuilder(str)); 119 | } 120 | } 121 | }catch (Exception e) { 122 | e.printStackTrace(); 123 | } 124 | 125 | return fbList; 126 | } 127 | 128 | /** 129 | * 一级查询处理 130 | * @param list 131 | * @param split 132 | * @return 133 | */ 134 | private static List getLevelOneFilterBuilder(List list){ 135 | List fbList = new ArrayList(); 136 | try{ 137 | if(list!=null && list.size()>0){ 138 | for(String str:list){ 139 | fbList.add(getFilterBuilder(str)); 140 | } 141 | } 142 | }catch (Exception e) { 143 | e.printStackTrace(); 144 | } 145 | 146 | return fbList; 147 | } 148 | 149 | /** 150 | * 获取一级处理的每一个filterBuilder 151 | * @param condition 152 | * @return 153 | */ 154 | private static FilterBuilder getFilterBuilder(String condition){ 155 | FilterBuilder filterBuilder = null; 156 | String str = condition.trim(); 157 | try{ 158 | if((str.startsWith("(") && str.endsWith(")"))||(str.indexOf("in(")>0 || str.indexOf("in (")>0)){//括弧配对完整,存在二级处理条件的可能性 159 | filterBuilder = analysisComplexWhereConditionFilterBuilder(str); 160 | }else{ 161 | filterBuilder = analysisSingleWhereConditionFilterBuilder(str.trim()); 162 | } 163 | }catch (Exception e) { 164 | e.printStackTrace(); 165 | } 166 | return filterBuilder; 167 | } 168 | 169 | /** 170 | * 分析带有括弧的复杂表达式 171 | * @param str 172 | * @return 173 | */ 174 | private static FilterBuilder analysisComplexWhereConditionFilterBuilder(String str){ 175 | FilterBuilder filterBuilder = null; 176 | try{ 177 | String field = null; 178 | String[] values = null; 179 | Operator operator = Operator.EQ; 180 | DataType dataType = DataType.STRING; 181 | 182 | if((str.indexOf("in(")>0 || str.indexOf("in (")>0 )&& str.indexOf(" and ")<0 && str.indexOf(" or ")<0){//in 或者 not in ，不满足二级处理条件 183 | 184 | Map map = CommonUtils.getValues(str, 1); 185 | for(Map.Entry entry : map.entrySet()){ 186 | dataType = entry.getKey(); 187 | values = entry.getValue(); 188 | System.out.println(values+"------------------------"); 189 | } 190 | 191 | int end = str.indexOf("in(")>0?str.indexOf("in("):str.indexOf("in ("); 192 | field = str.substring(0,end).trim(); 193 | 194 | operator = Operator.IN; 195 | 196 | if(StringUtils.isNotEmpty(field) && values!=null && values.length>0){ 197 | filterBuilder = createFilterBuilder(field, operator, dataType,false,false, values); 198 | } 199 | 200 | }else if((str.indexOf("not in(")>0 || str.indexOf("not in (")>0 )&& str.indexOf(" and ")<0 && str.indexOf(" or ")<0){//in 或者 not in ，不满足二级处理条件 201 | 202 | Map map = CommonUtils.getValues(str, 1); 203 | for(Map.Entry entry : map.entrySet()){ 204 | dataType = entry.getKey(); 205 | values = entry.getValue(); 206 | System.out.println(values+"------------------------"); 207 | } 208 | 209 | int end = str.indexOf("not in"); 210 | field = str.substring(0,end).trim(); 211 | 212 | operator = Operator.NOTIN; 213 | 214 | if(StringUtils.isNotEmpty(field) && values!=null && values.length>0){ 215 | filterBuilder = createFilterBuilder(field, operator, dataType,false,false, values); 216 | } 217 | 218 | }else if(str.indexOf(" between ")>0 && str.indexOf(" and ")>0 && (str.lastIndexOf(" and ")==str.indexOf(" and "))){//between and 219 | 220 | Map map = CommonUtils.getValues(str, 2); 221 | for(Map.Entry entry : map.entrySet()){ 222 | dataType = entry.getKey(); 223 | values = entry.getValue(); 224 | System.out.println(values+"------------------------"); 225 | } 226 | 227 | int end = str.indexOf(" between "); 228 | field = str.substring(str.indexOf("(")+1,end).trim(); 229 | 230 | operator = Operator.RANGE; 231 | 232 | if(StringUtils.isNotEmpty(field) && values!=null && values.length>0){ 233 | filterBuilder = createFilterBuilder(field, operator, dataType,true,true, values); 234 | } 235 | 236 | }else if(str.indexOf(" like ")>0 && str.indexOf(" and ")<0 && str.indexOf(" or ")<0){//只有like一条语句 237 | str = str.trim().substring(1,str.trim().length()-1).trim(); 238 | String[] arr = str.split(" like "); 239 | values = new String[1]; 240 | if(arr.length ==2){ 241 | field = arr[0].trim(); 242 | values[0] = arr[1].trim(); 243 | dataType = DataType.STRING; 244 | if(dataType == DataType.STRING){ 245 | values[0] = values[0].substring(1,values[0].length()); 246 | if(values[0].startsWith("%")){ 247 | values[0] = "*"+values[0].substring(1,values[0].length()); 248 | } 249 | if(values[0].endsWith("%")){ 250 | values[0] = values[0].substring(0,values[0].length()-1)+"*"; 251 | } 252 | } 253 | } 254 | 255 | int end = str.indexOf(" like "); 256 | field = str.substring(0,end).trim(); 257 | 258 | operator = Operator.LIKE; 259 | 260 | if(StringUtils.isNotEmpty(field) && values!=null && values.length>0){ 261 | filterBuilder = createFilterBuilder(field, operator, dataType,false,false, values); 262 | } 263 | 264 | }else {//注定是and组成的range算法 265 | if(str.indexOf(" and ")>0){//包含and语句,且只有1个and,对应的关于一个field的range处理 266 | 267 | Map map = CommonUtils.getValues(str, 3); 268 | for(Map.Entry entry : map.entrySet()){ 269 | dataType = entry.getKey(); 270 | values = entry.getValue(); 271 | System.out.println(values+"------------------------"); 272 | } 273 | 274 | operator = Operator.RANGE; 275 | 276 | String xString = CommonUtils.getFieldIncludeLowerUpper(str); 277 | String[] arr = xString.split("_"); 278 | boolean isL = Integer.parseInt(arr[1])==1?true:false; 279 | boolean isU = Integer.parseInt(arr[2])==1?true:false; 280 | field = arr[0].trim(); 281 | if(StringUtils.isNotEmpty(field) && values!=null && values.length>0){ 282 | filterBuilder = createFilterBuilder(field, operator, dataType,isL,isU, values); 283 | } 284 | } 285 | } 286 | 287 | }catch (Exception e) { 288 | e.printStackTrace(); 289 | } 290 | 291 | return filterBuilder; 292 | } 293 | 294 | 295 | /** 296 | * 普通where condition 表达式分析处理 297 | * @param str 298 | * @return 299 | */ 300 | private static FilterBuilder analysisSingleWhereConditionFilterBuilder(String str){ 301 | FilterBuilder filterBuilder = null; 302 | try{ 303 | String field = null; 304 | String[] values = new String[1]; 305 | Operator operator = Operator.EQ; 306 | DataType dataType = DataType.STRING; 307 | 308 | if(str.indexOf(">=")>0){ 309 | 310 | String[] arr = str.split(">="); 311 | if(arr.length ==2){ 312 | field = arr[0].trim(); 313 | values[0] = arr[1].trim(); 314 | dataType = RegexCheck.getDataType(values[0]); 315 | if(dataType == DataType.STRING){ 316 | values[0] = values[0].substring(1,values[0].length()-1); 317 | } 318 | } 319 | operator = Operator.GTE; 320 | 321 | }else if(str.indexOf("<=")>0){ 322 | 323 | String[] arr = str.split("<="); 324 | if(arr.length ==2){ 325 | field = arr[0].trim(); 326 | values[0] = arr[1].trim(); 327 | dataType = RegexCheck.getDataType(values[0]); 328 | if(dataType == DataType.STRING){ 329 | values[0] = values[0].substring(1,values[0].length()-1); 330 | } 331 | } 332 | operator = Operator.LTE; 333 | 334 | }else if(str.indexOf("!=")>0){ 335 | 336 | String[] arr = str.split("!="); 337 | if(arr.length ==2){ 338 | field = arr[0].trim(); 339 | values[0] = arr[1].trim(); 340 | dataType = RegexCheck.getDataType(values[0]); 341 | if(dataType == DataType.STRING){ 342 | values[0] = values[0].substring(1,values[0].length()-1); 343 | } 344 | } 345 | operator = Operator.NE; 346 | 347 | }else if(str.indexOf(" like ")>0){ 348 | 349 | String[] arr = str.split(" like "); 350 | if(arr.length ==2){ 351 | field = arr[0].trim(); 352 | values[0] = arr[1].trim(); 353 | dataType = DataType.STRING; 354 | if(dataType == DataType.STRING){ 355 | values[0] = values[0].substring(1,values[0].length()-1); 356 | if(values[0].startsWith("%")){ 357 | values[0] = "*"+values[0].substring(1,values[0].length()); 358 | 359 | } 360 | if(values[0].endsWith("%")){ 361 | values[0] = values[0].substring(0,values[0].length()-1)+"*"; 362 | } 363 | } 364 | } 365 | operator = Operator.LIKE; 366 | 367 | }else if(str.indexOf("=")>0){ 368 | 369 | String[] arr = str.split("="); 370 | if(arr.length ==2){ 371 | field = arr[0].trim(); 372 | values[0] = arr[1].trim(); 373 | dataType = RegexCheck.getDataType(values[0]); 374 | if(dataType == DataType.STRING){ 375 | values[0] = values[0].substring(1,values[0].length()-1); 376 | } 377 | } 378 | operator = Operator.EQ; 379 | 380 | }else if(str.indexOf(">")>0){ 381 | 382 | String[] arr = str.split(">"); 383 | if(arr.length ==2){ 384 | field = arr[0].trim(); 385 | values[0] = arr[1].trim(); 386 | dataType = RegexCheck.getDataType(values[0]); 387 | if(dataType == DataType.STRING){ 388 | values[0] = values[0].substring(1,values[0].length()-1); 389 | } 390 | } 391 | operator = Operator.GT; 392 | 393 | }else if(str.indexOf("<")>0){ 394 | 395 | String[] arr = str.split("<"); 396 | if(arr.length ==2){ 397 | field = arr[0].trim(); 398 | values[0] = arr[1].trim(); 399 | dataType = RegexCheck.getDataType(values[0]); 400 | if(dataType == DataType.STRING){ 401 | values[0] = values[0].substring(1,values[0].length()-1); 402 | } 403 | } 404 | operator = Operator.LT; 405 | 406 | } 407 | if(StringUtils.isNotEmpty(field) && values!=null && values.length>0){ 408 | filterBuilder = createFilterBuilder(field, operator, dataType,false,false, values); 409 | } 410 | }catch (Exception e) { 411 | e.printStackTrace(); 412 | } 413 | 414 | return filterBuilder; 415 | } 416 | 417 | /** 418 | * 构造查询过滤条件 419 | * @param field 420 | * @param operator 421 | * @param dataType 422 | * @param values 423 | * @return 424 | */ 425 | private static FilterBuilder createFilterBuilder(String field,Operator operator,DataType dataType,boolean isIncludeLower,boolean isIncludeUpper,String... values){ 426 | FilterBuilder filterBuilder = null; 427 | try{ 428 | 429 | if(operator == Operator.EQ){//等于 430 | filterBuilder = FilterBuilders.queryFilter(QueryBuilders.queryString(values[0]).field(field)); 431 | }else if(operator == Operator.IN){//in 432 | if(dataType == DataType.INT){ 433 | int[] arr = new int[values.length]; 434 | int i = 0; 435 | for(String value:values){ 436 | arr[i++]=Integer.parseInt(value); 437 | } 438 | filterBuilder = FilterBuilders.inFilter(field, arr).filterName(field); 439 | }else if(dataType == DataType.DOUBLE){ 440 | double[] arr = new double[values.length]; 441 | int i = 0; 442 | for(String value:values){ 443 | arr[i++]=Double.parseDouble(value); 444 | } 445 | filterBuilder = FilterBuilders.inFilter(field, arr).filterName(field); 446 | }else if(dataType == DataType.BOOLEAN){//作为字符串处理 447 | filterBuilder = FilterBuilders.inFilter(field, values).filterName(field); 448 | }else{ 449 | filterBuilder = FilterBuilders.inFilter(field, values).filterName(field); 450 | } 451 | 452 | }else if(operator == Operator.NE){//!= 453 | if("null".equals(values[0].toLowerCase())){ 454 | filterBuilder = FilterBuilders.missingFilter(field); 455 | }else{ 456 | /*if(dataType == DataType.INT){ 457 | filterBuilder = FilterBuilders.notFilter(FilterBuilders.termFilter(field, Integer.parseInt(values[0]))); 458 | }else if(dataType == DataType.DOUBLE){ 459 | filterBuilder = FilterBuilders.notFilter(FilterBuilders.termFilter(field, Double.parseDouble(values[0]))); 460 | }else if(dataType == DataType.BOOLEAN){ 461 | filterBuilder = FilterBuilders.notFilter(FilterBuilders.termFilter(field, Boolean.parseBoolean(values[0]))); 462 | }else{//字符串 463 | filterBuilder = FilterBuilders.notFilter(FilterBuilders.termFilter(field, values[0])); 464 | }*/ 465 | filterBuilder = FilterBuilders.notFilter(FilterBuilders.queryFilter(QueryBuilders.queryString(values[0]).field(field))); 466 | } 467 | 468 | }else if(operator == Operator.LIKE){ 469 | filterBuilder = FilterBuilders.queryFilter(QueryBuilders.wildcardQuery(field, values[0])); 470 | }else if(operator == Operator.NOTIN){ 471 | if(dataType == DataType.INT){ 472 | int[] arr = new int[values.length]; 473 | int i = 0; 474 | for(String value:values){ 475 | arr[i++]=Integer.parseInt(value); 476 | } 477 | filterBuilder = FilterBuilders.notFilter(FilterBuilders.inFilter(field, values).filterName(field)); 478 | }else if(dataType == DataType.DOUBLE){ 479 | double[] arr = new double[values.length]; 480 | int i = 0; 481 | for(String value:values){ 482 | arr[i++]=Double.parseDouble(value); 483 | } 484 | filterBuilder = FilterBuilders.notFilter(FilterBuilders.inFilter(field, values).filterName(field)); 485 | }else if(dataType == DataType.BOOLEAN){//作为字符串处理 486 | filterBuilder = FilterBuilders.notFilter(FilterBuilders.inFilter(field, values).filterName(field)); 487 | }else{ 488 | filterBuilder = FilterBuilders.notFilter(FilterBuilders.inFilter(field, values).filterName(field)); 489 | } 490 | }else if(operator == Operator.RANGE){ 491 | if(dataType == DataType.INT){ 492 | int[] arr = new int[values.length]; 493 | int i = 0; 494 | for(String value:values){ 495 | arr[i++]=Integer.parseInt(value); 496 | } 497 | filterBuilder = FilterBuilders.rangeFilter(field).filterName(field).from(arr[0]).to(arr[1]).includeLower(isIncludeLower).includeUpper(isIncludeUpper); 498 | }else if(dataType == DataType.DOUBLE){ 499 | double[] arr = new double[values.length]; 500 | int i = 0; 501 | for(String value:values){ 502 | arr[i++]=Double.parseDouble(value); 503 | } 504 | filterBuilder = FilterBuilders.rangeFilter(field).filterName(field).from(arr[0]).to(arr[1]).includeLower(isIncludeLower).includeUpper(isIncludeUpper); 505 | }else if(dataType == DataType.BOOLEAN){//作为字符串处理 506 | filterBuilder = FilterBuilders.rangeFilter(field).filterName(field).from(values[0]).to(values[1]).includeLower(isIncludeLower).includeUpper(isIncludeUpper); 507 | }else{ 508 | filterBuilder = FilterBuilders.rangeFilter(field).filterName(field).from(values[0]).to(values[1]).includeLower(isIncludeLower).includeUpper(isIncludeUpper); 509 | } 510 | }else if(operator == Operator.GT){ 511 | if(dataType == DataType.INT){ 512 | filterBuilder = FilterBuilders.rangeFilter(field).gt(Integer.parseInt(values[0])).filterName(field); 513 | }else if(dataType == DataType.DOUBLE){ 514 | filterBuilder = FilterBuilders.rangeFilter(field).gt(Double.parseDouble(values[0])).filterName(field); 515 | }else if(dataType == DataType.BOOLEAN){ 516 | filterBuilder = FilterBuilders.rangeFilter(field).gt(Boolean.parseBoolean(values[0])).filterName(field); 517 | }else{//字符串 518 | filterBuilder = FilterBuilders.rangeFilter(field).gt(values[0]).filterName(field); 519 | } 520 | }else if(operator == Operator.GTE){ 521 | if(dataType == DataType.INT){ 522 | filterBuilder = FilterBuilders.rangeFilter(field).gte(Integer.parseInt(values[0])).filterName(field); 523 | }else if(dataType == DataType.DOUBLE){ 524 | filterBuilder = FilterBuilders.rangeFilter(field).gte(Double.parseDouble(values[0])).filterName(field); 525 | }else if(dataType == DataType.BOOLEAN){ 526 | filterBuilder = FilterBuilders.rangeFilter(field).gte(Boolean.parseBoolean(values[0])).filterName(field); 527 | }else{//字符串 528 | filterBuilder = FilterBuilders.rangeFilter(field).gte(values[0]).filterName(field); 529 | } 530 | }else if(operator == Operator.LT){ 531 | if(dataType == DataType.INT){ 532 | filterBuilder = FilterBuilders.rangeFilter(field).lt(Integer.parseInt(values[0])).filterName(field); 533 | }else if(dataType == DataType.DOUBLE){ 534 | filterBuilder = FilterBuilders.rangeFilter(field).lt(Double.parseDouble(values[0])).filterName(field); 535 | }else if(dataType == DataType.BOOLEAN){ 536 | filterBuilder = FilterBuilders.rangeFilter(field).lt(Boolean.parseBoolean(values[0])).filterName(field); 537 | }else{//字符串 538 | filterBuilder = FilterBuilders.rangeFilter(field).lt(values[0]).filterName(field); 539 | } 540 | }else if(operator == Operator.LTE){ 541 | if(dataType == DataType.INT){ 542 | filterBuilder = FilterBuilders.rangeFilter(field).lte(Integer.parseInt(values[0])).filterName(field); 543 | }else if(dataType == DataType.DOUBLE){ 544 | filterBuilder = FilterBuilders.rangeFilter(field).lte(Double.parseDouble(values[0])).filterName(field); 545 | }else if(dataType == DataType.BOOLEAN){ 546 | filterBuilder = FilterBuilders.rangeFilter(field).lte(Boolean.parseBoolean(values[0])).filterName(field); 547 | }else{//字符串 548 | filterBuilder = FilterBuilders.rangeFilter(field).lte(values[0]).filterName(field); 549 | } 550 | } 551 | }catch (Exception e) { 552 | e.printStackTrace(); 553 | } 554 | return filterBuilder; 555 | } 556 | /** 557 | * 构造查询过滤条件 558 | * @param field 559 | * @param operator 560 | * @param dataType 561 | * @param values 562 | * @return 563 | */ 564 | private static FilterBuilder createFilterBuilder2(String field,Operator operator,DataType dataType,boolean isIncludeLower,boolean isIncludeUpper,String... values){ 565 | FilterBuilder filterBuilder = null; 566 | try{ 567 | 568 | if(operator == Operator.EQ){//等于 569 | 570 | if(dataType == DataType.INT){ 571 | filterBuilder = FilterBuilders.termFilter(field, Integer.parseInt(values[0])); 572 | }else if(dataType == DataType.DOUBLE){ 573 | filterBuilder = FilterBuilders.termFilter(field, Double.parseDouble(values[0])); 574 | }else if(dataType == DataType.BOOLEAN){ 575 | filterBuilder = FilterBuilders.termFilter(field, Boolean.parseBoolean(values[0])); 576 | }else{//字符串 577 | filterBuilder = FilterBuilders.termFilter(field, values[0]); 578 | } 579 | }else if(operator == Operator.IN){//in 580 | if(dataType == DataType.INT){ 581 | int[] arr = new int[values.length]; 582 | int i = 0; 583 | for(String value:values){ 584 | arr[i++]=Integer.parseInt(value); 585 | } 586 | filterBuilder = FilterBuilders.inFilter(field, arr); 587 | }else if(dataType == DataType.DOUBLE){ 588 | double[] arr = new double[values.length]; 589 | int i = 0; 590 | for(String value:values){ 591 | arr[i++]=Double.parseDouble(value); 592 | } 593 | filterBuilder = FilterBuilders.inFilter(field, arr); 594 | }else if(dataType == DataType.BOOLEAN){//作为字符串处理 595 | filterBuilder = FilterBuilders.inFilter(field, values); 596 | }else{ 597 | filterBuilder = FilterBuilders.inFilter(field, values); 598 | } 599 | 600 | }else if(operator == Operator.NE){//!= 601 | if("null".equals(values[0].toLowerCase())){ 602 | filterBuilder = FilterBuilders.missingFilter(field); 603 | }else{ 604 | if(dataType == DataType.INT){ 605 | filterBuilder = FilterBuilders.notFilter(FilterBuilders.termFilter(field, Integer.parseInt(values[0]))); 606 | }else if(dataType == DataType.DOUBLE){ 607 | filterBuilder = FilterBuilders.notFilter(FilterBuilders.termFilter(field, Double.parseDouble(values[0]))); 608 | }else if(dataType == DataType.BOOLEAN){ 609 | filterBuilder = FilterBuilders.notFilter(FilterBuilders.termFilter(field, Boolean.parseBoolean(values[0]))); 610 | }else{//字符串 611 | filterBuilder = FilterBuilders.notFilter(FilterBuilders.termFilter(field, values[0])); 612 | } 613 | } 614 | 615 | }else if(operator == Operator.LIKE){ 616 | 617 | }else if(operator == Operator.NOTIN){ 618 | if(dataType == DataType.INT){ 619 | int[] arr = new int[values.length]; 620 | int i = 0; 621 | for(String value:values){ 622 | arr[i++]=Integer.parseInt(value); 623 | } 624 | filterBuilder = FilterBuilders.notFilter(FilterBuilders.inFilter(field, values)); 625 | }else if(dataType == DataType.DOUBLE){ 626 | double[] arr = new double[values.length]; 627 | int i = 0; 628 | for(String value:values){ 629 | arr[i++]=Double.parseDouble(value); 630 | } 631 | filterBuilder = FilterBuilders.notFilter(FilterBuilders.inFilter(field, values)); 632 | }else if(dataType == DataType.BOOLEAN){//作为字符串处理 633 | filterBuilder = FilterBuilders.notFilter(FilterBuilders.inFilter(field, values)); 634 | }else{ 635 | filterBuilder = FilterBuilders.notFilter(FilterBuilders.inFilter(field, values)); 636 | } 637 | }else if(operator == Operator.RANGE){ 638 | if(dataType == DataType.INT){ 639 | int[] arr = new int[values.length]; 640 | int i = 0; 641 | for(String value:values){ 642 | arr[i++]=Integer.parseInt(value); 643 | } 644 | filterBuilder = FilterBuilders.rangeFilter(field).from(arr[0]).to(arr[1]).includeLower(isIncludeLower).includeUpper(isIncludeUpper); 645 | }else if(dataType == DataType.DOUBLE){ 646 | double[] arr = new double[values.length]; 647 | int i = 0; 648 | for(String value:values){ 649 | arr[i++]=Double.parseDouble(value); 650 | } 651 | filterBuilder = FilterBuilders.rangeFilter(field).from(arr[0]).to(arr[1]).includeLower(isIncludeLower).includeUpper(isIncludeUpper); 652 | }else if(dataType == DataType.BOOLEAN){//作为字符串处理 653 | filterBuilder = FilterBuilders.rangeFilter(field).from(values[0]).to(values[1]).includeLower(isIncludeLower).includeUpper(isIncludeUpper); 654 | }else{ 655 | filterBuilder = FilterBuilders.rangeFilter(field).from(values[0]).to(values[1]).includeLower(isIncludeLower).includeUpper(isIncludeUpper); 656 | } 657 | }else if(operator == Operator.GT){ 658 | if(dataType == DataType.INT){ 659 | filterBuilder = FilterBuilders.rangeFilter(field).gt(Integer.parseInt(values[0])); 660 | }else if(dataType == DataType.DOUBLE){ 661 | filterBuilder = FilterBuilders.rangeFilter(field).gt(Double.parseDouble(values[0])); 662 | }else if(dataType == DataType.BOOLEAN){ 663 | filterBuilder = FilterBuilders.rangeFilter(field).gt(Boolean.parseBoolean(values[0])); 664 | }else{//字符串 665 | filterBuilder = FilterBuilders.rangeFilter(field).gt(values[0]); 666 | } 667 | }else if(operator == Operator.GTE){ 668 | if(dataType == DataType.INT){ 669 | filterBuilder = FilterBuilders.rangeFilter(field).gte(Integer.parseInt(values[0])); 670 | }else if(dataType == DataType.DOUBLE){ 671 | filterBuilder = FilterBuilders.rangeFilter(field).gte(Double.parseDouble(values[0])); 672 | }else if(dataType == DataType.BOOLEAN){ 673 | filterBuilder = FilterBuilders.rangeFilter(field).gte(Boolean.parseBoolean(values[0])); 674 | }else{//字符串 675 | filterBuilder = FilterBuilders.rangeFilter(field).gte(values[0]); 676 | } 677 | }else if(operator == Operator.LT){ 678 | if(dataType == DataType.INT){ 679 | filterBuilder = FilterBuilders.rangeFilter(field).lt(Integer.parseInt(values[0])); 680 | }else if(dataType == DataType.DOUBLE){ 681 | filterBuilder = FilterBuilders.rangeFilter(field).lt(Double.parseDouble(values[0])); 682 | }else if(dataType == DataType.BOOLEAN){ 683 | filterBuilder = FilterBuilders.rangeFilter(field).lt(Boolean.parseBoolean(values[0])); 684 | }else{//字符串 685 | filterBuilder = FilterBuilders.rangeFilter(field).lt(values[0]); 686 | } 687 | }else if(operator == Operator.LTE){ 688 | if(dataType == DataType.INT){ 689 | filterBuilder = FilterBuilders.rangeFilter(field).lte(Integer.parseInt(values[0])); 690 | }else if(dataType == DataType.DOUBLE){ 691 | filterBuilder = FilterBuilders.rangeFilter(field).lte(Double.parseDouble(values[0])); 692 | }else if(dataType == DataType.BOOLEAN){ 693 | filterBuilder = FilterBuilders.rangeFilter(field).lte(Boolean.parseBoolean(values[0])); 694 | }else{//字符串 695 | filterBuilder = FilterBuilders.rangeFilter(field).lte(values[0]); 696 | } 697 | } 698 | }catch (Exception e) { 699 | e.printStackTrace(); 700 | } 701 | return filterBuilder; 702 | } 703 | private static Object caseType(DataType dataType,String value){ 704 | if(dataType == DataType.INT){ 705 | return Integer.parseInt(value); 706 | }else if(dataType == DataType.DOUBLE){ 707 | return Double.parseDouble(value); 708 | }else if(dataType == DataType.BOOLEAN){ 709 | return Boolean.parseBoolean(value); 710 | }else{ 711 | return value; 712 | } 713 | } 714 | /** 715 | * 获取连接字符 and or 716 | * @param key 717 | * @return 718 | */ 719 | private static int getSplit(String key){ 720 | int split = 0; 721 | String[] arr = key.split("_"); 722 | if("1".equals(arr[1])){ 723 | split = 1; 724 | }else if("2".equals(arr[1])){ 725 | split = 2; 726 | } 727 | return split; 728 | } 729 | } 730 | --------------------------------------------------------------------------------