Skip to content

Commit 4a42b88

Browse files
justinsbjustinsb
committed
Trying out using the presto parser for SQL
1 parent 2d7bcb2 commit 4a42b88

39 files changed

Lines changed: 3111 additions & 0 deletions

‎cloudata-structured/pom.xml‎

Lines changed: 12 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -13,6 +13,18 @@
1313

1414

1515
<dependencies>
16+
<dependency>
17+
<groupId>com.facebook.presto</groupId>
18+
<artifactId>presto-parser</artifactId>
19+
<version>0.55-SNAPSHOT</version>
20+
</dependency>
21+
22+
<dependency>
23+
<groupId>com.facebook.presto</groupId>
24+
<artifactId>presto-main</artifactId>
25+
<version>0.55-SNAPSHOT</version>
26+
</dependency>
27+
1628
<dependency>
1729
<groupId>com.cloudata</groupId>
1830
<artifactId>cloudata-server-shared</artifactId>

‎cloudata-structured/src/main/java/com/cloudata/structured/sql/SqlEngine.java‎

Lines changed: 70 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,70 @@
1+
package com.cloudata.structured.sql;
2+
3+
import java.util.List;
4+
5+
import org.slf4j.Logger;
6+
import org.slf4j.LoggerFactory;
7+
8+
import com.facebook.presto.importer.PeriodicImportManager;
9+
import com.facebook.presto.metadata.MetadataManager;
10+
import com.facebook.presto.sql.analyzer.Analysis;
11+
import com.facebook.presto.sql.analyzer.Analyzer;
12+
import com.facebook.presto.sql.analyzer.QueryExplainer;
13+
import com.facebook.presto.sql.parser.SqlParser;
14+
import com.facebook.presto.sql.planner.LogicalPlanner;
15+
import com.facebook.presto.sql.planner.Plan;
16+
import com.facebook.presto.sql.planner.PlanNodeIdAllocator;
17+
import com.facebook.presto.sql.planner.optimizations.PlanOptimizer;
18+
import com.facebook.presto.sql.tree.Statement;
19+
import com.facebook.presto.storage.StorageManager;
20+
import com.google.common.base.Optional;
21+
22+
public class SqlEngine {
23+
private static final Logger log = LoggerFactory.getLogger(SqlEngine.class);
24+
25+
final MetadataManager metadata;
26+
final List<PlanOptimizer> planOptimizers;
27+
final PeriodicImportManager periodicImportManager;
28+
final StorageManager storageManager;
29+
30+
// SplitManager splitManager = buildSplitManager();
31+
32+
public SqlEngine(MetadataManager metadata, List<PlanOptimizer> planOptimizers,
33+
PeriodicImportManager periodicImportManager, StorageManager storageManager) {
34+
this.metadata = metadata;
35+
this.planOptimizers = planOptimizers;
36+
this.periodicImportManager = periodicImportManager;
37+
this.storageManager = storageManager;
38+
}
39+
40+
public SqlStatement parse(SqlSession session, String sql) {
41+
log.debug("Parsing sql: {}", sql);
42+
43+
Statement statement = SqlParser.createStatement(sql);
44+
45+
QueryExplainer queryExplainer = new QueryExplainer(session.prestoSession, planOptimizers, metadata,
46+
periodicImportManager, storageManager);
47+
// analyze query
48+
Analyzer analyzer = new Analyzer(session.prestoSession, metadata, Optional.of(queryExplainer));
49+
50+
Analysis analysis = analyzer.analyze(statement);
51+
52+
// System.out.println("analysis: " + analysis);
53+
54+
PlanNodeIdAllocator idAllocator = new PlanNodeIdAllocator();
55+
// plan query
56+
LogicalPlanner logicalPlanner = new LogicalPlanner(session.prestoSession, planOptimizers, idAllocator,
57+
metadata, periodicImportManager, storageManager);
58+
Plan plan = logicalPlanner.plan(analysis);
59+
60+
return new SqlStatement(metadata, sql, plan);
61+
//
62+
// TableScanCountVisitor visitor = new TableScanCountVisitor();
63+
// plan.getRoot().accept(visitor, 0);
64+
// Assert.assertEquals(1, visitor.count);
65+
// String p = PlanPrinter.textLogicalPlan(plan.getRoot(), plan.getTypes());
66+
//
67+
// System.out.println("plan: " + p);
68+
}
69+
70+
}

