private List<RunningQuery> getQueries(final Predicate<PersistentQueryMetadata> predicate) { return ksqlEngine.getPersistentQueries() .stream() .filter(predicate) .map(q -> new RunningQuery( q.getStatementString(), q.getSinkNames(), new EntityQueryId(q.getQueryId()))) .collect(Collectors.toList()); }
private void printWriteQueries(final SourceDescription source) { if (!source.getWriteQueries().isEmpty()) { writer().println(String.format( "%n%-20s%n%-20s", "Queries that write into this " + source.getType(), "-----------------------------------" )); for (final RunningQuery writeQuery : source.getWriteQueries()) { writer().println(writeQuery.getId().getId() + " : " + writeQuery.getQueryString()); } writer().println("\nFor query topology and execution plan please run: EXPLAIN <QueryId>"); } }
private KsqlEntity listQueries(final PreparedStatement<ListQueries> statement) { if (statement.getStatement().getShowExtended()) { return new QueryDescriptionList( statement.getStatementText(), ksqlEngine.getPersistentQueries().stream() .map(QueryDescription::forQueryMetadata) .collect(Collectors.toList())); } return new Queries( statement.getStatementText(), ksqlEngine.getPersistentQueries().stream() .map( q -> new RunningQuery( q.getStatementString(), q.getSinkNames(), new EntityQueryId(q.getQueryId()))) .collect(Collectors.toList())); }
private void printQueryDescription(final QueryDescription query) { writer().println(String.format("%-20s : %s", "ID", query.getId().getId())); if (query.getStatementText().length() > 0) { writer().println(String.format("%-20s : %s", "SQL", query.getStatementText())); } writer().println(); printSchema(query.getFields(), ""); printQuerySources(query); printQuerySinks(query); printExecutionPlan(query); printTopology(query); printOverriddenProperties(query); }
@SuppressWarnings("SameParameterValue") private List<RunningQuery> createRunningQueries( final String sql, final Map<String, Object> overriddenProperties) { return createQueries(sql, overriddenProperties) .stream() .map(md -> new RunningQuery( md.getStatementString(), md.getSinkNames(), new EntityQueryId(md.getQueryId()))) .collect(Collectors.toList()); }
@Test public void shouldSerializeCorrectly() throws IOException { final String id = "query-id"; final String serialized = String.format("\"%s\"", id); final EntityQueryId deserialized = objectMapper.readValue(serialized, EntityQueryId.class); assertThat(deserialized.getId(), equalTo(id)); assertThat(objectMapper.writeValueAsString(id), equalTo(serialized)); } }
private QueryDescription( final String id, final QueryMetadata queryMetadata, final Set<String> sinks) { this( new EntityQueryId(id), queryMetadata.getStatementString(), EntityUtil.buildSourceSchemaEntity(queryMetadata.getResultSchema()), queryMetadata.getSourceNames(), sinks, queryMetadata.getTopologyDescription(), queryMetadata.getExecutionPlan(), queryMetadata.getOverriddenProperties()); }
@Override public Table buildTable(final Queries entity) { final Stream<List<String>> rows = entity.getQueries().stream() .map(r -> ImmutableList.of( r.getId().getId(), String.join(",", r.getSinks()), r.getQueryString())); return new Builder() .withColumnHeaders(HEADERS) .withRows(rows) .withFooterLine("For detailed information on a Query run: EXPLAIN <Query ID>;") .build(); } }
queries.add( new RunningQuery( "select * from t1", Collections.singleton("Test"), new EntityQueryId("0")));
assertThat(queryDescription.getId().getId(), equalTo("")); assertThat(queryDescription.getExecutionPlan(), equalTo("execution plan")); assertThat(queryDescription.getSources(), equalTo(Collections.singleton("source")));
queryCloseCallback); final QueryDescription queryDescription = QueryDescription.forQueryMetadata(queryMetadata); assertThat(queryDescription.getId().getId(), equalTo("query_id")); assertThat(queryDescription.getSinks(), equalTo(Collections.singleton("fake_sink")));