org.apache.kafka.streams.kstream.KGroupedStream Java Exaples

Source File: StreamingWordCount.java From Kafka-Streams-Real-time-Stream-Processing with The Unlicense

7 votes

public static void main(final String[] args) {
    final Properties props = new Properties();
    props.put(StreamsConfig.APPLICATION_ID_CONFIG, "StreamingWordCount");
    props.put(StreamsConfig.BOOTSTRAP_SERVERS_CONFIG, "localhost:9092");
    props.put(StreamsConfig.STATE_DIR_CONFIG, "state-store");
    props.put(StreamsConfig.DEFAULT_KEY_SERDE_CLASS_CONFIG, Serdes.String().getClass().getName());
    props.put(StreamsConfig.DEFAULT_VALUE_SERDE_CLASS_CONFIG, Serdes.String().getClass().getName());

    logger.info("Start Reading Messages");
    StreamsBuilder streamBuilder = new StreamsBuilder();
    KStream<String, String> KS0 = streamBuilder.stream("streaming-word-count");

    KStream<String, String> KS1 = KS0.flatMapValues(value ->
        Arrays.asList(value.toLowerCase().split(" ")));

    KGroupedStream<String, String> KGS2 = KS1.groupBy((key, value) -> value);

    KTable<String, Long> KTS3 = KGS2.count();

    KTS3.toStream().peek(
        (k, v) -> logger.info("Key = " + k + " Value = " + v.toString())
    );

    KafkaStreams streams = new KafkaStreams(streamBuilder.build(), props);
    streams.start();
    Runtime.getRuntime().addShutdownHook(new Thread(streams::close));
}

Source File: HoppingWindowExpressionTest.java From ksql-fork-with-deep-learning-function with Apache License 2.0

6 votes

@Test
public void shouldCreateHoppingWindowAggregate() {
  final KGroupedStream stream = EasyMock.createNiceMock(KGroupedStream.class);
  final TimeWindowedKStream windowedKStream = EasyMock.createNiceMock(TimeWindowedKStream.class);
  final UdafAggregator aggregator = EasyMock.createNiceMock(UdafAggregator.class);
  final HoppingWindowExpression windowExpression = new HoppingWindowExpression(10, TimeUnit.SECONDS, 4, TimeUnit.MILLISECONDS);
  final Initializer initializer = () -> 0;
  final Materialized<String, GenericRow, WindowStore<Bytes, byte[]>> store = Materialized.as("store");

  EasyMock.expect(stream.windowedBy(TimeWindows.of(10000L).advanceBy(4L))).andReturn(windowedKStream);
  EasyMock.expect(windowedKStream.aggregate(same(initializer), same(aggregator), same(store))).andReturn(null);
  EasyMock.replay(stream, windowedKStream);

  windowExpression.applyAggregate(stream, initializer, aggregator, store);
  EasyMock.verify(stream, windowedKStream);
}

Source File: TumblingWindowExpressionTest.java From ksql-fork-with-deep-learning-function with Apache License 2.0

6 votes

@Test
public void shouldCreateTumblingWindowAggregate() {
  final KGroupedStream stream = EasyMock.createNiceMock(KGroupedStream.class);
  final TimeWindowedKStream windowedKStream = EasyMock.createNiceMock(TimeWindowedKStream.class);
  final UdafAggregator aggregator = EasyMock.createNiceMock(UdafAggregator.class);
  final TumblingWindowExpression windowExpression = new TumblingWindowExpression(10, TimeUnit.SECONDS);
  final Initializer initializer = () -> 0;
  final Materialized<String, GenericRow, WindowStore<Bytes, byte[]>> store = Materialized.as("store");

  EasyMock.expect(stream.windowedBy(TimeWindows.of(10000L))).andReturn(windowedKStream);
  EasyMock.expect(windowedKStream.aggregate(same(initializer), same(aggregator), same(store))).andReturn(null);
  EasyMock.replay(stream, windowedKStream);

  windowExpression.applyAggregate(stream, initializer, aggregator, store);
  EasyMock.verify(stream, windowedKStream);
}

Source File: RunningAverage.java From kafka-tutorials with Apache License 2.0

6 votes

