use of io.confluent.ksql.statement.ConfiguredStatement in project ksql by confluentinc.
the class RequestHandler method executeStatement.
@SuppressWarnings("unchecked")
private <T extends Statement> Optional<KsqlEntity> executeStatement(final KsqlSecurityContext securityContext, final PreparedStatement<T> prepared, final SessionProperties sessionProperties, final KsqlEntityList entities) {
final Class<? extends Statement> statementClass = prepared.getStatement().getClass();
commandQueueSync.waitFor(new KsqlEntityList(entities), statementClass);
final ConfiguredStatement<T> configured = ConfiguredStatement.of(prepared, SessionConfig.of(this.ksqlEngine.getKsqlConfig(), sessionProperties.getMutableScopedProperties()));
FeatureFlagChecker.throwOnDisabledFeatures(configured);
final StatementExecutor<T> executor = (StatementExecutor<T>) customExecutors.getOrDefault(statementClass, (stmt, props, ctx, svcCtx) -> distributor.execute(stmt, ctx, securityContext));
final StatementExecutorResponse response = executor.execute(configured, sessionProperties, ksqlEngine, securityContext.getServiceContext());
if (response.isHandled()) {
return response.getEntity();
} else {
return distributor.execute(configured, ksqlEngine, securityContext).getEntity();
}
}
use of io.confluent.ksql.statement.ConfiguredStatement in project ksql by confluentinc.
the class DefaultSchemaInjectorFunctionalTest method shouldInferSchema.
private void shouldInferSchema(final org.apache.avro.Schema avroSchema, final Schema expectedKqlSchema) {
// Given:
final Schema expectedSchema = new ConnectKsqlSchemaTranslator(SchemaTranslationPolicies.of(this.translationPolicy)).toKsqlSchema(expectedKqlSchema);
try {
if (testType == TestType.WITHOUT_SCHEMA_ID) {
when(srClient.getLatestSchemaMetadata(any())).thenReturn(new SchemaMetadata(1, 1, avroSchema.toString()));
}
when(srClient.getSchemaBySubjectAndId(any(), anyInt())).thenReturn(this.avroSchema);
when(this.avroSchema.schemaType()).thenReturn("AVRO");
when(this.avroSchema.rawSchema()).thenReturn(avroSchema);
constructCSASSource(expectedSchema);
} catch (final Exception e) {
throw new AssertionError(e);
}
final PreparedStatement<Statement> prepared = KsqlParserTestUtil.buildSingleAst(this.statement, metaStore, true);
// When:
final KsqlConfig ksqlConfig = new KsqlConfig(ImmutableMap.of());
final ConfiguredStatement<?> inferred = schemaInjector.inject(ConfiguredStatement.of(prepared, SessionConfig.of(ksqlConfig, ImmutableMap.of())));
// Then:
if (testType == TestType.CSAS_WITH_SCHEMA_ID) {
validateCsasInference((ConfiguredStatement<CreateStreamAsSelect>) inferred, this.avroSchema);
} else {
final Statement withSchema = KsqlParserTestUtil.buildSingleAst(inferred.getStatementText(), metaStore, true).getStatement();
final Schema actual = getSchemaForDdlStatement((CreateSource) withSchema);
assertThat(FORMATTER.format(actual), equalTo(FORMATTER.format(expectedSchema)));
assertThat(actual, equalTo(expectedSchema));
}
}
use of io.confluent.ksql.statement.ConfiguredStatement in project ksql by confluentinc.
the class RequestValidator method validate.
/**
* @return the number of persistent queries that were validated
*
* @throws KsqlStatementException if the statement cannot be validated
*/
@SuppressWarnings("unchecked")
private <T extends Statement> int validate(final ServiceContext serviceContext, final ConfiguredStatement<T> configured, final SessionProperties sessionProperties, final KsqlExecutionContext executionContext, final Injector injector) throws KsqlStatementException {
final Statement statement = configured.getStatement();
final Class<? extends Statement> statementClass = statement.getClass();
final StatementValidator<T> customValidator = (StatementValidator<T>) customValidators.get(statementClass);
if (customValidator != null) {
customValidator.validate(configured, sessionProperties, executionContext, serviceContext);
} else if (KsqlEngine.isExecutableStatement(configured.getStatement()) || configured.getStatement() instanceof TerminateQuery) {
final ConfiguredStatement<?> statementInjected = injector.inject(configured);
distributedStatementValidator.create(statementInjected, serviceContext, executionContext);
} else {
throw new KsqlStatementException("Do not know how to validate statement of type: " + statementClass + " Known types: " + customValidators.keySet(), configured.getStatementText());
}
return (statement instanceof CreateAsSelect || statement instanceof InsertInto) ? 1 : 0;
}
use of io.confluent.ksql.statement.ConfiguredStatement in project ksql by confluentinc.
the class QueryExecutor method handleQuery.
private QueryMetadataHolder handleQuery(final ServiceContext serviceContext, final PreparedStatement<Query> statement, final Optional<Boolean> isInternalRequest, final MetricsCallbackHolder metricsCallbackHolder, final Map<String, Object> configOverrides, final Map<String, Object> requestProperties, final Context context, final boolean excludeTombstones) {
if (statement.getStatement().isPullQuery()) {
final ImmutableAnalysis analysis = ksqlEngine.analyzeQueryWithNoOutputTopic(statement.getStatement(), statement.getStatementText(), configOverrides);
final DataSource dataSource = analysis.getFrom().getDataSource();
final DataSource.DataSourceType dataSourceType = dataSource.getDataSourceType();
if (!ksqlConfig.getBoolean(KsqlConfig.KSQL_PULL_QUERIES_ENABLE_CONFIG)) {
throw new KsqlStatementException("Pull queries are disabled." + PullQueryValidator.PULL_QUERY_SYNTAX_HELP + System.lineSeparator() + "Please set " + KsqlConfig.KSQL_PULL_QUERIES_ENABLE_CONFIG + "=true to enable " + "this feature." + System.lineSeparator(), statement.getStatementText());
}
Optional<ConsistencyOffsetVector> consistencyOffsetVector = Optional.empty();
if (ksqlConfig.getBoolean(KsqlConfig.KSQL_QUERY_PULL_CONSISTENCY_OFFSET_VECTOR_ENABLED) && requestProperties.containsKey(KsqlRequestConfig.KSQL_REQUEST_QUERY_PULL_CONSISTENCY_OFFSET_VECTOR)) {
final String serializedCV = (String) requestProperties.get(KsqlRequestConfig.KSQL_REQUEST_QUERY_PULL_CONSISTENCY_OFFSET_VECTOR);
// serializedCV will be empty on the first request as the consistency vector is initialized
// at the server
consistencyOffsetVector = serializedCV != null && !serializedCV.equals("") ? Optional.of(ConsistencyOffsetVector.deserialize(serializedCV)) : Optional.of(ConsistencyOffsetVector.emptyVector());
}
switch(dataSourceType) {
case KTABLE:
{
// First thing, set the metrics callback so that it gets called, even if we hit an error
final AtomicReference<PullQueryResult> resultForMetrics = new AtomicReference<>(null);
metricsCallbackHolder.setCallback(QueryMetricsUtil.initializePullTableMetricsCallback(pullQueryMetrics, pullBandRateLimiter, resultForMetrics));
final SessionConfig sessionConfig = SessionConfig.of(ksqlConfig, configOverrides);
final ConfiguredStatement<Query> configured = ConfiguredStatement.of(statement, sessionConfig);
return handleTablePullQuery(analysis, serviceContext, configured, requestProperties, isInternalRequest, pullBandRateLimiter, resultForMetrics, consistencyOffsetVector);
}
case KSTREAM:
{
// First thing, set the metrics callback so that it gets called, even if we hit an error
final AtomicReference<StreamPullQueryMetadata> resultForMetrics = new AtomicReference<>(null);
final AtomicReference<Decrementer> refDecrementer = new AtomicReference<>(null);
metricsCallbackHolder.setCallback(QueryMetricsUtil.initializePullStreamMetricsCallback(pullQueryMetrics, pullBandRateLimiter, analysis, resultForMetrics, refDecrementer));
final SessionConfig sessionConfig = SessionConfig.of(ksqlConfig, configOverrides);
final ConfiguredStatement<Query> configured = ConfiguredStatement.of(statement, sessionConfig);
return handleStreamPullQuery(analysis, serviceContext, configured, resultForMetrics, refDecrementer);
}
default:
throw new KsqlStatementException("Unexpected data source type for pull query: " + dataSourceType, statement.getStatementText());
}
} else if (ScalablePushUtil.isScalablePushQuery(statement.getStatement(), ksqlEngine, ksqlConfig, configOverrides)) {
// First thing, set the metrics callback so that it gets called, even if we hit an error
final AtomicReference<ScalablePushQueryMetadata> resultForMetrics = new AtomicReference<>(null);
metricsCallbackHolder.setCallback(QueryMetricsUtil.initializeScalablePushMetricsCallback(scalablePushQueryMetrics, scalablePushBandRateLimiter, resultForMetrics));
final ImmutableAnalysis analysis = ksqlEngine.analyzeQueryWithNoOutputTopic(statement.getStatement(), statement.getStatementText(), configOverrides);
QueryLogger.info("Scalable push query created", statement.getStatementText());
return handleScalablePushQuery(analysis, serviceContext, statement, configOverrides, requestProperties, context, scalablePushBandRateLimiter, resultForMetrics);
} else {
// log validated statements for query anonymization
QueryLogger.info("Transient query created", statement.getStatementText());
return handlePushQuery(serviceContext, statement, configOverrides, excludeTombstones);
}
}
Aggregations