org.apache.flink.table.client.cli.SqlCommandParser.SqlCommandCall Java Examples

/**
 * Submits a SQL update statement and prints status information and/or errors on the terminal.
 *
 * @param statement SQL update statement
 * @return flag to indicate if the submission was successful or not
 */
public boolean submitUpdate(String statement) {
	terminal.writer().println(CliStrings.messageInfo(CliStrings.MESSAGE_WILL_EXECUTE).toAnsi());
	terminal.writer().println(new AttributedString(statement).toString());
	terminal.flush();

	final Optional<SqlCommandCall> parsedStatement = parseCommand(statement);
	// only support INSERT INTO
	return parsedStatement.map(cmdCall -> {
		switch (cmdCall.command) {
			case INSERT_INTO:
				return callInsertInto(cmdCall);
			default:
				printError(CliStrings.MESSAGE_UNSUPPORTED_SQL);
				return false;
		}
	}).orElse(false);
}
 

private void runTestItem(TestItem item) {
	Tuple2<Boolean, SqlCommandCall> checkFlagAndActualCall = parseSqlAndCheckException(item);
	if (!checkFlagAndActualCall.f0) {
		return;
	}
	SqlCommandCall actualCall = checkFlagAndActualCall.f1;
	assertNotNull(item.expectedCmd);
	assertEquals("test statement: " + item.sql,
			new SqlCommandCall(item.expectedCmd, item.expectedOperands), actualCall);

	String stmtWithComment = "-- comments \n " + item.sql;
	try {
		actualCall = SqlCommandParser.parse(parser, stmtWithComment);
	} catch (SqlExecutionException e) {
		if (!item.cannotParseComment) {
			fail("test statement: " + item.sql);
		}
		return;
	}
	assertEquals(item.expectedCmd, actualCall.command);
}
 

private void callCreateView(SqlCommandCall cmdCall) {
	final String name = cmdCall.operands[0];
	final String query = cmdCall.operands[1];

	final ViewEntry previousView = context.getViews().get(name);
	if (previousView != null) {
		printExecutionError(CliStrings.MESSAGE_VIEW_ALREADY_EXISTS);
		return;
	}

	try {
		// perform and validate change
		context.addView(ViewEntry.create(name, query));
		executor.validateSession(context);
		printInfo(CliStrings.MESSAGE_VIEW_CREATED);
	} catch (SqlExecutionException e) {
		// rollback change
		context.removeView(name);
		printExecutionException(e);
	}
}
 

private void callDropView(SqlCommandCall cmdCall) {
	final String name = cmdCall.operands[0];
	final ViewEntry view = context.getViews().get(name);

	if (view == null) {
		printExecutionError(CliStrings.MESSAGE_VIEW_NOT_FOUND);
		return;
	}

	try {
		// perform and validate change
		context.removeView(name);
		executor.validateSession(context);
		printInfo(CliStrings.MESSAGE_VIEW_REMOVED);
	} catch (SqlExecutionException e) {
		// rollback change
		context.addView(view);
		printExecutionException(CliStrings.MESSAGE_VIEW_NOT_REMOVED, e);
	}
}
 

private void callCreateView(SqlCommandCall cmdCall) {
	final String name = cmdCall.operands[0];
	final String query = cmdCall.operands[1];

	final ViewEntry previousView = context.getViews().get(name);
	if (previousView != null) {
		printExecutionError(CliStrings.MESSAGE_VIEW_ALREADY_EXISTS);
		return;
	}

	try {
		// perform and validate change
		context.addView(ViewEntry.create(name, query));
		executor.validateSession(context);
		printInfo(CliStrings.MESSAGE_VIEW_CREATED);
	} catch (SqlExecutionException e) {
		// rollback change
		context.removeView(name);
		printExecutionException(e);
	}
}
 

private void callDropView(SqlCommandCall cmdCall) {
	final String name = cmdCall.operands[0];
	final ViewEntry view = context.getViews().get(name);

	if (view == null) {
		printExecutionError(CliStrings.MESSAGE_VIEW_NOT_FOUND);
		return;
	}

	try {
		// perform and validate change
		context.removeView(name);
		executor.validateSession(context);
		printInfo(CliStrings.MESSAGE_VIEW_REMOVED);
	} catch (SqlExecutionException e) {
		// rollback change
		context.addView(view);
		printExecutionException(CliStrings.MESSAGE_VIEW_NOT_REMOVED, e);
	}
}
 

