elstic sql2dsl

.gitignore

@@ -0,0 +1,31 @@
+*.class
+
+# Package Files #
+*.jar
+*.war
+*.ear
+
+*.ipr
+*.iws
+*.iml
+.classpath
+.gradle*
+build/*
+target/*
+out
+.idea
+draft.story
+chromedriver.log
+.classpath
+.gitignore.swp
+.project
+.settings/
+*.ids
+gradle.properties
+*.log
+*.log.*
+*.bak
+cango*
+bin/
+.download/*
+logs/*

pom.xml

@@ -0,0 +1,142 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project xmlns="http://maven.apache.org/POM/4.0.0"
+         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
+    <name>elasticsearch-sql2dsl</name>
+    <modelVersion>4.0.0</modelVersion>
+    <groupId>org.elasticsearch</groupId>
+    <artifactId>elasticsearch-sql2dsl</artifactId>
+    <version>${elasticsearch.version}</version>
+    <packaging>jar</packaging>
+    <description>elasticsearch-sql2dsl</description>
+    <inceptionYear>2016</inceptionYear>
+    <licenses>
+        <license>
+            <name>The Apache Software License, Version 2.0</name>
+            <url>http://www.apache.org/licenses/LICENSE-2.0.txt</url>
+            <distribution>repo</distribution>
+        </license>
+    </licenses>
+
+    <properties>
+        <elasticsearch.version>1.4.5</elasticsearch.version>
+        <maven.compiler.target>1.8</maven.compiler.target>
+        <skip.unit.tests>true</skip.unit.tests>
+    </properties>
+	
+    <repositories>
+        <repository>
+            <id>uk.maven.org</id>
+            <name>UK MAVEN</name>
+            <releases>
+                <enabled>true</enabled>
+            </releases>
+            <snapshots>
+                <enabled>true</enabled>
+            </snapshots>
+            <url>http://uk.maven.org/maven2/</url>
+        </repository>
+    </repositories>
+
+    <dependencies>
+        <dependency>
+			 <groupId>com.alibaba</groupId>
+			 <artifactId>druid</artifactId>
+			 <version>1.0.24</version>
+		</dependency>
+
+        <dependency>
+            <groupId>com.google.guava</groupId>
+            <artifactId>guava</artifactId>
+            <version>18.0</version>
+        </dependency>
+
+        <dependency>
+            <groupId>com.google.code.gson</groupId>
+            <artifactId>gson</artifactId>
+            <version>2.3.1</version>
+        </dependency>
+
+        <dependency>
+            <groupId>commons-collections</groupId>
+            <artifactId>commons-collections</artifactId>
+            <version>3.2.1</version>
+        </dependency>
+
+
+
+        <dependency>
+            <groupId>org.elasticsearch</groupId>
+            <artifactId>elasticsearch</artifactId>
+            <version>${elasticsearch.version}</version>
+            <scope>compile</scope>
+        </dependency>
+
+        <dependency>
+            <groupId>org.apache.logging.log4j</groupId>
+            <artifactId>log4j-api</artifactId>
+            <version>2.3</version>
+        </dependency>
+
+		<dependency>
+            <groupId>junit</groupId>
+            <artifactId>junit</artifactId>
+            <version>4.12</version>
+            <scope>test</scope>
+        </dependency>
+    </dependencies>
+
+    <build>
+        <plugins>
+            <plugin>
+                <groupId>org.apache.maven.plugins</groupId>
+                <artifactId>maven-compiler-plugin</artifactId>
+                <version>2.3.2</version>
+                <configuration>
+                    <encoding>utf-8</encoding>
+                    <source>1.8</source>
+                    <target>1.8</target>
+                </configuration>
+            </plugin>
+            <plugin>
+                <groupId>org.apache.maven.plugins</groupId>
+                <artifactId>maven-surefire-plugin</artifactId>
+                <version>2.11</version>
+                <configuration>
+                    <includes>
+                        <include>**/*Tests.java</include>
+                    </includes>
+                </configuration>
+            </plugin>
+            <plugin>
+                <groupId>org.apache.maven.plugins</groupId>
+                <artifactId>maven-source-plugin</artifactId>
+                <version>2.1.2</version>
+                <executions>
+                    <execution>
+                        <id>attach-sources</id>
+                        <goals>
+                            <goal>jar</goal>
+                        </goals>
+                    </execution>
+                </executions>
+            </plugin>
+            <plugin>
+                <artifactId>maven-assembly-plugin</artifactId>
+                <version>2.3</version>
+                <configuration>
+                    <appendAssemblyId>false</appendAssemblyId>
+                    <outputDirectory>${project.build.directory}/releases/</outputDirectory>
+                </configuration>
+                <executions>
+                    <execution>
+                        <phase>package</phase>
+                        <goals>
+                            <goal>single</goal>
+                        </goals>
+                    </execution>
+                </executions>
+            </plugin>
+        </plugins>
+    </build>
+</project>

src/main/java/org/elasticsearch/ElasticMockClient.java

