# US 2021/0342125 A1 · Dual textual/graphical programming interfaces for streaming data processing pipelines

> Agents: this data is available as JSON from the patentgrep API and MCP server — see https://patentgrep.com/llms.txt

- Number: US 2021/0342125 A1
- Document ID: US20210342125A1
- Status: Published application
- Kind: A1
- Application number: 16/864,054
- Filed: 2020-04-30
- Published: 2021-11-04
- Earliest claimed: 2020-04-30
- Assignees: Splunk Inc.
- Applicants: Splunk Inc.
- Inventors: Ricky Gene Burnett; Joseph Gabriel Echeverria; Max Feng; Arthur Foelsche; Anush Kumar Jayaraman; Eric Prokop; Jeremiah Reichardt; Ran Xie
- Web page: https://patentgrep.com/patent/US20210342125A1

## CPC

- G06F 8/34: Graphical or visual programming
- G06F 16/252: {between a Database Management System and a front-end application}
- G06F 3/0482: Interaction with lists of selectable items, e.g. menus
- G06F 3/0483: Interaction with page-structured environments, e.g. book metaphor
- G06F 3/04842: Selection of displayed objects or displayed text elements (G06F3/0482 takes precedence)
- G06F 3/04847: Interaction techniques to control parameter settings, e.g. interaction with sliders or dials
- G06F 9/546: {Message passing systems or structures, e.g. queues}
- G06F 16/2428: {Query predicate definition using graphical user interfaces, including menus and forms (G06F16/2423 takes precedence)}
- G06F 16/24534: {Query rewriting; Transformation}
- G06F 16/24568: {Data stream processing; Continuous queries}
- G06F 16/9024: {Graphs; Linked lists (G06F16/9027 takes precedence)}
- G06F: ELECTRIC DIGITAL DATA PROCESSING (computer systems based on specific computational models G06N)

## Abstract

Systems and methods are disclosed for implementing dual textual/graphical programming interfaces for programming streaming data processing pipelines. A user interface is provided that enables a user to author a processing pipeline as a query in a query language, and to request conversion of that query language into a graph data structure representation of the pipeline, which can be visualized in the interface. The interface further enables modification of the graph via interaction with the visualization. On request, the modified graph can be converted back into the query language, with the querying being modified to reflect the modifications to the graph. In some embodiments, the graph data structure representation and/or the query language representation of the pipeline can be converted into a third representation, such as an Abstract Syntax Tree, that is deployed to an intake system to implement the pipeline.

## Claims

### Claim 1

A method comprising:
providing a graphical interface enabling a user to program operation of an iterative publish-subscribe-based message processing system via both a graphical programming interface and a textual programming interface, wherein the textual programming interface enables the user to author a query, within a query language, to define a processing pipeline designating handling of messages on the message processing system, and wherein the graphical programming interface enables the user to program operation of the message processing system by arranging a set of nodes within the graphical programming interface and visually interconnecting the set of nodes to form the processing pipeline;
obtaining input to the graphical programming interface that specifies one or more nodes and interconnections between those nodes to form the processing pipeline;
in response to selection of an input requesting display of the textual programming interface, generating a query representing the processing pipeline and displaying the generated query within the textual programming interface;
obtaining, via the textual programming interface, a modified query that represents a modification to the generated query; and
programming the iterative publish-subscribe-based message processing system to implement the processing pipeline as represented by the modified query.

### Claim 2 (depends on 1)

The method of claim 1 further comprising storing the input to the graphical programming interface as a graph data structure representation of the processing pipeline.

### Claim 3 (depends on 1)

The method of claim 1 further comprising storing the input to the graphical programming interface as a graph data structure representation of the processing pipeline, wherein the graph data structure representation is stored as a JavaScript Object Notation (JSON) object.

### Claim 4 (depends on 1)

The method of claim 1 further comprising storing the input to the graphical programming interface as a graph data structure representation of the processing pipeline, wherein generating the query representing the processing pipeline comprises converting the graph data structure representation of the processing pipeline into a query-language representation of the processing pipeline.

### Claim 5 (depends on 1)

The method of claim 1 further comprising storing the input to the graphical programming interface as a graph data structure representation of the processing pipeline, wherein generating the query representing the processing pipeline comprises converting the graph data structure representation of the processing pipeline into a query-language representation of the processing pipeline, and wherein converting the graph data structure representation of the processing pipeline into the query-language representation of the processing pipeline comprises converting individual nodes of the graph data structure into a set of commands in the query language and combining the set of commands with pipe commands to form the query-language representation.

### Claim 6 (depends on 1)