protected static KTable<Long, Double> getRatingAverageTable(KStream<Long, Rating> ratings,
                                                            String avgRatingsTopicName,
                                                            SpecificAvroSerde<CountAndSum> countAndSumSerde) {

  // Grouping Ratings
  KGroupedStream<Long, Double> ratingsById = ratings
      .map((key, rating) -> new KeyValue<>(rating.getMovieId(), rating.getRating()))
      .groupByKey(with(Long(), Double()));

  final KTable<Long, CountAndSum> ratingCountAndSum =
      ratingsById.aggregate(() -> new CountAndSum(0L, 0.0),
                            (key, value, aggregate) -> {
                              aggregate.setCount(aggregate.getCount() + 1);
                              aggregate.setSum(aggregate.getSum() + value);
                              return aggregate;
                            },
                            Materialized.with(Long(), countAndSumSerde));

  final KTable<Long, Double> ratingAverage =
      ratingCountAndSum.mapValues(value -> value.getSum() / value.getCount(),
                                  Materialized.as("average-ratings"));

  // persist the result in topic
  ratingAverage.toStream().to(avgRatingsTopicName);
  return ratingAverage;
}

Source File: GenericMetricProcessorIT.java From SkaETL with Apache License 2.0

5 votes

@Test
public void shouldComputeMedian() {

    List<JsonNode> input = Arrays.asList(
            toJsonNode("{\"project\":\"myproject\",\"type\":\"something\",\"duration\": 1}"),
            toJsonNode("{\"project\":\"myproject\",\"type\":\"something\",\"duration\": 2}"),
            toJsonNode("{\"project\":\"myproject\",\"type\":\"something\",\"duration\": 3}"),
            toJsonNode("{\"project\":\"myproject\",\"type\":\"something\",\"duration\": 4}"),
            toJsonNode("{\"project\":\"myproject\",\"type\":\"something\",\"duration\": 5}"),
            toJsonNode("{\"project\":\"myproject\",\"type\":\"something\",\"duration\": 6}"),
            toJsonNode("{\"project\":\"myproject\",\"type\":\"something\",\"duration\": 100}")
    );


    String destTopic = "median-dest";
    GenericMetricProcessor minDuration = new GenericMetricProcessor(buildProcessMetric("median", destTopic), "median-src", functionRegistry, udafRegistry) {

        @Override
        protected AggregateFunction aggInitializer() {
            return aggFunction("median");
        }

        @Override
        protected KTable<Windowed<Keys>, Double> aggregate(KGroupedStream<Keys, JsonNode> kGroupedStream) {
            return aggregateTumblingWindow(kGroupedStream, 1, TimeUnit.SECONDS);
        }

        @Override
        protected JsonNode mapValues(JsonNode value) {
            return value.path("duration");
        }
    };
    List<KafkaUnit.Message<Keys, MetricResult>> resultInDestTopic = executeMetricStream(input, minDuration, destTopic);
    assertThat(resultInDestTopic).hasSize(1);
    KafkaUnit.Message<Keys, MetricResult> result1 = resultInDestTopic.get(0);
    assertThat(result1.getKey().getRuleName()).isEqualTo("median");
    assertThat(result1.getKey().getRuleDSL()).isNotBlank();
    assertThat(result1.getKey().getProject()).isEqualTo("myproject");
    assertThat(result1.getValue().getResult()).isEqualTo(4.0029296875);
}

Source File: HoppingWindowExpression.java From ksql-fork-with-deep-learning-function with Apache License 2.0

5 votes

@SuppressWarnings("unchecked")
@Override
public KTable applyAggregate(
    KGroupedStream groupedStream,
    Initializer initializer,
    UdafAggregator aggregator,
    Materialized<String, GenericRow, ?> materialized
) {
  return groupedStream.windowedBy(
      TimeWindows.of(sizeUnit.toMillis(size))
          .advanceBy(advanceByUnit.toMillis(advanceBy))
  ).aggregate(initializer, aggregator, materialized);
}

Source File: TumblingWindowExpression.java From ksql-fork-with-deep-learning-function with Apache License 2.0

5 votes

@SuppressWarnings("unchecked")
@Override
public KTable applyAggregate(final KGroupedStream groupedStream,
                             final Initializer initializer,
                             final UdafAggregator aggregator,
                             final Materialized<String, GenericRow, ?> materialized) {
  return groupedStream.windowedBy(TimeWindows.of(sizeUnit.toMillis(size)))
      .aggregate(initializer, aggregator, materialized);

}

Source File: SessionWindowExpression.java From ksql-fork-with-deep-learning-function with Apache License 2.0

5 votes