@@ -0,0 +1,482 @@
+package org.elasticsearch;
+
+import org.elasticsearch.action.*;
+import org.elasticsearch.action.bulk.BulkRequest;
+import org.elasticsearch.action.bulk.BulkRequestBuilder;
+import org.elasticsearch.action.bulk.BulkResponse;
+import org.elasticsearch.action.count.CountRequest;
+import org.elasticsearch.action.count.CountRequestBuilder;
+import org.elasticsearch.action.count.CountResponse;
+import org.elasticsearch.action.delete.DeleteRequest;
+import org.elasticsearch.action.delete.DeleteRequestBuilder;
+import org.elasticsearch.action.delete.DeleteResponse;
+import org.elasticsearch.action.deletebyquery.DeleteByQueryRequest;
+import org.elasticsearch.action.deletebyquery.DeleteByQueryRequestBuilder;
+import org.elasticsearch.action.deletebyquery.DeleteByQueryResponse;
+import org.elasticsearch.action.exists.ExistsRequest;
+import org.elasticsearch.action.exists.ExistsRequestBuilder;
+import org.elasticsearch.action.exists.ExistsResponse;
+import org.elasticsearch.action.explain.ExplainRequest;
+import org.elasticsearch.action.explain.ExplainRequestBuilder;
+import org.elasticsearch.action.explain.ExplainResponse;
+import org.elasticsearch.action.get.*;
+import org.elasticsearch.action.index.IndexRequest;
+import org.elasticsearch.action.index.IndexRequestBuilder;
+import org.elasticsearch.action.index.IndexResponse;
+import org.elasticsearch.action.indexedscripts.delete.DeleteIndexedScriptRequest;
+import org.elasticsearch.action.indexedscripts.delete.DeleteIndexedScriptRequestBuilder;
+import org.elasticsearch.action.indexedscripts.delete.DeleteIndexedScriptResponse;
+import org.elasticsearch.action.indexedscripts.get.GetIndexedScriptRequest;
+import org.elasticsearch.action.indexedscripts.get.GetIndexedScriptRequestBuilder;
+import org.elasticsearch.action.indexedscripts.get.GetIndexedScriptResponse;
+import org.elasticsearch.action.indexedscripts.put.PutIndexedScriptRequest;
+import org.elasticsearch.action.indexedscripts.put.PutIndexedScriptRequestBuilder;
+import org.elasticsearch.action.indexedscripts.put.PutIndexedScriptResponse;
+import org.elasticsearch.action.mlt.MoreLikeThisRequest;
+import org.elasticsearch.action.mlt.MoreLikeThisRequestBuilder;
+import org.elasticsearch.action.percolate.*;
+import org.elasticsearch.action.search.*;
+import org.elasticsearch.action.suggest.SuggestRequest;
+import org.elasticsearch.action.suggest.SuggestRequestBuilder;
+import org.elasticsearch.action.suggest.SuggestResponse;
+import org.elasticsearch.action.termvector.*;
+import org.elasticsearch.action.update.UpdateRequest;
+import org.elasticsearch.action.update.UpdateRequestBuilder;
+import org.elasticsearch.action.update.UpdateResponse;
+import org.elasticsearch.client.AdminClient;
+import org.elasticsearch.client.Client;
+import org.elasticsearch.common.settings.Settings;
+import org.elasticsearch.threadpool.ThreadPool;
+
+public class ElasticMockClient implements Client {
+    @Override
+    public ThreadPool threadPool() {
+        return null;
+    }
+
+    @Override
+    public AdminClient admin() {
+        return null;
+    }
+
+    @Override
+    public ActionFuture<IndexResponse> index(IndexRequest indexRequest) {
+        return null;
+    }
+
+    @Override
+    public void index(IndexRequest indexRequest, ActionListener<IndexResponse> actionListener) {
+
+    }
+
+    @Override
+    public IndexRequestBuilder prepareIndex() {
+        return null;
+    }
+
+    @Override
+    public ActionFuture<UpdateResponse> update(UpdateRequest updateRequest) {
+        return null;
+    }
+
+    @Override
+    public void update(UpdateRequest updateRequest, ActionListener<UpdateResponse> actionListener) {
+
+    }
+
+    @Override
+    public UpdateRequestBuilder prepareUpdate() {
+        return null;
+    }
+
+    @Override
+    public UpdateRequestBuilder prepareUpdate(String s, String s1, String s2) {
+        return null;
+    }
+
+    @Override
+    public IndexRequestBuilder prepareIndex(String s, String s1) {
+        return null;
+    }
+
+    @Override
+    public IndexRequestBuilder prepareIndex(String s, String s1, String s2) {
+        return null;
+    }
+
+    @Override
+    public ActionFuture<DeleteResponse> delete(DeleteRequest deleteRequest) {
+        return null;
+    }
+
+    @Override
+    public void delete(DeleteRequest deleteRequest, ActionListener<DeleteResponse> actionListener) {
+
+    }
+
+    @Override
+    public DeleteRequestBuilder prepareDelete() {
+        return null;
+    }
+
+    @Override
+    public DeleteRequestBuilder prepareDelete(String s, String s1, String s2) {
+        return null;
+    }
+
+    @Override
+    public ActionFuture<BulkResponse> bulk(BulkRequest bulkRequest) {
+        return null;
+    }
+
+    @Override
+    public void bulk(BulkRequest bulkRequest, ActionListener<BulkResponse> actionListener) {
+
+    }
+
+    @Override
+    public BulkRequestBuilder prepareBulk() {
+        return null;
+    }
+
+    @Override
+    public ActionFuture<DeleteByQueryResponse> deleteByQuery(DeleteByQueryRequest deleteByQueryRequest) {
+        return null;
+    }
+
+    @Override
+    public void deleteByQuery(DeleteByQueryRequest deleteByQueryRequest, ActionListener<DeleteByQueryResponse> actionListener) {
+
+    }
+
+    @Override
+    public DeleteByQueryRequestBuilder prepareDeleteByQuery(String... strings) {
+        return null;
+    }
+
+    @Override
+    public ActionFuture<GetResponse> get(GetRequest getRequest) {
+        return null;
+    }
+
+    @Override
+    public void get(GetRequest getRequest, ActionListener<GetResponse> actionListener) {
+
+    }
+
+    @Override
+    public GetRequestBuilder prepareGet() {
+        return null;
+    }
+
+    @Override
+    public GetRequestBuilder prepareGet(String s, String s1, String s2) {
+        return null;
+    }
+
+    @Override
+    public PutIndexedScriptRequestBuilder preparePutIndexedScript() {
+        return null;
+    }
+
+    @Override
+    public PutIndexedScriptRequestBuilder preparePutIndexedScript(String s, String s1, String s2) {
+        return null;
+    }
+
+    @Override
+    public void deleteIndexedScript(DeleteIndexedScriptRequest deleteIndexedScriptRequest, ActionListener<DeleteIndexedScriptResponse> actionListener) {
+
+    }
+
+    @Override
+    public ActionFuture<DeleteIndexedScriptResponse> deleteIndexedScript(DeleteIndexedScriptRequest deleteIndexedScriptRequest) {
+        return null;
+    }
+
+    @Override
+    public DeleteIndexedScriptRequestBuilder prepareDeleteIndexedScript() {
+        return null;
+    }
+
+    @Override
+    public DeleteIndexedScriptRequestBuilder prepareDeleteIndexedScript(String s, String s1) {
+        return null;
+    }
+
+    @Override
+    public void putIndexedScript(PutIndexedScriptRequest putIndexedScriptRequest, ActionListener<PutIndexedScriptResponse> actionListener) {
+
+    }
+
+    @Override
+    public ActionFuture<PutIndexedScriptResponse> putIndexedScript(PutIndexedScriptRequest putIndexedScriptRequest) {
+        return null;
+    }
+
+    @Override
+    public GetIndexedScriptRequestBuilder prepareGetIndexedScript() {
+        return null;
+    }
+
+    @Override
+    public GetIndexedScriptRequestBuilder prepareGetIndexedScript(String s, String s1) {
+        return null;
+    }
+
+    @Override
+    public void getIndexedScript(GetIndexedScriptRequest getIndexedScriptRequest, ActionListener<GetIndexedScriptResponse> actionListener) {
+
+    }
+
+    @Override
+    public ActionFuture<GetIndexedScriptResponse> getIndexedScript(GetIndexedScriptRequest getIndexedScriptRequest) {
+        return null;
+    }
+
+    @Override
+    public ActionFuture<MultiGetResponse> multiGet(MultiGetRequest multiGetRequest) {
+        return null;
+    }
+
+    @Override
+    public void multiGet(MultiGetRequest multiGetRequest, ActionListener<MultiGetResponse> actionListener) {
+
+    }
+
+    @Override
+    public MultiGetRequestBuilder prepareMultiGet() {
+        return null;
+    }
+
+    @Override
+    public ActionFuture<CountResponse> count(CountRequest countRequest) {
+        return null;
+    }
+
+    @Override
+    public void count(CountRequest countRequest, ActionListener<CountResponse> actionListener) {
+
+    }
+
+    @Override
+    public CountRequestBuilder prepareCount(String... strings) {
+        return null;
+    }
+
+    @Override
+    public ActionFuture<ExistsResponse> exists(ExistsRequest existsRequest) {
+        return null;
+    }
+
+    @Override
+    public void exists(ExistsRequest existsRequest, ActionListener<ExistsResponse> actionListener) {
+
+    }
+
+    @Override
+    public ExistsRequestBuilder prepareExists(String... strings) {
+        return null;
+    }
+
+    @Override
+    public ActionFuture<SuggestResponse> suggest(SuggestRequest suggestRequest) {
+        return null;
+    }
+
+    @Override
+    public void suggest(SuggestRequest suggestRequest, ActionListener<SuggestResponse> actionListener) {
+
+    }
+
+    @Override
+    public SuggestRequestBuilder prepareSuggest(String... strings) {
+        return null;
+    }
+
+    @Override
+    public ActionFuture<SearchResponse> search(SearchRequest searchRequest) {
+        return null;
+    }
+
+    @Override
+    public void search(SearchRequest searchRequest, ActionListener<SearchResponse> actionListener) {
+
+    }
+
+    @Override
+    public SearchRequestBuilder prepareSearch(String... strings) {
+        return null;
+    }
+
+    @Override
+    public ActionFuture<SearchResponse> searchScroll(SearchScrollRequest searchScrollRequest) {
+        return null;
+    }
+
+    @Override
+    public void searchScroll(SearchScrollRequest searchScrollRequest, ActionListener<SearchResponse> actionListener) {
+
+    }
+
+    @Override
+    public SearchScrollRequestBuilder prepareSearchScroll(String s) {
+        return null;
+    }
+
+    @Override
+    public ActionFuture<MultiSearchResponse> multiSearch(MultiSearchRequest multiSearchRequest) {
+        return null;
+    }
+
+    @Override
+    public void multiSearch(MultiSearchRequest multiSearchRequest, ActionListener<MultiSearchResponse> actionListener) {
+
+    }
+
+    @Override
+    public MultiSearchRequestBuilder prepareMultiSearch() {
+        return null;
+    }
+
+    @Override
+    public ActionFuture<SearchResponse> moreLikeThis(MoreLikeThisRequest moreLikeThisRequest) {
+        return null;
+    }
+
+    @Override
+    public void moreLikeThis(MoreLikeThisRequest moreLikeThisRequest, ActionListener<SearchResponse> actionListener) {
+
+    }
+
+    @Override
+    public MoreLikeThisRequestBuilder prepareMoreLikeThis(String s, String s1, String s2) {
+        return null;
+    }
+
+    @Override
+    public ActionFuture<TermVectorResponse> termVector(TermVectorRequest termVectorRequest) {
+        return null;
+    }
+
+    @Override
+    public void termVector(TermVectorRequest termVectorRequest, ActionListener<TermVectorResponse> actionListener) {
+
+    }
+
+    @Override
+    public TermVectorRequestBuilder prepareTermVector() {
+        return null;
+    }
+
+    @Override
+    public TermVectorRequestBuilder prepareTermVector(String s, String s1, String s2) {
+        return null;
+    }
+
+    @Override
+    public ActionFuture<MultiTermVectorsResponse> multiTermVectors(MultiTermVectorsRequest multiTermVectorsRequest) {
+        return null;
+    }
+
+    @Override
+    public void multiTermVectors(MultiTermVectorsRequest multiTermVectorsRequest, ActionListener<MultiTermVectorsResponse> actionListener) {
+
+    }
+
+    @Override
+    public MultiTermVectorsRequestBuilder prepareMultiTermVectors() {
+        return null;
+    }
+
+    @Override
+    public ActionFuture<PercolateResponse> percolate(PercolateRequest percolateRequest) {
+        return null;
+    }
+
+    @Override
+    public void percolate(PercolateRequest percolateRequest, ActionListener<PercolateResponse> actionListener) {
+
+    }
+
+    @Override
+    public PercolateRequestBuilder preparePercolate() {
+        return null;
+    }
+
+    @Override
+    public ActionFuture<MultiPercolateResponse> multiPercolate(MultiPercolateRequest multiPercolateRequest) {
+        return null;
+    }
+
+    @Override
+    public void multiPercolate(MultiPercolateRequest multiPercolateRequest, ActionListener<MultiPercolateResponse> actionListener) {
+
+    }
+
+    @Override
+    public MultiPercolateRequestBuilder prepareMultiPercolate() {
+        return null;
+    }
+
+    @Override
+    public ExplainRequestBuilder prepareExplain(String s, String s1, String s2) {
+        return null;
+    }
+
+    @Override
+    public ActionFuture<ExplainResponse> explain(ExplainRequest explainRequest) {
+        return null;
+    }
+
+    @Override
+    public void explain(ExplainRequest explainRequest, ActionListener<ExplainResponse> actionListener) {
+
+    }
+
+    @Override
+    public ClearScrollRequestBuilder prepareClearScroll() {
+        return null;
+    }
+
+    @Override
+    public ActionFuture<ClearScrollResponse> clearScroll(ClearScrollRequest clearScrollRequest) {
+        return null;
+    }
+
+    @Override
+    public void clearScroll(ClearScrollRequest clearScrollRequest, ActionListener<ClearScrollResponse> actionListener) {
+
+    }
+
+    @Override
+    public Settings settings() {
+        return null;
+    }
+
+    @Override
+    public <Request extends ActionRequest, Response extends ActionResponse, RequestBuilder extends ActionRequestBuilder<Request, Response, RequestBuilder, Client>> ActionFuture<Response> execute(Action<Request, Response, RequestBuilder, Client> action, Request request) {
+        return null;
+    }
+
+    @Override
+    public <Request extends ActionRequest, Response extends ActionResponse, RequestBuilder extends ActionRequestBuilder<Request, Response, RequestBuilder, Client>> void execute(Action<Request, Response, RequestBuilder, Client> action, Request request, ActionListener<Response> actionListener) {
+
+    }
+
+    @Override
+    public <Request extends ActionRequest, Response extends ActionResponse, RequestBuilder extends ActionRequestBuilder<Request, Response, RequestBuilder, Client>> RequestBuilder prepareExecute(Action<Request, Response, RequestBuilder, Client> action) {
+        return null;
+    }
+
+    @Override
+    public void close() throws ElasticsearchException {
+
+    }
+
+    private static final Client mockClient = new ElasticMockClient();
+
+    public static Client get() {
+        return mockClient;
+    }
+}

