public void prepare() throws DatabaseException {
type = (String) cmd.getObject("type");
view_name = (String) cmd.getObject("view_name");
String schema_name = database.getCurrentSchema();
vname = TableName.resolve(schema_name, view_name);
vname = database.tryResolveCase(vname);
if (type.equals("create")) {
// Get the select expression
select_expression = (TableSelectExpression) cmd.getObject("select_expression");
// Get the column name list
ArrayList col_list = (ArrayList) cmd.getObject("column_list");
// Generate the TableExpressionFromSet hierarchy for the expression,
TableExpressionFromSet from_set = Planner.generateFromSet(select_expression, database);
// Form the plan
plan = Planner.formQueryPlan(database, select_expression, from_set, new ArrayList());
// Wrap the result around a SubsetNode to alias the columns in the
// table correctly for this view.
int sz = (col_list == null) ? 0 : col_list.size();
Variable[] original_vars = from_set.generateResolvedVariableList();
Variable[] new_column_vars = new Variable[original_vars.length];
if (sz > 0) {
if (sz != original_vars.length) {
throw new StatementException("Column list is not the same size as the columns selected.");
}
for (int i = 0; i < sz; ++i) {
String col_name = (String) col_list.get(i);
new_column_vars[i] = new Variable(vname, col_name);
}
} else {
sz = original_vars.length;
for (int i = 0; i < sz; ++i) {
new_column_vars[i] = new Variable(vname, original_vars[i].getName());
}
}
// Check there are no repeat column names in the table.
for (int i = 0; i < sz; ++i) {
Variable cur_v = new_column_vars[i];
for (int n = i + 1; n < sz; ++n) {
if (new_column_vars[n].equals(cur_v)) {
throw new DatabaseException(
"Duplicate column name '"
+ cur_v
+ "' in view. "
+ "A view may not contain duplicate column names.");
}
}
}
// Wrap the plan around a SubsetNode plan
plan = new QueryPlan.SubsetNode(plan, original_vars, new_column_vars);
}
}
@Test
public void testParseFails() throws SqlParseException {
Planner planner = getPlanner();
try {
SqlNode parse = planner.parse("select * * from \"emps\"");
fail("expected error, got " + parse);
} catch (SqlParseException e) {
assertThat(e.getMessage(), containsString("Encountered \"*\" at line 1, column 10."));
}
}
public void testFirstTrip() throws Exception {
Planner planner = new TestPlanner("portland", "45.58,-122.68", "45.48,-122.6");
Response response = planner.getFirstTrip();
Itinerary itinerary = response.getPlan().itinerary.get(0);
Leg leg = itinerary.legs.get(1);
assertTrue(leg.startTime.get(Calendar.HOUR) >= 4);
assertTrue(leg.startTime.get(Calendar.HOUR) <= 7);
}
/** Tests that Hive dialect does not generate "AS". */
@Test
public void testHiveDialect() throws SqlParseException {
Planner planner = getPlanner();
SqlNode parse =
planner.parse(
"select * from (select * from \"emps\") as t\n" + "where \"name\" like '%e%'");
final SqlDialect hiveDialect = new SqlDialect(SqlDialect.DatabaseProduct.HIVE, "Hive", null);
assertThat(
parse.toSqlString(hiveDialect).getSql(),
equalTo("SELECT *\n" + "FROM (SELECT *\n" + "FROM emps) T\n" + "WHERE name LIKE '%e%'"));
}
/**
* Tests that planner throws an error if you pass to {@link
* Planner#convert(org.eigenbase.sql.SqlNode)} a {@link org.eigenbase.sql.SqlNode} that has been
* parsed but not validated.
*/
@Test
public void testConvertWithoutValidateFails() throws Exception {
Planner planner = getPlanner();
SqlNode parse = planner.parse("select * from \"emps\"");
try {
RelNode rel = planner.convert(parse);
fail("expected error, got " + rel);
} catch (IllegalArgumentException e) {
assertThat(
e.getMessage(), containsString("cannot move from STATE_3_PARSED to STATE_4_VALIDATED"));
}
}
@Override
public void manage() {
updateExplorationMap();
List<Planner> planners = new ArrayList<>();
planners.add(new ColonyPlanner(world, controls));
planners.add(new ResearchPlanner(world, controls, exploration));
planners.add(new ColonizationPlanner(world, controls));
planners.add(
new ExplorationPlanner(
world,
controls,
exploration,
new Action1<Date>() {
@Override
public void invoke(Date value) {
lastSatelliteDeploy = value;
}
}));
int mix1 = planners.size();
planners.add(new EconomyPlanner(world, controls));
planners.add(new OffensePlanner(world, controls));
planners.add(new StaticDefensePlanner(world, controls));
int mix2 = planners.size();
planners.add(
new AttackPlanner(
world,
controls,
exploration,
new Action1<Date>() {
@Override
public void invoke(Date value) {
nextAttack = value;
}
}));
ModelUtils.shuffle(planners.subList(mix1, mix2));
for (Planner p : planners) {
List<Action0> acts = p.run();
if (!acts.isEmpty()) {
applyActions.addAll(acts);
if (p.getClass() == ColonyPlanner.class) {
return;
}
}
}
}
@Test
public void testValidateFails() throws SqlParseException {
Planner planner = getPlanner();
SqlNode parse = planner.parse("select * from \"emps\" where \"Xname\" like '%e%'");
assertThat(
parse.toString(), equalTo("SELECT *\n" + "FROM `emps`\n" + "WHERE `Xname` LIKE '%e%'"));
try {
SqlNode validate = planner.validate(parse);
fail("expected error, got " + validate);
} catch (ValidationException e) {
assertThat(Util.getStackTrace(e), containsString("Column 'Xname' not found in any table"));
// ok
}
}
@Test
public void testParseAndConvert() throws Exception {
Planner planner = getPlanner();
SqlNode parse = planner.parse("select * from \"emps\" where \"name\" like '%e%'");
assertThat(
parse.toString(), equalTo("SELECT *\n" + "FROM `emps`\n" + "WHERE `name` LIKE '%e%'"));
SqlNode validate = planner.validate(parse);
RelNode rel = planner.convert(validate);
assertThat(
toString(rel),
equalTo(
"ProjectRel(empid=[$0], deptno=[$1], name=[$2], salary=[$3], commission=[$4])\n"
+ " FilterRel(condition=[LIKE($2, '%e%')])\n"
+ " EnumerableTableAccessRel(table=[[hr, emps]])\n"));
}
public void mouseClicked(MouseEvent e) {
Point p = e.getPoint();
MainLoop loop = planner.getMapPanel().getLoop();
final RoadDirection dir;
if (fullRect.contains(p)) {
dir = RoadDirection.CENTER;
} else if (nw.contains(p)) {
dir = RoadDirection.NW;
} else if (ne.contains(p)) {
dir = RoadDirection.NE;
} else if (sw.contains(p)) {
dir = RoadDirection.SW;
} else if (se.contains(p)) {
dir = RoadDirection.SE;
} else {
dir = null;
}
if (dir != null) {
loop.syncAndExecute(
() -> {
Globals.roadDirection = dir;
repaint();
});
}
}
public void testPlanner() throws Exception {
Planner planner =
new TestPlanner("portland", "NE 43RD AVE at NE GLISAN ST", "NE 43RD AVE at NE ROYAL CT");
Response response = planner.getItineraries();
Itinerary itinerary = response.getPlan().itinerary.get(0);
Leg leg = itinerary.legs.get(0);
List<WalkStep> steps = leg.walkSteps;
assertEquals(3, steps.size());
WalkStep step0 = steps.get(0);
WalkStep step2 = steps.get(2);
assertEquals(AbsoluteDirection.NORTH, step0.absoluteDirection);
assertEquals("NE 43RD AVE", step0.streetName);
assertEquals("NE 43RD AVE", step2.streetName);
assertEquals(RelativeDirection.LEFT, step2.relativeDirection);
assertTrue(step2.stayOn);
}
public void testAlerts() throws Exception {
// SE 47th and Ash, NE 47th and Davis (note that we cross Burnside, this goes from SE to NE)
Planner planner =
new TestPlanner("portland", "SE 47TH AVE at SE ASH ST", "NE 47TH AVE at NE COUCH ST");
Response response = planner.getItineraries();
Itinerary itinerary = response.getPlan().itinerary.get(0);
Leg leg = itinerary.legs.get(0);
List<WalkStep> steps = leg.walkSteps;
assertEquals(2, steps.size());
WalkStep step0 = steps.get(0);
WalkStep step1 = steps.get(1);
assertNotNull(step0.alerts);
assertEquals(1, step0.alerts.size());
assertEquals("SE", step0.alerts.get(0).alertHeaderText.getSomeTranslation());
assertEquals(1, step1.alerts.size());
assertEquals("NE", step1.alerts.get(0).alertHeaderText.getSomeTranslation());
}
/** Unit test that parses, validates, converts and plans. */
@Test
public void testPlan() throws Exception {
RuleSet ruleSet =
RuleSets.ofList(
MergeFilterRule.INSTANCE,
JavaRules.ENUMERABLE_FILTER_RULE,
JavaRules.ENUMERABLE_PROJECT_RULE);
Planner planner = getPlanner(ruleSet);
SqlNode parse = planner.parse("select * from \"emps\"");
SqlNode validate = planner.validate(parse);
RelNode convert = planner.convert(validate);
RelTraitSet traitSet = planner.getEmptyTraitSet().replace(EnumerableConvention.INSTANCE);
RelNode transform = planner.transform(0, traitSet, convert);
assertThat(
toString(transform),
equalTo(
"EnumerableProjectRel(empid=[$0], deptno=[$1], name=[$2], salary=[$3], commission=[$4])\n"
+ " EnumerableTableAccessRel(table=[[hr, emps]])\n"));
}