The method of claim 1 further comprising storing the input to the graphical programming interface as a graph data structure representation of the processing pipeline, wherein:
generating the query representing the processing pipeline comprises converting the graph data structure representation of the processing pipeline into a query-language representation of the processing pipeline;
converting the graph data structure representation of the processing pipeline into the query-language representation of the processing pipeline comprises converting individual nodes of the graph data structure into a set of commands in the query language and combining the set of commands with pipe commands to form the query-language representation; and
the individual nodes of the graph data structure are converted into the set of commands in the query language using a predefined mapping of types of the individual nodes and individual commands within the set of commands.

### Claim 7 (depends on 1)

The method of claim 1 further comprising displaying in the graphical interface:
a graph data structure representation of the processing pipeline as represented by the modified query; and
one or more inputs enabling visual modification of the graph data structure representation of the processing pipeline as represented by the modified query.

### Claim 8 (depends on 1)

The method of claim 1 further comprising displaying in the graphical interface:
a graph data structure representation of the processing pipeline as represented by the modified query; and
one or more inputs enabling visual modification of the graph data structure representation of the processing pipeline as represented by the modified query;
wherein the one or more inputs comprise an input selectable to cause at least one node to be added on an interconnection between two existing nodes of the graph data structure.

### Claim 9 (depends on 1)

The method of claim 1 further comprising displaying in the graphical interface:
a graph data structure representation of the processing pipeline as represented by the modified query; and
one or more inputs enabling visual modification of the graph data structure representation of the processing pipeline as represented by the modified query;
wherein the one or more inputs comprise an input selectable to cause at least one interconnection between two existing nodes of the graph data structure to be split into two interconnections.

### Claim 10 (depends on 1)

The method of claim 1 further comprising:
converting modified query into a graph data structure representation of the processing pipeline as represented by the modified query; and
displaying the graph data structure representation of the processing pipeline as represented by the modified query in the graphical interface.

### Claim 11 (depends on 1)

The method of claim 1, wherein programming the iterative publish-subscribe-based message processing system to implement the processing pipeline as represented by the modified query comprises converting the modified query into an Abstract Syntax Tree (AST) data structure.

### Claim 12 (depends on 1)

The method of claim 1 further comprising:
converting modified query into a graph data structure representation of the processing pipeline as represented by the modified query; and
displaying the graph data structure representation of the processing pipeline as represented by the modified query in the graphical interface;
wherein converting modified query into the graph data structure representation of the processing pipeline as represented by the modified query comprises:
converting the modified query into an Abstract Syntax Tree (AST) data structure; and
converting the AST data structure into the graph data structure representation of the processing pipeline as represented by the modified query.

### Claim 13 (depends on 1)

The method of claim 1, wherein the one or more nodes of the processing pipeline include at least a first node corresponding to a data source and a second node corresponding to an output destination for data processed by the processing pipeline.

### Claim 14 (depends on 1)

The method of claim 1, wherein the one or more nodes of the processing pipeline include at least a first node corresponding to a data source, a second node corresponding to an output destination for data processed by the processing pipeline, and a third node corresponding to a transformation of data processed by the processing pipeline, wherein the third node is interposed between the first and second nodes within the processing pipeline.

### Claim 15 (depends on 1)

The method of claim 1 further comprising:
prior to programming the iterative publish-subscribe-based message processing system to implement the processing pipeline as represented by the modified query, receiving a request to preview the processing pipeline; and
programming the iterative publish-subscribe-based message processing system to implement a preview of the processing pipeline as represented by the modified query, the preview instructing the iterative publish-subscribe-based message processing system to implement operations of the processing pipeline without transmitting data to an external system.

### Claim 16 (depends on 1)

The method of claim 1, wherein the one or more nodes of the processing pipeline include at least a first node corresponding to a streaming data source, and wherein programming the iterative publish-subscribe-based message processing system to implement the processing pipeline as represented by the modified query causes the iterative publish-subscribe-based message processing system to process data objects via the processing pipeline as they become available at the streaming data source.

### Claim 17 (depends on 1)

The method of claim 1, wherein the one or more nodes of the processing pipeline include at least a first node corresponding to a data source providing raw machine data for processing.

### Claim 18 (depends on 1)

The method of claim 1, wherein generating the query representing the processing pipeline comprises applying error checking to a graph representing the one or more nodes and interconnections between those nodes to ensure that the graph can be converted into the query.

### Claim 19 (depends on 1)

The method of claim 1, wherein generating the query representing the processing pipeline comprises applying error checking to a graph representing the one or more nodes and interconnections between those nodes to ensure that the graph can be converted into the query, wherein applying the error checking comprises determining that the graph does not include loops.