src/main/java/org/elasticsearch/dsl/ElasticDslBuilder.java

@@ -0,0 +1,98 @@
+package org.elasticsearch.dsl;
+
+import com.alibaba.druid.sql.ast.SQLExpr;
+import com.alibaba.druid.sql.ast.expr.SQLBinaryOpExpr;
+import com.alibaba.druid.sql.ast.expr.SQLIdentifierExpr;
+import com.alibaba.druid.sql.ast.expr.SQLPropertyExpr;
+import com.alibaba.druid.sql.ast.expr.SQLQueryExpr;
+import com.google.common.collect.Lists;
+import org.elasticsearch.dsl.exception.ElasticSql2DslException;
+import org.elasticsearch.index.query.BoolFilterBuilder;
+import org.elasticsearch.sql.ElasticSqlSelectQueryBlock;
+import org.elasticsearch.utils.StringUtils;
+
+import java.util.List;
+
+public class ElasticDslBuilder {
+
+    private SQLQueryExpr queryExpr;
+
+    public ElasticDslBuilder(SQLQueryExpr queryExpr) {
+        this.queryExpr = queryExpr;
+    }
+
+    public ElasticDslContext build() {
+        ElasticDslContext dslContext = new ElasticDslContext();
+        if (queryExpr.getSubQuery().getQuery() instanceof ElasticSqlSelectQueryBlock) {
+            ElasticSqlSelectQueryBlock queryBlock = (ElasticSqlSelectQueryBlock) queryExpr.getSubQuery().getQuery();
+            //解析SQL指定索引别名
+            parseQueryAs(dslContext, queryBlock);
+            //解析SQL查询条件
+            parseFilterCondition(dslContext.boolFilter(), queryBlock.getWhere());
+            //解析查询阶段
+            parseSelectFieldList(dslContext, queryBlock);
+        }
+        return dslContext;
+    }
+
+    private void parseFilterCondition(BoolFilterBuilder filterBuilder, SQLExpr sqlExpr) {
+        System.out.println(sqlExpr.getClass());
+        if (sqlExpr == null) {
+            return;
+        }
+
+        //throw new ElasticSql2DslException("[syntax error] Where condition not support type: " + sqlExpr.getClass());
+
+        if (sqlExpr instanceof SQLBinaryOpExpr) {
+            SQLBinaryOpExpr sqlBinOpExpr = (SQLBinaryOpExpr) sqlExpr;
+        }
+    }
+
+    private void parseQueryAs(ElasticDslContext dslContext, ElasticSqlSelectQueryBlock queryBlock) {
+        dslContext.setQueryAs(queryBlock.getFrom().getAlias());
+    }
+
+    private void parseSelectFieldList(ElasticDslContext dslContext, ElasticSqlSelectQueryBlock queryBlock) {
+        List<String> selectFields = Lists.newLinkedList();
+        String queryAsAlias = dslContext.getQueryAs();
+
+        if (queryBlock.getSelectList().size() == 1 && (queryBlock.getSelectList().get(0).getExpr() instanceof SQLIdentifierExpr)) {
+            SQLIdentifierExpr idfExpr = (SQLIdentifierExpr) queryBlock.getSelectList().get(0).getExpr();
+            if ("*".equalsIgnoreCase(idfExpr.getName())) {
+                return;
+            }
+        }
+
+        queryBlock.getSelectList().stream().forEach(selectFieldItem -> {
+            if (selectFieldItem.getExpr() instanceof SQLIdentifierExpr) {
+                SQLIdentifierExpr idfExpr = (SQLIdentifierExpr) selectFieldItem.getExpr();
+                selectFields.add(idfExpr.getName());
+            }
+            if (selectFieldItem.getExpr() instanceof SQLPropertyExpr) {
+                SQLPropertyExpr propertyExpr = (SQLPropertyExpr) selectFieldItem.getExpr();
+
+                if (propertyExpr.getOwner() instanceof SQLPropertyExpr) {
+                    SQLPropertyExpr ownerPropertyExpr = (SQLPropertyExpr) propertyExpr.getOwner();
+                    if (!(ownerPropertyExpr.getOwner() instanceof SQLIdentifierExpr)) {
+                        throw new ElasticSql2DslException("[syntax error] Select field ref level could <= 3");
+                    }
+                    SQLIdentifierExpr superOwnerIdfExpr = (SQLIdentifierExpr) ownerPropertyExpr.getOwner();
+                    if (StringUtils.isNotBlank(queryAsAlias) && queryAsAlias.equalsIgnoreCase(superOwnerIdfExpr.getName())) {
+                        selectFields.add(String.format("%s.%s", ownerPropertyExpr.getName(), propertyExpr.getName()));
+                    } else {
+                        throw new ElasticSql2DslException("[syntax error] Select field qualifier not support: " + superOwnerIdfExpr.getName());
+                    }
+                } else if (propertyExpr.getOwner() instanceof SQLIdentifierExpr) {
+                    SQLIdentifierExpr ownerIdfExpr = (SQLIdentifierExpr) propertyExpr.getOwner();
+                    if (StringUtils.isNotBlank(queryAsAlias) && queryAsAlias.equalsIgnoreCase(ownerIdfExpr.getName())) {
+                        selectFields.add(propertyExpr.getName());
+                    } else {
+                        selectFields.add(String.format("%s.%s", ownerIdfExpr.getName(), propertyExpr.getName()));
+                    }
+                }
+            }
+        });
+        dslContext.setQueryFieldList(selectFields);
+    }
+
+}