@SuppressWarnings("unchecked")
@Override
public KTable applyAggregate(final KGroupedStream groupedStream,
                             final Initializer initializer,
                             final UdafAggregator aggregator,
                             final Materialized<String, GenericRow, ?> materialized) {
  return groupedStream.windowedBy(SessionWindows.with(sizeUnit.toMillis(gap)))
      .aggregate(initializer, aggregator, aggregator.getMerger(),
          materialized);
}

Source File: SchemaKGroupedStream.java From ksql-fork-with-deep-learning-function with Apache License 2.0

5 votes

SchemaKGroupedStream(
    final Schema schema, final KGroupedStream kgroupedStream,
    final Field keyField,
    final List<SchemaKStream> sourceSchemaKStreams,
    final FunctionRegistry functionRegistry,
    final SchemaRegistryClient schemaRegistryClient
) {
  this.schema = schema;
  this.kgroupedStream = kgroupedStream;
  this.keyField = keyField;
  this.sourceSchemaKStreams = sourceSchemaKStreams;
  this.functionRegistry = functionRegistry;
  this.schemaRegistryClient = schemaRegistryClient;
}

Source File: GenericMetricProcessorIT.java From SkaETL with Apache License 2.0

5 votes

@Test
public void shouldComputeSum() {

    List<JsonNode> input = Arrays.asList(
            toJsonNode("{\"project\":\"myproject\",\"type\":\"something\",\"duration\": 1}"),
            toJsonNode("{\"project\":\"myproject\",\"type\":\"somethingelse\",\"duration\": 9}")
    );


    String destTopic = "sum-dest";
    GenericMetricProcessor minDuration = new GenericMetricProcessor(buildProcessMetric("sum", destTopic), "sum-src", functionRegistry, udafRegistry) {

        @Override
        protected AggregateFunction aggInitializer() {
            return aggFunction("sum");
        }

        @Override
        protected KTable<Windowed<Keys>, Double> aggregate(KGroupedStream<Keys, JsonNode> kGroupedStream) {
            return aggregateTumblingWindow(kGroupedStream, 1, TimeUnit.SECONDS);
        }

        @Override
        protected JsonNode mapValues(JsonNode value) {
            return value.path("duration");
        }
    };
    List<KafkaUnit.Message<Keys, MetricResult>> resultInDestTopic = executeMetricStream(input, minDuration, destTopic);
    assertThat(resultInDestTopic).hasSize(1);
    KafkaUnit.Message<Keys, MetricResult> result1 = resultInDestTopic.get(0);
    assertThat(result1.getKey().getRuleName()).isEqualTo("sum");
    assertThat(result1.getKey().getRuleDSL()).isNotBlank();
    assertThat(result1.getKey().getProject()).isEqualTo("myproject");
    assertThat(result1.getValue().getResult()).isEqualTo(10);
}

Source File: GenericMetricProcessorIT.java From SkaETL with Apache License 2.0

5 votes

@Test
public void shouldComputeAvg() {

    List<JsonNode> input = Arrays.asList(
            toJsonNode("{\"project\":\"myproject\",\"type\":\"something\",\"duration\": 1}"),
            toJsonNode("{\"project\":\"myproject\",\"type\":\"somethingelse\",\"duration\": 9}")
    );


    String destTopic = "avg-dest";
    GenericMetricProcessor minDuration = new GenericMetricProcessor(buildProcessMetric("avg", destTopic), "avg-src", functionRegistry, udafRegistry) {

        @Override
        protected AggregateFunction aggInitializer() {
            return aggFunction("avg");
        }

        @Override
        protected KTable<Windowed<Keys>, Double> aggregate(KGroupedStream<Keys, JsonNode> kGroupedStream) {
            return aggregateTumblingWindow(kGroupedStream, 1, TimeUnit.SECONDS);
        }

        @Override
        protected JsonNode mapValues(JsonNode value) {
            return value.path("duration");
        }
    };
    List<KafkaUnit.Message<Keys, MetricResult>> resultInDestTopic = executeMetricStream(input, minDuration, destTopic);
    assertThat(resultInDestTopic).hasSize(1);
    KafkaUnit.Message<Keys, MetricResult> result1 = resultInDestTopic.get(0);
    assertThat(result1.getKey().getRuleName()).isEqualTo("avg");
    assertThat(result1.getKey().getRuleDSL()).isNotBlank();
    assertThat(result1.getKey().getProject()).isEqualTo("myproject");
    assertThat(result1.getValue().getResult()).isEqualTo(5);
}

