SQL-Native Data Pipelines

Write standard SQL, use Plotono's pipe syntax, or build visually. Every approach compiles to the same optimized output targeting DuckDB or BigQuery. SQL is a first-class citizen, not an afterthought.

Write Standard SQL

Plotono does not invent a proprietary query language that replaces SQL. If you already know SQL, you can write queries directly and they will run against DuckDB or BigQuery without modification. The SQL editor provides syntax highlighting, inline error reporting, and autocompletion for table and column names.

DuckDB compatibility means you can run analytical queries locally without needing a cloud warehouse for development and testing. BigQuery compatibility means the same pipeline definition can target a production-scale warehouse when you are ready to deploy. The compiler handles the syntax differences between the two backends so your queries are portable.

Visual + SQL: Choose Your Workflow

The pipeline editor provides three modes, and you can switch between them at any time without losing your work. Visual mode shows a drag-and-drop canvas where each node represents one step in your pipeline. Pipe syntax mode displays the pipeline as a text-based chain of operations. Raw SQL mode shows the compiled query output.

All three modes share the same internal representation. A pipeline built in the visual editor produces the same SQL as one written by hand. This means teams with mixed skill levels can collaborate on the same pipeline. An analyst might prototype the logic visually, then a data engineer can switch to SQL mode to fine-tune the join conditions and add optimizations.

The toggle sits in the editor toolbar and switches the view instantly. There is no export or conversion step. What you see in one mode is always synchronized with the other two.

Pipe Syntax

Pipe syntax is a query notation designed for readability. Instead of nesting subqueries or writing complex CTEs, you chain operations using the |> pipe operator. Each step reads left to right, top to bottom, in the order it will be executed.

FROM users
|> WHERE age > 18
|> WHERE country = @target_country
|> AGGREGATE COUNT(*) AS user_count, AVG(age) AS avg_age BY country
|> ORDER BY user_count DESC
|> LIMIT 10

This reads naturally: start with the users table, filter to adults in a target country, aggregate by country to get counts and averages, sort by count, and take the top ten. The compiler transforms this into standard SQL with the same semantics.

Pipe syntax supports all the same operations as the visual builder and raw SQL, including joins, subqueries, CASE expressions, window functions, and parameterized values. It is a notation choice, not a limitation. Everything that pipe syntax can express compiles to valid SQL, and everything the visual builder can represent has an equivalent pipe syntax form.

Query Optimization

Before generating the final SQL output, Plotono runs your query through up to twelve optimization passes. Each optimizer targets a specific category of performance improvement. They work together to produce queries that run faster and use fewer resources.

ConstantFolder

Evaluates expressions made up entirely of constants at compile time. Expressions like 1 + 2 become 3 before the query ever reaches the database.

BooleanSimplifier

Reduces boolean expressions to simpler equivalent forms. Removes double negations, simplifies tautologies, and rewrites complex AND/OR trees into minimal representations.

DeadBranchEliminator

Identifies branches in CASE expressions and conditional logic that can never execute based on constant conditions, and removes them from the query.

RedundantOpEliminator

Detects and removes operations that produce no effect, such as a SELECT that selects all columns in their existing order, or a WHERE TRUE clause.

PredicatePushdown

Moves filter conditions as close to the data source as possible. Filtering earlier in the pipeline means fewer rows flow through downstream operations, reducing memory and computation.

WhereMerger

Combines multiple sequential WHERE clauses into a single filter using AND. Fewer separate filter stages means fewer query plan nodes and less overhead.

LimitPushdown

Pushes LIMIT operations closer to the data source when semantically safe, avoiding the processing of rows that will be discarded anyway.

TypeAwareFolder

Uses column type information from the schema to perform type-specific constant folding that a generic folder cannot, such as date arithmetic simplification.

ProjectionPushdown

Eliminates unused columns early in the pipeline. If a downstream SELECT only uses three columns, projections are pushed to read only those three from the source.

JoinReorderAdvisor

Analyzes join conditions and schema statistics to suggest more efficient join orderings. Smaller tables are joined first to minimize intermediate result sizes.

CommonSubexprEliminator

Finds subexpressions that appear multiple times in the query and factors them into a single computation, avoiding redundant work during execution.

SubqueryUnnest

Converts correlated subqueries into equivalent joins. Correlated subqueries force row-by-row execution; unnesting enables set-based operations that run much faster.

Parameterized Queries

Plotono queries support named parameters using the @param_name syntax. Parameters make queries reusable. Define a pipeline once with parameters for date ranges, category filters, or threshold values, then supply different values each time you execute it.

Parameters have typed definitions: integer, string, float, boolean, date, and timestamp. You can mark parameters as required or optional and provide default values. When a pipeline is used inside a dashboard, parameter values are bound to global filter controls, so end users can adjust the query without seeing or editing any SQL.

When composing pipelines, child pipeline parameters can be renamed to parent parameters. This lets you create a shared base pipeline with its own parameter names, then expose those parameters under different names in different parent contexts without modifying the original.

From SQL to Dashboard

Query results flow directly into the visualization layer. Once your SQL or pipe syntax query produces output, map the result columns to chart axes using the column mapping editor. Choose a chart type, assign X, Y, color, and size dimensions, and the chart renders immediately from your query results.

Drop the chart onto a dashboard and it stays connected to the underlying query. When the data changes or when a user adjusts a global filter, the query re-executes and the chart updates. There is no export step, no separate data model to maintain, and no stale copy of the data sitting in an intermediate layer.

Learn more about the visual pipeline builder, dashboards and visualizations, or view pricing.

Write SQL, See Results Instantly

Contact sales to get started with SQL data pipelines and twelve built-in query optimizers.