src/main/java/org/elasticsearch/dsl/ElasticDslContext.java

@@ -0,0 +1,135 @@
+package org.elasticsearch.dsl;
+
+import org.apache.commons.collections.CollectionUtils;
+import org.elasticsearch.ElasticMockClient;
+import org.elasticsearch.action.search.SearchRequestBuilder;
+import org.elasticsearch.index.query.BoolFilterBuilder;
+import org.elasticsearch.index.query.FilterBuilders;
+import org.elasticsearch.index.query.QueryBuilders;
+import org.elasticsearch.search.sort.SortBuilder;
+import org.elasticsearch.utils.GsonHelper;
+
+import java.util.LinkedList;
+import java.util.List;
+
+public class ElasticDslContext {
+    /*取数开始位置*/
+    private int from = 0;
+    /*取数大小*/
+    private int size = 100;
+    /*查询索引*/
+    private List<String> indices;
+    /*查询文档类*/
+    private List<String> types;
+    /*查询索引别名*/
+    private String queryAs;
+    /*SQL的where条件*/
+    private BoolFilterBuilder filterBuilder;
+    /*SQL的order by条件*/
+    private List<SortBuilder> sortBuilderList;
+    /*查询字段列表*/
+    private List<String> queryFieldList;
+
+    public void addSort(SortBuilder sortBuilder) {
+        if (sortBuilder != null) {
+            if (sortBuilderList == null) {
+                sortBuilderList = new LinkedList<SortBuilder>();
+            }
+            sortBuilderList.add(sortBuilder);
+        }
+    }
+
+    public BoolFilterBuilder boolFilter() {
+        if (filterBuilder == null) {
+            filterBuilder = FilterBuilders.boolFilter();
+        }
+        return filterBuilder;
+    }
+
+    public List<String> getQueryFieldList() {
+        return queryFieldList;
+    }
+
+    public void setQueryFieldList(List<String> queryFieldList) {
+        this.queryFieldList = queryFieldList;
+    }
+
+    public List<String> getIndices() {
+        return indices;
+    }
+
+    public void setIndices(List<String> indices) {
+        this.indices = indices;
+    }
+
+    public List<String> getTypes() {
+        return types;
+    }
+
+    public void setTypes(List<String> types) {
+        this.types = types;
+    }
+
+    public int getFrom() {
+        return from;
+    }
+
+    public void setFrom(int from) {
+        this.from = from;
+    }
+
+    public int getSize() {
+        return size;
+    }
+
+    public void setSize(int size) {
+        this.size = size;
+    }
+
+    public String getQueryAs() {
+        return queryAs;
+    }
+
+    public void setQueryAs(String queryAs) {
+        this.queryAs = queryAs;
+    }
+
+    public String toDsl() {
+        SearchRequestBuilder requestBuilder = new SearchRequestBuilder(ElasticMockClient.get());
+
+        if (size > 100) {
+            requestBuilder.setFrom(from).setSize(100);
+        } else {
+            requestBuilder.setFrom(from).setSize(size);
+        }
+
+        if (CollectionUtils.isNotEmpty(indices)) {
+            requestBuilder.setIndices(indices.toArray(new String[indices.size()]));
+        }
+
+        if (CollectionUtils.isNotEmpty(types)) {
+            requestBuilder.setTypes(types.toArray(new String[types.size()]));
+        }
+
+        if (filterBuilder != null && filterBuilder.hasClauses()) {
+            requestBuilder.setQuery(QueryBuilders.filteredQuery(null, filterBuilder));
+        } else {
+            requestBuilder.setQuery(QueryBuilders.matchAllQuery());
+        }
+
+        if (CollectionUtils.isNotEmpty(sortBuilderList)) {
+            sortBuilderList.stream().forEach(requestBuilder::addSort);
+        }
+
+        if (CollectionUtils.isNotEmpty(queryFieldList)) {
+            requestBuilder.setFetchSource(queryFieldList.toArray(new String[queryFieldList.size()]), null);
+        }
+
+        return requestBuilder.toString();
+    }
+
+    @Override
+    public String toString() {
+        return GsonHelper.gson.toJson(this) + "\n" + "[DSL]: \n" + toDsl();
+    }
+}