/**
 * Submits a SQL update statement and prints status information and/or errors on the terminal.
 *
 * @param statement SQL update statement
 * @return flag to indicate if the submission was successful or not
 */
public boolean submitUpdate(String statement) {
	terminal.writer().println(CliStrings.messageInfo(CliStrings.MESSAGE_WILL_EXECUTE).toAnsi());
	terminal.writer().println(new AttributedString(statement).toString());
	terminal.flush();

	final Optional<SqlCommandCall> parsedStatement = parseCommand(statement);
	// only support INSERT INTO
	return parsedStatement.map(cmdCall -> {
		switch (cmdCall.command) {
			case INSERT_INTO:
				return callInsertInto(cmdCall);
			default:
				printError(CliStrings.MESSAGE_UNSUPPORTED_SQL);
				return false;
		}
	}).orElse(false);
}
 

/**
 * Submits a SQL update statement and prints status information and/or errors on the terminal.
 *
 * @param statement SQL update statement
 * @return flag to indicate if the submission was successful or not
 */
public boolean submitUpdate(String statement) {
	terminal.writer().println(CliStrings.messageInfo(CliStrings.MESSAGE_WILL_EXECUTE).toAnsi());
	terminal.writer().println(new AttributedString(statement).toString());
	terminal.flush();

	final Optional<SqlCommandCall> parsedStatement = parseCommand(statement);
	// only support INSERT INTO/OVERWRITE
	return parsedStatement.map(cmdCall -> {
		switch (cmdCall.command) {
			case INSERT_INTO:
			case INSERT_OVERWRITE:
				return callInsert(cmdCall);
			default:
				printError(CliStrings.MESSAGE_UNSUPPORTED_SQL);
				return false;
		}
	}).orElse(false);
}
 

private void callUseCatalog(SqlCommandCall cmdCall) {
	try {
		executor.useCatalog(sessionId, cmdCall.operands[0]);
	} catch (SqlExecutionException e) {
		printExecutionException(e);
		return;
	}
	terminal.flush();
}
 

private boolean callInsertInto(SqlCommandCall cmdCall) {
	printInfo(CliStrings.MESSAGE_SUBMITTING_STATEMENT);

	try {
		final ProgramTargetDescriptor programTarget = executor.executeUpdate(context, cmdCall.operands[0]);
		terminal.writer().println(CliStrings.messageInfo(CliStrings.MESSAGE_STATEMENT_SUBMITTED).toAnsi());
		terminal.writer().println(programTarget.toString());
		terminal.flush();
	} catch (SqlExecutionException e) {
		printExecutionException(e);
		return false;
	}
	return true;
}
 

private void callSource(SqlCommandCall cmdCall) {
	final String pathString = cmdCall.operands[0];

	// load file
	final String stmt;
	try {
		final Path path = Paths.get(pathString);
		byte[] encoded = Files.readAllBytes(path);
		stmt = new String(encoded, Charset.defaultCharset());
	} catch (IOException e) {
		printExecutionException(e);
		return;
	}

	// limit the output a bit
	if (stmt.length() > SOURCE_MAX_SIZE) {
		printExecutionError(CliStrings.MESSAGE_MAX_SIZE_EXCEEDED);
		return;
	}

	terminal.writer().println(CliStrings.messageInfo(CliStrings.MESSAGE_WILL_EXECUTE).toAnsi());
	terminal.writer().println(new AttributedString(stmt).toString());
	terminal.flush();

	// try to run it
	final Optional<SqlCommandCall> call = parseCommand(stmt);
	call.ifPresent(this::callCommand);
}
 

private void testValidSqlCommand(String stmt, SqlCommandCall expectedCall) {
	final Optional<SqlCommandCall> actualCall = SqlCommandParser.parse(stmt);
	if (!actualCall.isPresent()) {
		fail();
	}
	assertEquals(expectedCall, actualCall.get());
}
 

private Optional<SqlCommandCall> parseCommand(String line) {
	final SqlCommandCall parsedLine;
	try {
		parsedLine = SqlCommandParser.parse(executor.getSqlParser(sessionId), line);
	} catch (SqlExecutionException e) {
		printExecutionException(e);
		return Optional.empty();
	}
	return Optional.of(parsedLine);
}
 

private void callDescribe(SqlCommandCall cmdCall) {
	final TableSchema schema;
	try {
		schema = executor.getTableSchema(context, cmdCall.operands[0]);
	} catch (SqlExecutionException e) {
		printExecutionException(e);
		return;
	}
	terminal.writer().println(schema.toString());
	terminal.flush();
}
 