Source File: GenericMetricProcessorIT.java From SkaETL with Apache License 2.0

5 votes

@Test
public void shouldComputeMax() {

    List<JsonNode> input = Arrays.asList(
            toJsonNode("{\"project\":\"myproject\",\"type\":\"something\",\"duration\": 1}"),
            toJsonNode("{\"project\":\"myproject\",\"type\":\"somethingelse\",\"duration\": 10}")
    );
    String destTopic = "max-dest";

    GenericMetricProcessor minDuration = new GenericMetricProcessor(buildProcessMetric("max", destTopic), "max-src", functionRegistry, udafRegistry) {

        @Override
        protected AggregateFunction aggInitializer() {
            return aggFunction("max");
        }

        @Override
        protected KTable<Windowed<Keys>, Double> aggregate(KGroupedStream<Keys, JsonNode> kGroupedStream) {
            return aggregateTumblingWindow(kGroupedStream, 1, TimeUnit.SECONDS);
        }

        @Override
        protected JsonNode mapValues(JsonNode value) {
            return value.path("duration");
        }
    };
    List<KafkaUnit.Message<Keys, MetricResult>> resultInDestTopic = executeMetricStream(input, minDuration, destTopic);
    assertThat(resultInDestTopic).hasSize(1);
    KafkaUnit.Message<Keys, MetricResult> result1 = resultInDestTopic.get(0);
    assertThat(result1.getKey().getRuleName()).isEqualTo("max");
    assertThat(result1.getKey().getRuleDSL()).isNotBlank();
    assertThat(result1.getKey().getProject()).isEqualTo("myproject");
    assertThat(result1.getValue().getResult()).isEqualTo(10);
}

Source File: GenericMetricProcessorIT.java From SkaETL with Apache License 2.0

5 votes

@Test
public void shouldComputeMin() {

    List<JsonNode> input = Arrays.asList(
            toJsonNode("{\"project\":\"myproject\",\"type\":\"something\",\"duration\": 1}"),
            toJsonNode("{\"project\":\"myproject\",\"type\":\"somethingelse\",\"duration\": 10}")
    );
    String destTopic = "min-dest";
    GenericMetricProcessor minDuration = new GenericMetricProcessor(buildProcessMetric("min", destTopic), "min-src", functionRegistry, udafRegistry) {
        @Override
        protected AggregateFunction aggInitializer() {
            return aggFunction("min");
        }

        @Override
        protected KTable<Windowed<Keys>, Double> aggregate(KGroupedStream<Keys, JsonNode> kGroupedStream) {
            return aggregateTumblingWindow(kGroupedStream, 1, TimeUnit.SECONDS);
        }

        @Override
        protected JsonNode mapValues(JsonNode value) {
            return value.path("duration");
        }
    };
    List<KafkaUnit.Message<Keys, MetricResult>> resultInDestTopic = executeMetricStream(input, minDuration, destTopic);
    assertThat(resultInDestTopic).hasSize(1);
    assertThat(resultInDestTopic.get(0).getKey().getRuleName()).isEqualTo("min");
    assertThat(resultInDestTopic.get(0).getKey().getRuleDSL()).isNotBlank();
    assertThat(resultInDestTopic.get(0).getKey().getProject()).isEqualTo("myproject");
    assertThat(resultInDestTopic.get(0).getValue().getResult()).isEqualTo(1);
}

Source File: GenericMetricProcessorIT.java From SkaETL with Apache License 2.0

5 votes