src/main/java/org/elasticsearch/dsl/ElasticSql2DslParser.java

@@ -0,0 +1,47 @@
+package org.elasticsearch.dsl;
+
+import com.alibaba.druid.sql.ast.SQLExpr;
+import com.alibaba.druid.sql.ast.expr.SQLQueryExpr;
+import com.alibaba.druid.sql.parser.Token;
+import org.elasticsearch.common.lang3.StringUtils;
+import org.elasticsearch.dsl.exception.ElasticSql2DslException;
+import org.elasticsearch.sql.ElasticSqlExprParser;
+
+public class ElasticSql2DslParser {
+
+    private String sql;
+
+    public ElasticSql2DslParser(String sql) {
+        if (StringUtils.isBlank(sql)) {
+            throw new IllegalArgumentException("constructor args [sql] cannot be blank!");
+        }
+        this.sql = sql;
+    }
+
+    /**
+     * 执行sql到dsl转换
+     *
+     * @return 解析后dsl上下文
+     * @throws ElasticSql2DslException 当解析出现语法错误时抛出
+     */
+    public ElasticDslContext parse() {
+        ElasticSqlExprParser elasticSqlExprParser = new ElasticSqlExprParser(sql);
+        SQLExpr sqlQueryExpr = elasticSqlExprParser.expr();
+
+        check(elasticSqlExprParser, sqlQueryExpr);
+
+        ElasticDslBuilder dslBuilder = new ElasticDslBuilder((SQLQueryExpr) sqlQueryExpr);
+        return dslBuilder.build();
+    }
+
+    private void check(ElasticSqlExprParser sqlExprParser, SQLExpr sqlQueryExpr) {
+        if (sqlExprParser.getLexer().token() != Token.EOF) {
+            throw new ElasticSql2DslException("Sql last token is not EOF");
+        }
+
+        if (!(sqlQueryExpr instanceof SQLQueryExpr)) {
+            throw new ElasticSql2DslException("Sql is not select sql");
+        }
+    }
+
+}