private void callUseDatabase(SqlCommandCall cmdCall) {
	try {
		executor.useDatabase(sessionId, cmdCall.operands[0]);
	} catch (SqlExecutionException e) {
		printExecutionException(e);
		return;
	}
	terminal.flush();
}
 

private void callDescribe(SqlCommandCall cmdCall) {
	final TableSchema schema;
	try {
		schema = executor.getTableSchema(sessionId, cmdCall.operands[0]);
	} catch (SqlExecutionException e) {
		printExecutionException(e);
		return;
	}
	terminal.writer().println(schema.toString());
	terminal.flush();
}
 

private void callExplain(SqlCommandCall cmdCall) {
	final String explanation;
	try {
		TableResult tableResult = executor.executeSql(sessionId, cmdCall.operands[0]);
		explanation = tableResult.collect().next().getField(0).toString();
	} catch (SqlExecutionException e) {
		printExecutionException(e);
		return;
	}
	terminal.writer().println(explanation);
	terminal.flush();
}
 

private boolean callInsert(SqlCommandCall cmdCall) {
	printInfo(CliStrings.MESSAGE_SUBMITTING_STATEMENT);

	try {
		final ProgramTargetDescriptor programTarget = executor.executeUpdate(sessionId, cmdCall.operands[0]);
		terminal.writer().println(CliStrings.messageInfo(CliStrings.MESSAGE_STATEMENT_SUBMITTED).toAnsi());
		terminal.writer().println(programTarget.toString());
		terminal.flush();
	} catch (SqlExecutionException e) {
		printExecutionException(e);
		return false;
	}
	return true;
}
 

private void callSource(SqlCommandCall cmdCall) {
	final String pathString = cmdCall.operands[0];

	// load file
	final String stmt;
	try {
		final Path path = Paths.get(pathString);
		byte[] encoded = Files.readAllBytes(path);
		stmt = new String(encoded, Charset.defaultCharset());
	} catch (IOException e) {
		printExecutionException(e);
		return;
	}

	// limit the output a bit
	if (stmt.length() > SOURCE_MAX_SIZE) {
		printExecutionError(CliStrings.MESSAGE_MAX_SIZE_EXCEEDED);
		return;
	}

	terminal.writer().println(CliStrings.messageInfo(CliStrings.MESSAGE_WILL_EXECUTE).toAnsi());
	terminal.writer().println(new AttributedString(stmt).toString());
	terminal.flush();

	// try to run it
	final Optional<SqlCommandCall> call = parseCommand(stmt);
	call.ifPresent(this::callCommand);
}
 

private Tuple2<Boolean, SqlCommandCall> parseSqlAndCheckException(TestItem item) {
	SqlCommandCall call = null;
	Throwable actualException = null;
	try {
		call = SqlCommandParser.parse(parser, item.sql);
	} catch (Throwable e) {
		actualException = e;
	}

	if (item.expectedException == null && actualException == null) {
		return Tuple2.of(true, call);
	} else if (item.expectedException == null) {
		actualException.printStackTrace();
		fail("Failed to run sql: " + item.sql);
	} else if (actualException == null) {
		fail("the excepted exception: '" + item.expectedException + "' does not occur.\n" +
				"test statement: " + item.sql);
	} else {
		assertTrue(actualException.getClass().isAssignableFrom(item.expectedException));
		boolean hasExpectedExceptionMsg = false;
		while (actualException != null) {
			if (actualException.getMessage().contains(item.expectedExceptionMsg)) {
				hasExpectedExceptionMsg = true;
				break;
			}
			actualException = actualException.getCause();
		}
		if (!hasExpectedExceptionMsg) {
			fail("the excepted exception message: '" + item.expectedExceptionMsg + "' does not occur.\n" +
					"test statement: " + item.sql);
		}
	}
	return Tuple2.of(false, null);
}
 

private void callUseDatabase(SqlCommandCall cmdCall) {
	try {
		executor.useDatabase(context, cmdCall.operands[0]);
	} catch (SqlExecutionException e) {
		printExecutionException(e);
		return;
	}
	terminal.flush();
}
 

private Optional<SqlCommandCall> parseCommand(String line) {
	final Optional<SqlCommandCall> parsedLine = SqlCommandParser.parse(line);
	if (!parsedLine.isPresent()) {
		printError(CliStrings.MESSAGE_UNKNOWN_SQL);
	}
	return parsedLine;
}
 