@Test
public void shouldComputeCountDistinct() {

    List<JsonNode> input = Arrays.asList(
            toJsonNode("{\"project\":\"myproject\",\"type\":\"something\",\"duration\": 1}"),
            toJsonNode("{\"project\":\"myproject\",\"type\":\"somethingelse\",\"duration\": 10}"),
            toJsonNode("{\"project\":\"myproject\",\"type\":\"somethingelse\",\"duration\": 11}"),
            toJsonNode("{\"project\":\"myproject\",\"type\":\"somethingelse\",\"duration\": 12}"),
            toJsonNode("{\"project\":\"myproject\",\"type\":\"somethingelse\",\"duration\": 13}"),
            toJsonNode("{\"project\":\"myproject\",\"type\":\"anotherone\",\"duration\": 13}")

    );
    String destTopic = "count-distinct-dest";
    GenericMetricProcessor minDuration = new GenericMetricProcessor(buildProcessMetric("count-distinct", destTopic), "count-distinct-src", functionRegistry, udafRegistry) {
        @Override
        protected AggregateFunction aggInitializer() {
            return aggFunction("count-distinct");
        }

        @Override
        protected KTable<Windowed<Keys>, Double> aggregate(KGroupedStream<Keys, JsonNode> kGroupedStream) {
            return aggregateTumblingWindow(kGroupedStream, 1, TimeUnit.SECONDS);
        }

        @Override
        protected JsonNode mapValues(JsonNode value) {                return value.path("type");
        }
    };
    List<KafkaUnit.Message<Keys, MetricResult>> resultInDestTopic = executeMetricStream(input, minDuration, destTopic);
    assertThat(resultInDestTopic).hasSize(1);
    assertThat(resultInDestTopic.get(0).getKey().getRuleName()).isEqualTo("count-distinct");
    assertThat(resultInDestTopic.get(0).getKey().getRuleDSL()).isNotBlank();
    assertThat(resultInDestTopic.get(0).getKey().getProject()).isEqualTo("myproject");
    assertThat(resultInDestTopic.get(0).getValue().getResult()).isEqualTo(3);
}

Source File: GenericMetricProcessorIT.java From SkaETL with Apache License 2.0

5 votes

@Test
public void shouldComputeCount() {

    List<JsonNode> input = Arrays.asList(
            toJsonNode("{\"project\":\"myproject\",\"type\":\"something\",\"duration\": 1}"),
            toJsonNode("{\"project\":\"myproject\",\"type\":\"somethingelse\",\"duration\": 10}")
    );
    String destTopic = "count-dest";
    GenericMetricProcessor minDuration = new GenericMetricProcessor(buildProcessMetric("count", destTopic), "count-src", functionRegistry, udafRegistry) {
        @Override
        protected AggregateFunction aggInitializer() {
            return aggFunction("count");
        }

        @Override
        protected KTable<Windowed<Keys>, Double> aggregate(KGroupedStream<Keys, JsonNode> kGroupedStream) {
            return aggregateTumblingWindow(kGroupedStream, 1, TimeUnit.SECONDS);
        }

        @Override
        protected JsonNode mapValues(JsonNode value) {                return value.path("duration");
        }
    };
    List<KafkaUnit.Message<Keys, MetricResult>> resultInDestTopic = executeMetricStream(input, minDuration, destTopic);
    assertThat(resultInDestTopic).hasSize(1);
    assertThat(resultInDestTopic.get(0).getKey().getRuleName()).isEqualTo("count");
    assertThat(resultInDestTopic.get(0).getKey().getRuleDSL()).isNotBlank();
    assertThat(resultInDestTopic.get(0).getKey().getProject()).isEqualTo("myproject");
    assertThat(resultInDestTopic.get(0).getValue().getResult()).isEqualTo(2);
}

Source File: ScsApplication.java From spring_io_2019 with Apache License 2.0

5 votes

@StreamListener
@SendTo(Bindings.AVG_RATINGS)
KStream<Long, Double> averageRatingsFor(@Input(Bindings.RATINGS) KStream<Long, Rating> ratings) {
  KGroupedStream<Long, Double> ratingsGrouped =
      ratings
          .mapValues(Rating::getRating)
          .groupByKey();
  KTable<Long, Long> count = ratingsGrouped.count();
  KTable<Long, Double>
      reduce = ratingsGrouped.reduce(Double::sum, Materialized.with(Serdes.Long(), Serdes.Double()));
  KTable<Long, Double>
      join = reduce.join(count, (sum, count1) -> sum / count1, Materialized.with(Serdes.Long(), Serdes.Double()));
  return join.toStream();
}

Source File: CogroupingStreams.java From kafka-tutorials with Apache License 2.0

5 votes