src/main/java/org/elasticsearch/dsl/exception/ElasticSql2DslException.java

@@ -0,0 +1,7 @@
+package org.elasticsearch.dsl.exception;
+
+public class ElasticSql2DslException extends RuntimeException {
+    public ElasticSql2DslException(String message) {
+        super(message);
+    }
+}

src/main/java/org/elasticsearch/sql/ElasticSqlExprParser.java

@@ -0,0 +1,48 @@
+package org.elasticsearch.sql;
+
+import com.alibaba.druid.sql.ast.SQLExpr;
+import com.alibaba.druid.sql.parser.Lexer;
+import com.alibaba.druid.sql.parser.SQLExprParser;
+import com.alibaba.druid.sql.parser.SQLSelectParser;
+import com.alibaba.druid.sql.parser.Token;
+
+public class ElasticSqlExprParser extends SQLExprParser {
+
+    public ElasticSqlExprParser(Lexer lexer) {
+        super(lexer);
+    }
+
+    public ElasticSqlExprParser(String sql) {
+        this(new ElasticSqlLexer(sql));
+        this.lexer.nextToken();
+    }
+
+    @Override
+    public SQLSelectParser createSelectParser() {
+        return new ElasticSqlSelectParser(this);
+    }
+
+    public ElasticSqlSelectQueryBlock.Limit parseLimit() {
+        if (lexer.token() == Token.LIMIT) {
+            lexer.nextToken();
+
+            ElasticSqlSelectQueryBlock.Limit limit = new ElasticSqlSelectQueryBlock.Limit();
+
+            SQLExpr temp = this.expr();
+            if (lexer.token() == (Token.COMMA)) {
+                limit.setOffset(temp);
+                lexer.nextToken();
+                limit.setRowCount(this.expr());
+            } else if (identifierEquals("OFFSET")) {
+                limit.setRowCount(temp);
+                lexer.nextToken();
+                limit.setOffset(this.expr());
+            } else {
+                limit.setRowCount(temp);
+            }
+            return limit;
+        }
+
+        return null;
+    }
+}