private void callSet(SqlCommandCall cmdCall) {
	// show all properties
	if (cmdCall.operands.length == 0) {
		final Map<String, String> properties;
		try {
			properties = executor.getSessionProperties(context);
		} catch (SqlExecutionException e) {
			printExecutionException(e);
			return;
		}
		if (properties.isEmpty()) {
			terminal.writer().println(CliStrings.messageInfo(CliStrings.MESSAGE_EMPTY).toAnsi());
		} else {
			properties
				.entrySet()
				.stream()
				.map((e) -> e.getKey() + "=" + e.getValue())
				.sorted()
				.forEach((p) -> terminal.writer().println(p));
		}
	}
	// set a property
	else {
		context.setSessionProperty(cmdCall.operands[0], cmdCall.operands[1]);
		terminal.writer().println(CliStrings.messageInfo(CliStrings.MESSAGE_SET).toAnsi());
	}
	terminal.flush();
}
 

private void callDescribe(SqlCommandCall cmdCall) {
	final TableSchema schema;
	try {
		schema = executor.getTableSchema(context, cmdCall.operands[0]);
	} catch (SqlExecutionException e) {
		printExecutionException(e);
		return;
	}
	terminal.writer().println(schema.toString());
	terminal.flush();
}
 

private void callExplain(SqlCommandCall cmdCall) {
	final String explanation;
	try {
		explanation = executor.explainStatement(context, cmdCall.operands[0]);
	} catch (SqlExecutionException e) {
		printExecutionException(e);
		return;
	}
	terminal.writer().println(explanation);
	terminal.flush();
}
 

private boolean callInsertInto(SqlCommandCall cmdCall) {
	printInfo(CliStrings.MESSAGE_SUBMITTING_STATEMENT);

	try {
		final ProgramTargetDescriptor programTarget = executor.executeUpdate(context, cmdCall.operands[0]);
		terminal.writer().println(CliStrings.messageInfo(CliStrings.MESSAGE_STATEMENT_SUBMITTED).toAnsi());
		terminal.writer().println(programTarget.toString());
		terminal.flush();
	} catch (SqlExecutionException e) {
		printExecutionException(e);
		return false;
	}
	return true;
}
 

private void callSource(SqlCommandCall cmdCall) {
	final String pathString = cmdCall.operands[0];

	// load file
	final String stmt;
	try {
		final Path path = Paths.get(pathString);
		byte[] encoded = Files.readAllBytes(path);
		stmt = new String(encoded, Charset.defaultCharset());
	} catch (IOException e) {
		printExecutionException(e);
		return;
	}

	// limit the output a bit
	if (stmt.length() > SOURCE_MAX_SIZE) {
		printExecutionError(CliStrings.MESSAGE_MAX_SIZE_EXCEEDED);
		return;
	}

	terminal.writer().println(CliStrings.messageInfo(CliStrings.MESSAGE_WILL_EXECUTE).toAnsi());
	terminal.writer().println(new AttributedString(stmt).toString());
	terminal.flush();

	// try to run it
	final Optional<SqlCommandCall> call = parseCommand(stmt);
	call.ifPresent(this::callCommand);
}
 

private void testValidSqlCommand(String stmt, SqlCommandCall expectedCall) {
	final Optional<SqlCommandCall> actualCall = SqlCommandParser.parse(stmt);
	if (!actualCall.isPresent()) {
		fail();
	}
	assertEquals(expectedCall, actualCall.get());
}
 

private Optional<SqlCommandCall> parseCommand(String line) {
	final Optional<SqlCommandCall> parsedLine = SqlCommandParser.parse(line);
	if (!parsedLine.isPresent()) {
		printError(CliStrings.MESSAGE_UNKNOWN_SQL);
	}
	return parsedLine;
}
 

private void callSet(SqlCommandCall cmdCall) {
	// show all properties
	if (cmdCall.operands.length == 0) {
		final Map<String, String> properties;
		try {
			properties = executor.getSessionProperties(context);
		} catch (SqlExecutionException e) {
			printExecutionException(e);
			return;
		}
		if (properties.isEmpty()) {
			terminal.writer().println(CliStrings.messageInfo(CliStrings.MESSAGE_EMPTY).toAnsi());
		} else {
			properties
				.entrySet()
				.stream()
				.map((e) -> e.getKey() + "=" + e.getValue())
				.sorted()
				.forEach((p) -> terminal.writer().println(p));
		}
	}
	// set a property
	else {
		context.setSessionProperty(cmdCall.operands[0], cmdCall.operands[1]);
		terminal.writer().println(CliStrings.messageInfo(CliStrings.MESSAGE_SET).toAnsi());
	}
	terminal.flush();
}