### Claim 20 (depends on 1)

The method of claim 1 further comprising applying error checking to the modified query, wherein applying the error checking comprises validating a syntax of the modified query.

### Claim 21 (depends on 1)

The method of claim 1 further comprising, after receiving specification of at least one node in the one or more nodes, causing output of information regarding options for additional nodes to add to the one or more nodes, wherein the options for the additional nodes are identified based on compatibility with the at least one node.

### Claim 22 (depends on 1)

The method of claim 1 further comprising, after receiving specification of at least one node in the one or more nodes, causing output of information regarding options for additional nodes to add to the one or more nodes, wherein the options for the additional nodes are identified by using a trained machine learning model to analyze nodes currently in the pipeline and output a recommendation for at least one additional node.

### Claim 23 (depends on 1)

The method of claim 1, wherein the one or more nodes of the processing pipeline include at least a first node corresponding to a data source, and wherein the method further comprises, after receiving specification of at least one node in the one or more nodes, causing output of information regarding options for additional nodes to add to the one or more nodes, wherein the options for the additional nodes are identified based on historical data obtained from the data source.

### Claim 24 (depends on 1)

The method of claim 1, wherein the one or more nodes of the processing pipeline include at least a first node corresponding to an output destination, and wherein the method further comprises, after receiving specification of at least one node in the one or more nodes, causing output of information regarding options for additional nodes to add to the one or more nodes, wherein the options for the additional nodes are identified based on historical data written to the output destination.

### Claim 25 (depends on 1)

The method of claim 1, wherein the one or more nodes of the processing pipeline include at least a first node corresponding to an output destination, wherein the output destination is a data intake and query system.

### Claim 26 (depends on 1)

The method of claim 1 further comprising presenting a plurality of pre-defined templates for the one or more nodes and interconnections between those nodes, and wherein the input comprises selection of a template from the plurality of pre-defined templates.

### Claim 27

A system comprising:
a data store including computer-executable instructions; and
a processor in communication with the data store and configured to execute the computer-executable instructions to:
provide a graphical interface enabling a user to program operation of an iterative publish-subscribe-based message processing system via both a graphical programming interface and a textual programming interface, wherein the textual programming interface enables the user to author a query, within a query language, to define a processing pipeline designating handling of messages on the message processing system, and wherein the graphical programming interface enables the user to program operation of the message processing system by arranging a set of nodes within the graphical programming interface and visually interconnecting the set of nodes to form the processing pipeline;
obtain input to the graphical programming interface that specifies one or more nodes and interconnections between those nodes to form the processing pipeline;
in response to selection of an input requesting display of the textual programming interface, generate a query representing the processing pipeline and displaying the generated query within the textual programming interface;
obtain, via the textual programming interface, a modified query that represents a modification to the generated query; and
program the iterative publish-subscribe-based message processing system to implement the processing pipeline as represented by the modified query.

### Claim 28 (depends on 27)

The system of claim 27, wherein the processor is further configured to execute the computer-executable instructions to store the input to the graphical programming interface as a graph data structure representation of the processing pipeline and to generate the query representing the processing pipeline at least partly by converting the graph data structure representation of the processing pipeline into a query-language representation of the processing pipeline.

### Claim 29

Non-transitory computer-readable media comprising computer-executable instructions that, when executed by a computing system, cause the computing system to:
provide a graphical interface enabling a user to program operation of an iterative publish-subscribe-based message processing system via both a graphical programming interface and a textual programming interface, wherein the textual programming interface enables the user to author a query, within a query language, to define a processing pipeline designating handling of messages on the message processing system, and wherein the graphical programming interface enables the user to program operation of the message processing system by arranging a set of nodes within the graphical programming interface and visually interconnecting the set of nodes to form the processing pipeline;
obtain input to the graphical programming interface that specifies one or more nodes and interconnections between those nodes to form the processing pipeline;
in response to selection of an input requesting display of the textual programming interface, generate a query representing the processing pipeline and displaying the generated query within the textual programming interface;
obtain, via the textual programming interface, a modified query that represents a modification to the generated query; and
program the iterative publish-subscribe-based message processing system to implement the processing pipeline as represented by the modified query.

### Claim 30 (depends on 27)

The non-transitory computer-readable media of claim 27, wherein the computer-executable instructions further cause the computing system to store the input to the graphical programming interface as a graph data structure representation of the processing pipeline and to generate the query representing the processing pipeline at least partly by converting the graph data structure representation of the processing pipeline into a query-language representation of the processing pipeline.