src/main/java/org/elasticsearch/sql/ElasticSqlLexer.java

@@ -0,0 +1,62 @@
+package org.elasticsearch.sql;
+
+import com.alibaba.druid.sql.parser.Keywords;
+import com.alibaba.druid.sql.parser.Lexer;
+import com.alibaba.druid.sql.parser.Token;
+
+import java.util.HashMap;
+import java.util.Map;
+
+public class ElasticSqlLexer extends Lexer {
+    public final static Keywords DEFAULT_ELASTIC_SQL_KEYWORDS;
+
+    static {
+        Map<String, Token> map = new HashMap<>();
+
+        map.put("SELECT", Token.SELECT);
+        map.put("DISTINCT", Token.DISTINCT);
+        map.put("FROM", Token.FROM);
+        map.put("WHERE", Token.WHERE);
+
+        map.put("GROUP", Token.GROUP);
+        map.put("HAVING", Token.HAVING);
+
+        map.put("AND", Token.AND);
+        map.put("AS", Token.AS);
+
+        map.put("ORDER", Token.ORDER);
+        map.put("BY", Token.BY);
+
+        map.put("ASC", Token.ASC);
+        map.put("DESC", Token.DESC);
+
+        map.put("LIMIT", Token.LIMIT);
+
+        map.put("IS", Token.IS);
+        map.put("BETWEEN", Token.BETWEEN);
+
+        map.put("IN", Token.IN);
+        map.put("EXISTS", Token.EXISTS);
+
+        map.put("LIKE", Token.LIKE);
+        map.put("NOT", Token.NOT);
+
+        map.put("NULL", Token.NULL);
+        map.put("OR", Token.OR);
+
+        map.put("XOR", Token.XOR);
+        map.put("COMMENT", Token.COMMENT);
+
+        DEFAULT_ELASTIC_SQL_KEYWORDS = new Keywords(map);
+    }
+
+    public ElasticSqlLexer(String input, boolean skipComment) {
+        super(input, skipComment);
+        super.keywods = DEFAULT_ELASTIC_SQL_KEYWORDS;
+    }
+
+    public ElasticSqlLexer(String input) {
+        this(input, false);
+    }
+
+}

src/main/java/org/elasticsearch/sql/ElasticSqlSelectParser.java

@@ -0,0 +1,59 @@
+package org.elasticsearch.sql;
+
+import com.alibaba.druid.sql.ast.SQLSetQuantifier;
+import com.alibaba.druid.sql.ast.statement.SQLSelectQuery;
+import com.alibaba.druid.sql.parser.SQLExprParser;
+import com.alibaba.druid.sql.parser.SQLSelectParser;
+import com.alibaba.druid.sql.parser.Token;
+
+public class ElasticSqlSelectParser extends SQLSelectParser {
+
+    public ElasticSqlSelectParser(SQLExprParser exprParser) {
+        super(exprParser);
+    }
+
+    public ElasticSqlSelectQueryBlock.Limit parseLimit() {
+        return ((ElasticSqlExprParser) this.exprParser).parseLimit();
+    }
+
+    @Override
+    public SQLSelectQuery query() {
+        if (lexer.token() == Token.LPAREN) {
+            lexer.nextToken();
+            SQLSelectQuery select = query();
+            accept(Token.RPAREN);
+            return queryRest(select);
+        }
+
+        accept(Token.SELECT);
+
+        if (lexer.token() == Token.COMMENT) {
+            lexer.nextToken();
+        }
+
+        ElasticSqlSelectQueryBlock queryBlock = new ElasticSqlSelectQueryBlock();
+
+        if (lexer.token() == Token.DISTINCT) {
+            queryBlock.setDistionOption(SQLSetQuantifier.DISTINCT);
+            lexer.nextToken();
+        } else if (lexer.token() == Token.UNIQUE) {
+            queryBlock.setDistionOption(SQLSetQuantifier.UNIQUE);
+            lexer.nextToken();
+        } else if (lexer.token() == Token.ALL) {
+            queryBlock.setDistionOption(SQLSetQuantifier.ALL);
+            lexer.nextToken();
+        }
+
+        parseSelectList(queryBlock);
+        parseFrom(queryBlock);
+        parseWhere(queryBlock);
+        parseGroupBy(queryBlock);
+        queryBlock.setOrderBy(this.exprParser.parseOrderBy());
+
+        if (lexer.token() == Token.LIMIT) {
+            queryBlock.setLimit(parseLimit());
+        }
+
+        return queryRest(queryBlock);
+    }
+}

src/main/java/org/elasticsearch/sql/ElasticSqlSelectQueryBlock.java