public Topology buildTopology(Properties envProps) {
    final StreamsBuilder builder = new StreamsBuilder();
        final String appOneInputTopic = envProps.getProperty("app-one.topic.name");
        final String appTwoInputTopic = envProps.getProperty("app-two.topic.name");
        final String appThreeInputTopic = envProps.getProperty("app-three.topic.name");
        final String totalResultOutputTopic = envProps.getProperty("output.topic.name");

    final Serde<String> stringSerde = getPrimitiveAvroSerde(envProps, true);
    final Serde<LoginEvent> loginEventSerde = getSpecificAvroSerde(envProps);
    final Serde<LoginRollup> loginRollupSerde = getSpecificAvroSerde(envProps);


    final KStream<String, LoginEvent> appOneStream = builder.stream(appOneInputTopic, Consumed.with(stringSerde, loginEventSerde));
    final KStream<String, LoginEvent> appTwoStream = builder.stream(appTwoInputTopic, Consumed.with(stringSerde, loginEventSerde));
    final KStream<String, LoginEvent> appThreeStream = builder.stream(appThreeInputTopic, Consumed.with(stringSerde, loginEventSerde));

    final Aggregator<String, LoginEvent, LoginRollup> loginAggregator = new LoginAggregator();

    final KGroupedStream<String, LoginEvent> appOneGrouped = appOneStream.groupByKey();
    final KGroupedStream<String, LoginEvent> appTwoGrouped = appTwoStream.groupByKey();
    final KGroupedStream<String, LoginEvent> appThreeGrouped = appThreeStream.groupByKey();

    appOneGrouped.cogroup(loginAggregator)
        .cogroup(appTwoGrouped, loginAggregator)
        .cogroup(appThreeGrouped, loginAggregator)
        .aggregate(() -> new LoginRollup(new HashMap<>()), Materialized.with(Serdes.String(), loginRollupSerde))
        .toStream().to(totalResultOutputTopic, Produced.with(stringSerde, loginRollupSerde));

    return builder.build();
}

Source File: GenericMetricProcessorIT.java From SkaETL with Apache License 2.0

4 votes

@Test
@Ignore("slow")
public void shouldComputeMinWithTumblingWindow() {

    List<JsonNode> inputStartTime = Arrays.asList(
            toJsonNode("{\"project\":\"myproject\",\"type\":\"something\",\"duration\": 2}"),
            toJsonNode("{\"project\":\"myproject\",\"type\":\"somethingelse\",\"duration\": 10}")
    );
    try {
        Thread.sleep(1000);
    } catch (InterruptedException e) {
        e.printStackTrace();
    }


    List<JsonNode> inputsDelayed = Arrays.asList(
            toJsonNode("{\"project\":\"myproject\",\"type\":\"something\",\"duration\": 1}"),
            toJsonNode("{\"project\":\"myproject\",\"type\":\"somethingelse\",\"duration\": 8}")
    );
    List<JsonNode> input = new ArrayList<>();
    input.addAll(inputStartTime);
    input.addAll(inputsDelayed);

    String destTopic = "min-dest";
    GenericMetricProcessor minDuration = new GenericMetricProcessor(buildProcessMetric("min",destTopic), "dsl", "min-src", functionRegistry, udafRegistry) {
        @Override
        protected AggregateFunction aggInitializer() {
            return aggFunction("min");
        }

        @Override
        protected KTable<Windowed<Keys>, Double> aggregate(KGroupedStream<Keys, JsonNode> kGroupedStream) {
            return aggregateTumblingWindow(kGroupedStream, 1, TimeUnit.SECONDS);
        }

        @Override
        protected JsonNode mapValues(JsonNode value) {
            return value.path("duration");
        }
    };
    List<KafkaUnit.Message<Keys, MetricResult>> resultInDestTopic = executeMetricStream(input, minDuration, destTopic);
    assertThat(resultInDestTopic).hasSize(2);
    assertThat(resultInDestTopic.get(0).getKey().getRuleName()).isEqualTo("min");
    assertThat(resultInDestTopic.get(0).getKey().getRuleDSL()).isNotBlank();
    assertThat(resultInDestTopic.get(0).getKey().getProject()).isEqualTo("myproject");
    assertThat(resultInDestTopic.get(0).getValue().getResult()).isEqualTo(2);
    assertThat(resultInDestTopic.get(1).getKey().getRuleName()).isEqualTo("min");
    assertThat(resultInDestTopic.get(1).getKey().getRuleDSL()).isNotBlank();
    assertThat(resultInDestTopic.get(1).getKey().getProject()).isEqualTo("myproject");
    assertThat(resultInDestTopic.get(1).getValue().getResult()).isEqualTo(1);

}

Source File: KsqlWindowExpression.java From ksql-fork-with-deep-learning-function with Apache License 2.0

4 votes

public abstract KTable applyAggregate(final KGroupedStream groupedStream,
final Initializer initializer,
final UdafAggregator aggregator,
final Materialized<String, GenericRow, ?> materialized);

org.apache.kafka.streams.kstream.KGroupedStream Java Examples