use of io.confluent.ksql.KsqlExecutionContext in project ksql by confluentinc.
the class RequestValidator method validate.
/**
* Validates the messages against a snapshot in time of the KSQL engine.
*
* @param statements the list of statements to validate
* @param sessionProperties session properties for this validation
* @param sql the sql that generated the list of statements, used for
* generating more useful debugging information
*
* @return the number of new persistent queries that would be created by {@code statements}
* @throws KsqlException if any of the statements cannot be validated, or the number
* of requested statements would cause the execution context
* to exceed the number of persistent queries that it was configured
* to support
*/
public int validate(final ServiceContext serviceContext, final List<ParsedStatement> statements, final SessionProperties sessionProperties, final String sql) {
requireSandbox(serviceContext);
final KsqlExecutionContext ctx = requireSandbox(snapshotSupplier.apply(serviceContext));
final Injector injector = injectorFactory.apply(ctx, serviceContext);
final KsqlConfig ksqlConfig = ctx.getKsqlConfig();
int numPersistentQueries = 0;
for (final ParsedStatement parsed : statements) {
final PreparedStatement<?> prepared = ctx.prepare(parsed, (isVariableSubstitutionEnabled(sessionProperties, ksqlConfig) ? sessionProperties.getSessionVariables() : Collections.emptyMap()));
final ConfiguredStatement<?> configured = ConfiguredStatement.of(prepared, SessionConfig.of(ksqlConfig, sessionProperties.getMutableScopedProperties()));
numPersistentQueries += validate(serviceContext, configured, sessionProperties, ctx, injector);
if (QueryCapacityUtil.exceedsPersistentQueryCapacity(ctx, ksqlConfig)) {
QueryCapacityUtil.throwTooManyActivePersistentQueriesException(ctx, ksqlConfig, sql);
}
}
return numPersistentQueries;
}
use of io.confluent.ksql.KsqlExecutionContext in project ksql by confluentinc.
the class ListSourceExecutor method sourceDescriptionList.
private static Optional<KsqlEntity> sourceDescriptionList(final ConfiguredStatement<? extends StatementWithExtendedClause> statement, final SessionProperties sessionProperties, final KsqlExecutionContext executionContext, final ServiceContext serviceContext, final List<? extends DataSource> sources, final boolean extended) {
final RemoteHostExecutor remoteHostExecutor = RemoteHostExecutor.create(statement, sessionProperties, executionContext, serviceContext.getKsqlClient());
final Multimap<String, SourceDescription> remoteSourceDescriptions = extended ? RemoteSourceDescriptionExecutor.fetchSourceDescriptions(remoteHostExecutor) : ImmutableMultimap.of();
final List<SourceDescriptionWithWarnings> descriptions = sources.stream().map(s -> describeSource(statement.getSessionConfig().getConfig(false), executionContext, serviceContext, s.getName(), extended, statement, sessionProperties, remoteSourceDescriptions.get(s.getName().toString()))).collect(Collectors.toList());
return Optional.of(new SourceDescriptionList(statement.getStatementText(), descriptions.stream().map(d -> d.description).collect(Collectors.toList()), descriptions.stream().flatMap(d -> d.warnings.stream()).collect(Collectors.toList())));
}
use of io.confluent.ksql.KsqlExecutionContext in project ksql by confluentinc.
the class StandaloneExecutor method validateStatements.
private void validateStatements(final List<ParsedStatement> statements) {
final KsqlExecutionContext sandboxEngine = ksqlEngine.createSandbox(serviceContext);
final Injector injector = injectorFactory.apply(sandboxEngine, sandboxEngine.getServiceContext());
final StatementExecutor sandboxExecutor = new StatementExecutor(sandboxEngine.getServiceContext(), sandboxEngine, injector, ksqlConfig);
final boolean hasQueries = executeStatements(statements, sandboxExecutor);
if (failOnNoQueries && !hasQueries) {
throw new KsqlException("The SQL file does not contain any persistent queries. " + "i.e. it contains no 'INSERT INTO', 'CREATE TABLE x AS SELECT' or " + "'CREATE STREAM x AS SELECT' style statements.");
}
}
Aggregations