‎cloudata-structured/src/main/java/com/cloudata/structured/sql/SqlSession.java‎

Lines changed: 18 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,18 @@
1+
package com.cloudata.structured.sql;
2+
3+
import com.facebook.presto.sql.analyzer.Session;
4+
5+
public class SqlSession {
6+
7+
final Session prestoSession;
8+
9+
public SqlSession() {
10+
String user = "user";
11+
String source = "source";
12+
String catalog = "default";
13+
String schema = "default";
14+
String remoteUserAddress = "remoteUserAddress";
15+
String userAgent = "userAgent";
16+
this.prestoSession = new Session(user, source, catalog, schema, remoteUserAddress, userAgent);
17+
}
18+
}

‎cloudata-structured/src/main/java/com/cloudata/structured/sql/SqlStatement.java‎

Lines changed: 116 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,116 @@
1+
package com.cloudata.structured.sql;
2+
3+
import com.cloudata.structured.sql.simple.ConvertToSimplePlanVisitor;
4+
import com.cloudata.structured.sql.simple.SimpleNode;
5+
import com.facebook.presto.metadata.Metadata;
6+
import com.facebook.presto.sql.planner.Plan;
7+
import com.google.common.base.Optional;
8+
9+
public class SqlStatement {
10+
11+
private final String sql;
12+
private final Plan plan;
13+
14+
Optional<SimpleNode> simple;
15+
private final Metadata metadata;
16+
17+
public SqlStatement(Metadata metadata, String sql, Plan plan) {
18+
this.metadata = metadata;
19+
this.sql = sql;
20+
this.plan = plan;
21+
}
22+
23+
public boolean isSimple() {
24+
return getSimple() != null;
25+
}
26+
27+
public SimpleNode getSimple() {
28+
if (simple == null) {
29+
ConvertToSimplePlanVisitor visitor = new ConvertToSimplePlanVisitor(metadata);
30+
SimpleNode accept = plan.getRoot().accept(visitor, null);
31+
// plan.getRoot().accept(visitor, 0);
32+
simple = Optional.fromNullable(accept);
33+
}
34+
return simple.orNull();
35+
}
36+
37+
// class SimplePlan {
38+
// final Table table;
39+
//
40+
// final Expression[] expressions;
41+
//
42+
// public void evaluate() {
43+
// // Statement: Query{queryBody=QuerySpecification{select=Select{distinct=false, selectItems=["key1" k1,
44+
// // concat("key2", 'hello') k2]}, from=[Table{table1}], where=null, groupBy=[], having=null, orderBy=[],
45+
// // limit=null}, orderBy=[]}
46+
// // analysis: com.facebook.presto.sql.analyzer.Analysis@39f46204
47+
// // plan: - Output[k1, k2]
48+
// // k1 := key1
49+
// // k2 := concat
50+
// // - Project => [key1:varchar, concat:varchar]
51+
// // concat := concat("key2", 'hello')
52+
// // - TableScan[com.cloudata.structured.sql.MockTableHandle@737c45ee, domain={}] => [key1:varchar,
53+
// // key2:varchar]
54+
// // key1 := com.cloudata.structured.sql.MockColumnHandle@549448df
55+
// // key2 := com.cloudata.structured.sql.MockColumnHandle@533c53da
56+
//
57+
// // ExpressionInterpreter.expressionInterpreter(expression, metadata, session)
58+
//
59+
// }
60+
// }
61+
//
62+
// private boolean isSimple(Plan plan) {
63+
//
64+
// // TODO: Make this better, once we have a better grip on the logic
65+
// PlanNode root = plan.getRoot();
66+
// if (root instanceof OutputNode) {
67+
// OutputNode outputNode = (OutputNode) root;
68+
// PlanNode source = outputNode.getSource();
69+
// if (source instanceof TableScanNode) {
70+
// TableScanNode tableScanNode = (TableScanNode) source;
71+
//
72+
// List<String> columns = Lists.newArrayList();
73+
// // List<String> columns = Lists.newArrayList();
74+
//
75+
// for (int i = 0; i < outputNode.getColumnNames().size(); i++) {
76+
// String name = outputNode.getColumnNames().get(i);
77+
// Symbol symbol = outputNode.getOutputSymbols().get(i);
78+
//
79+
// }
80+
//
81+
// // Statement: Query{queryBody=QuerySpecification{select=Select{distinct=false, selectItems=["key1" k1,
82+
// // "key2" k2]}, from=[Table{table1}], where=null, groupBy=[], having=null, orderBy=[], limit=null},
83+
// // orderBy=[]}
84+
// // analysis: com.facebook.presto.sql.analyzer.Analysis@6fcc5b5d
85+
// // plan: - Output[k1, k2]
86+
// // k1 := key1
87+
// // k2 := key2
88+
// // - TableScan[com.cloudata.structured.sql.MockTableHandle@3aa92b03, domain={}] => [key1:varchar,
89+
// // key2:varchar]
90+
// // key1 := com.cloudata.structured.sql.MockColumnHandle@20bb82ca
91+
// // key2 := com.cloudata.structured.sql.MockColumnHandle@7687ac8f
92+
//
93+
// SimpleQuery query = new SimpleQuery();
94+
// return true;
95+
// }
96+
// }
97+
// return false;
98+
// }
99+
100+
// class CheckSimpleVisitor extends RecursivePlanVisitor<Integer, Boolean> {
101+
// boolean simple = true;
102+
//
103+
// @Override
104+
// public Boolean visitOutput(OutputNode node, Integer context) {
105+
// simple = false;
106+
// return false;
107+
// }
108+
//
109+
// @Override
110+
// protected Boolean visitPlan(PlanNode node, Integer context) {
111+
// if (vi)
112+
// }
113+
//
114+
// }
115+
116+
}