@@ -0,0 +1,62 @@
+package org.elasticsearch.sql;
+
+import com.alibaba.druid.sql.ast.SQLExpr;
+import com.alibaba.druid.sql.ast.SQLObject;
+import com.alibaba.druid.sql.ast.SQLObjectImpl;
+import com.alibaba.druid.sql.ast.statement.SQLSelectQueryBlock;
+import com.alibaba.druid.sql.visitor.SQLASTVisitor;
+
+public class ElasticSqlSelectQueryBlock extends SQLSelectQueryBlock implements SQLObject {
+    /*DSL: from to*/
+    private Limit limit;
+
+
+    public Limit getLimit() {
+        return limit;
+    }
+
+    public void setLimit(Limit limit) {
+        this.limit = limit;
+    }
+
+    public static class Limit extends SQLObjectImpl {
+        public Limit() {
+
+        }
+
+        public Limit(SQLExpr rowCount) {
+            this.setRowCount(rowCount);
+        }
+
+        private SQLExpr rowCount;
+        private SQLExpr offset;
+
+        public SQLExpr getRowCount() {
+            return rowCount;
+        }
+
+        public void setRowCount(SQLExpr rowCount) {
+            if (rowCount != null) {
+                rowCount.setParent(this);
+            }
+            this.rowCount = rowCount;
+        }
+
+        public SQLExpr getOffset() {
+            return offset;
+        }
+
+        public void setOffset(SQLExpr offset) {
+            if (offset != null) {
+                offset.setParent(this);
+            }
+            this.offset = offset;
+        }
+
+        @Override
+        protected void accept0(SQLASTVisitor visitor) {
+            throw new UnsupportedOperationException("ElasticSql un-support method : accept0(SQLASTVisitor visitor)");
+        }
+
+    }
+}

src/main/java/org/elasticsearch/utils/GsonHelper.java

@@ -0,0 +1,12 @@
+package org.elasticsearch.utils;
+
+import com.google.gson.Gson;
+import com.google.gson.GsonBuilder;
+
+public class GsonHelper {
+    private GsonHelper() {
+
+    }
+
+    public static final Gson gson = new GsonBuilder().create();
+}

src/main/java/org/elasticsearch/utils/StringUtils.java

@@ -0,0 +1,20 @@
+package org.elasticsearch.utils;
+
+public class StringUtils {
+    public static boolean isBlank(String src) {
+        if (src == null) {
+            return true;
+        }
+        int len = src.length();
+        for (int idx = 0; idx < len; idx++) {
+            if (' ' != src.charAt(idx)) {
+                return false;
+            }
+        }
+        return true;
+    }
+
+    public static boolean isNotBlank(String src) {
+        return !isBlank(src);
+    }
+}

src/test/java/org/elasticsearch/SqlParserTest.java

@@ -0,0 +1,59 @@
+package org.elasticsearch;
+
+import junit.framework.TestCase;
+import org.apache.commons.collections.CollectionUtils;
+import org.elasticsearch.dsl.ElasticDslContext;
+import org.elasticsearch.dsl.ElasticSql2DslParser;
+import org.junit.Assert;
+
+
+public class SqlParserTest extends TestCase {
+
+    public void testParseSelectFieldWithQueryAs() {
+        String sql = "select b.id,bookCategory,b.bookStatus,clazz.sortNo,b.clazz.cid from book b where 1 = 1";
+        ElasticSql2DslParser sql2DslParser = new ElasticSql2DslParser(sql);
+        ElasticDslContext dslContext = sql2DslParser.parse();
+
+        System.out.println(dslContext.toString());
+        Assert.assertEquals(dslContext.getQueryFieldList().get(0), "id");
+        Assert.assertEquals(dslContext.getQueryFieldList().get(1), "bookCategory");
+        Assert.assertEquals(dslContext.getQueryFieldList().get(2), "bookStatus");
+        Assert.assertEquals(dslContext.getQueryFieldList().get(3), "clazz.sortNo");
+        Assert.assertEquals(dslContext.getQueryFieldList().get(4), "clazz.cid");
+    }
+
+    public void testParseSelectFieldWithoutQueryAs() {
+        String sql = "select b.id,bookCategory,b.bookStatus,clazz.sortNo,clazz.cid from book where 1 = 1";
+        ElasticSql2DslParser sql2DslParser = new ElasticSql2DslParser(sql);
+        ElasticDslContext dslContext = sql2DslParser.parse();
+
+        System.out.println(dslContext.toString());
+        Assert.assertEquals(dslContext.getQueryFieldList().get(0), "b.id");
+        Assert.assertEquals(dslContext.getQueryFieldList().get(1), "bookCategory");
+        Assert.assertEquals(dslContext.getQueryFieldList().get(2), "b.bookStatus");
+        Assert.assertEquals(dslContext.getQueryFieldList().get(3), "clazz.sortNo");
+        Assert.assertEquals(dslContext.getQueryFieldList().get(4), "clazz.cid");
+    }
+
+    public void testParseSelectFieldMatchAll() {
+        String sql = "select * from book where 1 = 1";
+        ElasticSql2DslParser sql2DslParser = new ElasticSql2DslParser(sql);
+        ElasticDslContext dslContext = sql2DslParser.parse();
+
+        System.out.println(dslContext.toString());
+        Assert.assertTrue(CollectionUtils.isEmpty(dslContext.getQueryFieldList()));
+    }
+
+    public void testParseFilterCondition() {
+        //String sql = "select * from book b where 1 = 1 and b.status='ONLINE'"; //SQLBinaryOpExpr
+        //String sql = "select * from book b where price+1 < 2"; //SQLBinaryOpExpr
+        //String sql = "select * from book b where c in (1,2,3)";    //SQLInListExpr
+        //String sql = "select * from book b where c not in (1,2,3)"; //SQLInListExpr
+        String sql = "select * from book b where c between 1 and 3"; //SQLBetweenExpr
+
+        ElasticSql2DslParser sql2DslParser = new ElasticSql2DslParser(sql);
+        ElasticDslContext dslContext = sql2DslParser.parse();
+
+        System.out.println(dslContext.toString());
+    }
+}