‎cloudata-structured/src/main/java/com/cloudata/structured/sql/provider/CloudataColumnHandle.java‎

Lines changed: 18 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,18 @@
1+
package com.cloudata.structured.sql.provider;
2+
3+
import com.facebook.presto.spi.ColumnHandle;
4+
import com.facebook.presto.spi.ColumnMetadata;
5+
6+
public class CloudataColumnHandle implements ColumnHandle {
7+
8+
private final ColumnMetadata columnMetadata;
9+
10+
public CloudataColumnHandle(CloudataTableHandle tableHandle, ColumnMetadata columnMetadata) {
11+
this.columnMetadata = columnMetadata;
12+
}
13+
14+
public ColumnMetadata getColumnMetadata() {
15+
return columnMetadata;
16+
}
17+
18+
}

‎cloudata-structured/src/main/java/com/cloudata/structured/sql/provider/CloudataConnectorMetadata.java‎

Lines changed: 145 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,145 @@
1+
package com.cloudata.structured.sql.provider;
2+
3+
import java.util.List;
4+
import java.util.Map;
5+
6+
import com.facebook.presto.spi.ColumnHandle;
7+
import com.facebook.presto.spi.ColumnMetadata;
8+
import com.facebook.presto.spi.ConnectorMetadata;
9+
import com.facebook.presto.spi.ConnectorTableMetadata;
10+
import com.facebook.presto.spi.SchemaTableName;
11+
import com.facebook.presto.spi.SchemaTablePrefix;
12+
import com.facebook.presto.spi.TableHandle;
13+
import com.google.common.collect.Lists;
14+
15+
public class CloudataConnectorMetadata implements ConnectorMetadata {
16+
17+
final String connectorId;
18+
19+
public CloudataConnectorMetadata(String connectorId) {
20+
this.connectorId = connectorId;
21+
}
22+
23+
@Override
24+
public boolean canHandle(TableHandle tableHandle) {
25+
return tableHandle instanceof CloudataTableHandle
26+
&& ((CloudataTableHandle) tableHandle).getConnectorId().equals(connectorId);
27+
}
28+
29+
@Override
30+
public List<String> listSchemaNames() {
31+
List<String> schemas = Lists.newArrayList();
32+
schemas.add("default");
33+
return schemas;
34+
}
35+
36+
@Override
37+
public CloudataTableHandle getTableHandle(SchemaTableName tableName) {
38+
if (!listSchemaNames().contains(tableName.getSchemaName())) {
39+
return null;
40+
}
41+
42+
// ExampleTable table = exampleClient.getTable(tableName.getSchemaName(), tableName.getTableName());
43+
// if (table == null) {
44+
// return null;
45+
// }
46+
47+
return new CloudataTableHandle(connectorId, tableName.getSchemaName(), tableName.getTableName());
48+
}
49+
50+
@Override
51+
public ConnectorTableMetadata getTableMetadata(TableHandle table) {
52+
CloudataTableHandle tableHandle = promote(table);
53+
return tableHandle.getTableMetadata();
54+
}
55+
56+
private CloudataTableHandle promote(TableHandle table) {
57+
assert (table != null);
58+
// checkArgument(table instanceof CloudataTableHandle, "tableHandle is not an instance of CloudataTableHandle");
59+
assert (table instanceof CloudataTableHandle);
60+
CloudataTableHandle tableHandle = (CloudataTableHandle) table;
61+
assert tableHandle.getConnectorId().equals(connectorId);
62+
// checkArgument(tableHandle.getConnectorId().equals(connectorId), "tableHandle is not for this connector");
63+
return tableHandle;
64+
}
65+
66+
@Override
67+
public List<SchemaTableName> listTables(String schemaNameOrNull) {
68+
throw new UnsupportedOperationException();
69+
}
70+
71+
@Override
72+
public ColumnHandle getColumnHandle(TableHandle tableHandle, String columnName) {
73+
CloudataTableHandle exampleTableHandle = promote(tableHandle);
74+
75+
// ExampleTable table = exampleClient.getTable(exampleTableHandle.getSchemaName(),
76+
// exampleTableHandle.getTableName());
77+
// if (table == null) {
78+
// throw new TableNotFoundException(exampleTableHandle.toSchemaTableName());
79+
// }
80+
81+
// ImmutableMap.Builder<String, ColumnHandle> columnHandles = ImmutableMap.builder();
82+
// for (ColumnMetadata columnMetadata : table.getColumnsMetadata()) {
83+
// columnHandles.put(columnMetadata.getName(), new ExampleColumnHandle(connectorId, columnMetadata));
84+
// }
85+
// return columnHandles.build();
86+
87+
return exampleTableHandle.getColumnHandle(columnName);
88+
}
89+
90+
@Override
91+
public Map<String, ColumnHandle> getColumnHandles(TableHandle tableHandle) {
92+
CloudataTableHandle exampleTableHandle = promote(tableHandle);
93+
94+
// ExampleTable table = exampleClient.getTable(exampleTableHandle.getSchemaName(),
95+
// exampleTableHandle.getTableName());
96+
// if (table == null) {
97+
// throw new TableNotFoundException(exampleTableHandle.toSchemaTableName());
98+
// }
99+
100+
// ImmutableMap.Builder<String, ColumnHandle> columnHandles = ImmutableMap.builder();
101+
// for (ColumnMetadata columnMetadata : table.getColumnsMetadata()) {
102+
// columnHandles.put(columnMetadata.getName(), new ExampleColumnHandle(connectorId, columnMetadata));
103+
// }
104+
// return columnHandles.build();
105+
106+
return exampleTableHandle.getColumnHandles();
107+
}
108+
109+
@Override
110+
public ColumnMetadata getColumnMetadata(TableHandle tableHandle, ColumnHandle column) {
111+
// checkNotNull(tableHandle, "tableHandle is null");
112+
// checkArgument(tableHandle instanceof MockTableHandle, "tableHandle is not an instance of MockTableHandle");
113+
// checkArgument(((MockTableHandle) tableHandle).getConnectorId().equals(connectorId),
114+
// "tableHandle is not for this connector");
115+
116+
CloudataColumnHandle columnHandle = promote(column);
117+
118+
return columnHandle.getColumnMetadata();
119+
}
120+
121+
private CloudataColumnHandle promote(ColumnHandle column) {
122+
// checkNotNull(columnHandle, "columnHandle is null");
123+
assert column != null;
124+
// checkArgument(columnHandle instanceof CloudataColumnHandle,
125+
// "columnHandle is not an instance of CloudataColumnHandle");
126+
assert column instanceof CloudataColumnHandle;
127+
return (CloudataColumnHandle) column;
128+
}
129+
130+
@Override
131+
public Map<SchemaTableName, List<ColumnMetadata>> listTableColumns(SchemaTablePrefix prefix) {
132+
throw new UnsupportedOperationException();
133+
}
134+
135+
@Override
136+
public TableHandle createTable(ConnectorTableMetadata tableMetadata) {
137+
throw new UnsupportedOperationException();
138+
}
139+
140+
@Override
141+
public void dropTable(TableHandle tableHandle) {
142+
throw new UnsupportedOperationException();
143+
}
144+
145+
}

0 commit comments

Comments
 (0)