\n");
for (row, row_cells) in header_rows {
@@ -118,7 +139,8 @@ impl Writer for HtmlWriter {
/// Render one `TableCell` as an HTML tag — `| `/` | ` from
/// `cell.is_header()`, with a `colspan`/`rowspan` attribute only when the
-/// cell actually spans more than one column/row.
+/// cell actually spans more than one column/row, and a `style` attribute
+/// only when `cell.properties` resolves to one.
fn render_cell(cell: &TableCell) -> String {
let tag = if cell.is_header() { "th" } else { "td" };
let colspan = cell.width();
@@ -130,9 +152,80 @@ fn render_cell(cell: &TableCell) -> String {
if rowspan > 1 {
attrs.push_str(&format!(" rowspan=\"{rowspan}\""));
}
+ if let Some(style) = cell_style(&cell.properties) {
+ attrs.push_str(&format!(" style=\"{style}\""));
+ }
format!("<{tag}{attrs}>{}", escape_html(&cell.content))
}
+/// Translate a cell's resolved `FORMAT` properties into a `style` attribute
+/// value, or `None` if none of them produce a CSS declaration.
+fn cell_style(properties: &Parameters) -> Option {
+ let mut declarations = Vec::new();
+
+ if let Some(align) = text_align(properties.get("hjust")) {
+ declarations.push(format!("text-align: {align}"));
+ // Right-aligned data reads as numeric — keep digit widths uniform
+ // so they still line up under one another.
+ if align == "right" {
+ declarations.push("font-variant-numeric: tabular-nums".to_string());
+ }
+ }
+
+ (!declarations.is_empty()).then(|| declarations.join("; "))
+}
+
+/// Map a resolved `hjust` number to a CSS `text-align` keyword, bucketed
+/// with the same `0.25`/`0.75` thresholds `VegaLiteWriter`'s `convert_hjust`
+/// uses for its own `align` conversion, so `hjust` means the same alignment
+/// in both writers. `resolve_column_properties` already standardises every
+/// `hjust` (however the user wrote it) to a number before it reaches a
+/// `TableCell`, so a non-`Number` here is unreachable in practice.
+fn text_align(hjust: Option<&ParameterValue>) -> Option<&'static str> {
+ match hjust? {
+ ParameterValue::Number(n) if *n <= 0.25 => Some("left"),
+ ParameterValue::Number(n) if *n >= 0.75 => Some("right"),
+ ParameterValue::Number(_) => Some("center"),
+ _ => None,
+ }
+}
+
+/// Render a `` block, one `` per column, or `None` if
+/// `columns` is absent or none of them resolve a `style`. Skipping the block
+/// entirely in that case avoids emitting a run of bare, attribute-less
+/// `` tags that would render identically to omitting them.
+fn render_colgroup(columns: Option<&[TableColumn]>) -> Option {
+ let styles: Vec> = columns?
+ .iter()
+ .map(|c| column_style(&c.properties))
+ .collect();
+ if styles.iter().all(Option::is_none) {
+ return None;
+ }
+
+ let mut html = String::from("\n");
+ for style in styles {
+ match style {
+ Some(style) => html.push_str(&format!("\n")),
+ None => html.push_str("\n"),
+ }
+ }
+ html.push_str("\n");
+ Some(html)
+}
+
+/// Translate a column's resolved `FORMAT` properties into a ``'s
+/// `style` attribute value, or `None` if it has no `width`. `width`'s value
+/// is already validated (by `ParamConstraint::string_numeric_with_unit`) to
+/// be a number immediately followed by `px` or `%`, which is exactly CSS's
+/// own `width` syntax, so it's used as-is.
+fn column_style(properties: &Parameters) -> Option {
+ match properties.get("width") {
+ Some(ParameterValue::String(width)) => Some(format!("width: {width}")),
+ _ => None,
+ }
+}
+
/// Per row, the column positions already covered by a cell that started in
/// an earlier row and hasn't ended yet (a rowspan declared above that row) —
/// those get no cell and no filler when the row is rendered, since the
@@ -184,14 +277,7 @@ fn render_row(mut cells: Vec<&TableCell>, ncol: usize, occupied: &HashSet
// by another spanner's occupancy) renders through `render_cell`
// too, so one place decides which tag a `TableCellKind` gets,
// not two.
- let filler = TableCell {
- kind,
- top: cells[0].top,
- bottom: cells[0].top,
- left: col,
- right: col,
- content: String::new(),
- };
+ let filler = TableCell::new(kind, cells[0].top, cells[0].top, col, col, String::new());
html.push_str(&render_cell(&filler));
col += 1;
}
@@ -213,14 +299,7 @@ mod render_tests {
left: usize,
right: usize,
) -> TableCell {
- TableCell {
- kind,
- top,
- bottom,
- left,
- right,
- content: String::new(),
- }
+ TableCell::new(kind, top, bottom, left, right, String::new())
}
#[test]
@@ -234,6 +313,99 @@ mod render_tests {
assert_eq!(render_cell(&c), " | ");
}
+ #[test]
+ fn render_cell_emits_a_style_attribute_from_properties() {
+ // The exact declarations a given `hjust` produces are `cell_style`'s
+ // own tests' job — this just checks render_cell embeds whatever
+ // `cell_style` returns as a `style="..."` attribute.
+ let mut c = cell(TableCellKind::Body, 0, 0, 0, 0);
+ c.properties
+ .insert("hjust".to_string(), ParameterValue::Number(1.0));
+ let style = cell_style(&c.properties).unwrap();
+ assert_eq!(render_cell(&c), format!(" | "));
+ }
+
+ #[test]
+ fn text_align_buckets_a_resolved_hjust_number() {
+ assert_eq!(text_align(None), None);
+ assert_eq!(text_align(Some(&ParameterValue::Number(0.0))), Some("left"));
+ assert_eq!(text_align(Some(&ParameterValue::Number(0.1))), Some("left"));
+ assert_eq!(
+ text_align(Some(&ParameterValue::Number(0.5))),
+ Some("center")
+ );
+ assert_eq!(
+ text_align(Some(&ParameterValue::Number(0.9))),
+ Some("right")
+ );
+ assert_eq!(
+ text_align(Some(&ParameterValue::Number(1.0))),
+ Some("right")
+ );
+ }
+
+ #[test]
+ fn cell_style_only_adds_tabular_nums_when_right_aligned() {
+ let mut left = Parameters::new();
+ left.insert("hjust".to_string(), ParameterValue::Number(0.0));
+ assert_eq!(cell_style(&left), Some("text-align: left".to_string()));
+
+ let mut right = Parameters::new();
+ right.insert("hjust".to_string(), ParameterValue::Number(1.0));
+ assert_eq!(
+ cell_style(&right),
+ Some("text-align: right; font-variant-numeric: tabular-nums".to_string())
+ );
+
+ assert_eq!(cell_style(&Parameters::new()), None);
+ }
+
+ #[test]
+ fn column_style_reads_a_string_width_as_a_css_width() {
+ let mut properties = Parameters::new();
+ properties.insert(
+ "width".to_string(),
+ ParameterValue::String("20%".to_string()),
+ );
+ assert_eq!(column_style(&properties), Some("width: 20%".to_string()));
+
+ assert_eq!(column_style(&Parameters::new()), None);
+ }
+
+ fn column(properties: Parameters) -> TableColumn {
+ TableColumn {
+ name: String::new(),
+ label: String::new(),
+ properties,
+ }
+ }
+
+ #[test]
+ fn render_colgroup_returns_none_without_columns() {
+ assert_eq!(render_colgroup(None), None);
+ }
+
+ #[test]
+ fn render_colgroup_returns_none_when_no_column_has_a_width() {
+ let columns = vec![column(Parameters::new()), column(Parameters::new())];
+ assert_eq!(render_colgroup(Some(&columns)), None);
+ }
+
+ #[test]
+ fn render_colgroup_emits_a_bare_col_for_a_column_with_no_width() {
+ let mut widened = Parameters::new();
+ widened.insert(
+ "width".to_string(),
+ ParameterValue::String("20%".to_string()),
+ );
+ let columns = vec![column(widened), column(Parameters::new())];
+
+ assert_eq!(
+ render_colgroup(Some(&columns)).unwrap(),
+ "\n\n\n\n"
+ );
+ }
+
#[test]
fn render_row_skips_a_column_occupied_by_a_rowspan_from_above() {
let a = cell(TableCellKind::ColumnLabel, 1, 1, 0, 0);
@@ -252,7 +424,7 @@ mod render_tests {
cell(TableCellKind::ColumnLabel, 0, 0, 1, 1),
];
- assert!(HtmlWriter::new().write_table(&cells).is_err());
+ assert!(HtmlWriter::new().write_table(&cells, None, None).is_err());
}
#[test]
@@ -267,7 +439,7 @@ mod render_tests {
cell(TableCellKind::Body, 2, 2, 1, 1),
];
- let html = HtmlWriter::new().write_table(&cells).unwrap();
+ let html = HtmlWriter::new().write_table(&cells, None, None).unwrap();
assert_eq!(
html,
@@ -303,10 +475,15 @@ mod tests {
let writer = HtmlWriter::new();
let html = writer.render(&spec).unwrap();
+ // Precise per-dtype alignment is covered directly by
+ // resolve_column_properties's/cell_style's own tests — this just
+ // checks the columns render and escaping works end to end.
assert!(html.starts_with(""));
- assert!(html.contains("| id | "));
- assert!(html.contains("name | "));
- assert!(html.contains("1 | "));
+ assert!(html.contains(">id"));
+ assert!(html.contains(">name"));
+ assert!(html.contains(">1"));
+ assert!(html.contains("text-align: right")); // "id"/1, numeric
+ assert!(html.contains("text-align: left")); // "name", text
assert!(html.contains("<b>a</b>"));
assert!(!html.contains("a"));
}
@@ -328,11 +505,36 @@ mod tests {
// "amount" has no spanner, so its label stretches up into the
// spanner row (rowspan) instead of a blank filler cell there.
- assert!(html.contains("| Info | amount |
|---|
"));
- assert!(html.contains("id | "));
- assert!(html.contains("name | "));
+ // Alignment styling is incidental here (amount/id are numeric) and
+ // covered precisely by resolve_column_properties's own tests — this
+ // checks colspan/rowspan/ordering, not exact style content.
+ assert!(html.contains("| Info | amount | "));
+ assert!(html.contains(">id"));
+ assert!(html.contains(">name"));
// The spanner row renders above the column-label row.
- assert!(html.find("Info").unwrap() < html.find("id | ").unwrap());
+ assert!(html.find("Info").unwrap() < html.find(">id").unwrap());
+ }
+
+ #[test]
+ fn test_write_table_renders_a_colgroup_for_a_formats_width() {
+ let reader = DuckDBReader::from_connection_string("duckdb://memory").unwrap();
+ reader
+ .execute_sql("CREATE TABLE sales AS SELECT * FROM (VALUES (1, 'a')) AS t(id, name)")
+ .unwrap();
+ let spec = reader
+ .execute("TABULATE FROM sales FORMAT id SETTING width => '20%'")
+ .unwrap();
+
+ let writer = HtmlWriter::new();
+ let html = writer.render(&spec).unwrap();
+
+ assert!(html.contains(""));
+ assert!(html.contains(""));
+ // "name" has no FORMAT width, so its stays bare.
+ assert!(html.contains(""));
+ // comes before , per the HTML spec.
+ assert!(html.find("").unwrap() < html.find("").unwrap());
}
#[test]
diff --git a/src/writer/mod.rs b/src/writer/mod.rs
index c19b040a..fdfff832 100644
--- a/src/writer/mod.rs
+++ b/src/writer/mod.rs
@@ -29,7 +29,7 @@
//! without knowing which writer they picked.
use crate::reader::ResolvedSpec;
-use crate::{DataFrame, GgsqlError, Plot, Result, TableCell};
+use crate::{DataFrame, GgsqlError, Plot, Result, TableCell, TableColumn, TableRow};
use std::collections::HashMap;
pub mod options;
@@ -174,20 +174,27 @@ pub trait Writer {
/// Unlike `write_plot`, there is no AST parameter: `Table` (the parsed
/// `TABULATE` spec) has nothing left that a writer needs by the time
/// `cells` exists — its only field (`source`) is already consumed
- /// building `cells`. If `Table` grows something a writer genuinely needs
- /// that isn't itself expressible as a cell, add it back then.
+ /// building `cells`. `columns`/`rows` cover a whole-column or whole-row
+ /// property (e.g. `width`) that can't be expressed as a per-cell value.
///
/// # Arguments
///
/// * `cells` - The resolved table layout — see `TableCell` for the
/// position/kind conventions
+ /// * `columns` - Resolved per-column properties, if any were built
+ /// * `rows` - Resolved per-row properties, if any were built
///
/// # Errors
///
/// Returns `GgsqlError::WriterError` if this writer doesn't support
/// tables, or output generation fails.
- fn write_table(&self, cells: &[TableCell]) -> Result {
- let _ = cells;
+ fn write_table(
+ &self,
+ cells: &[TableCell],
+ columns: Option<&[TableColumn]>,
+ rows: Option<&[TableRow]>,
+ ) -> Result {
+ let _ = (cells, columns, rows);
Err(GgsqlError::WriterError(
"this writer does not support tables".to_string(),
))
@@ -224,7 +231,9 @@ pub trait Writer {
fn render(&self, spec: &ResolvedSpec) -> Result {
match spec {
ResolvedSpec::Plot(plot) => self.write_plot(plot.plot(), plot.data()),
- ResolvedSpec::Table(table) => self.write_table(table.cells()),
+ ResolvedSpec::Table(table) => {
+ self.write_table(table.cells(), table.columns(), table.rows())
+ }
}
}
}
diff --git a/tree-sitter-ggsql/CLAUDE.md b/tree-sitter-ggsql/CLAUDE.md
index 02ad2b58..27601c9d 100644
--- a/tree-sitter-ggsql/CLAUDE.md
+++ b/tree-sitter-ggsql/CLAUDE.md
@@ -28,11 +28,11 @@ tree-sitter-ggsql/
└── corpus/ Tree-sitter test corpus (parser test cases)
```
-The files under `src/` are generated by `tree-sitter generate` from `grammar.js` — they are committed so downstream consumers don't need the tree-sitter CLI to build.
+The files under `src/` are generated by `tree-sitter generate` from `grammar.js` — they are gitignored, not committed. `bindings/rust/build.rs` regenerates them on every Rust build by default.
## Grammar at a glance
-`grammar.js` defines a `query` rule that is `optional(sql_portion) + repeat(choice(visualise_statement, tabulate_statement))`. The SQL portion is recognised structurally enough to know where it ends (statement boundaries, recursive subqueries, WITH compound statements) without re-implementing a SQL parser — the actual SQL is handed off to the configured `Reader`. The VISUALISE side is parsed in detail (clauses, layer types, mappings, settings, scales, facets, projections, labels) so [`/src/parser/builder.rs`](../src/parser/builder.rs) can build a typed AST from it. `tabulate_statement` (the plain-table counterpart to VISUALISE — a query result with no plot) is still a **work in progress**: it recognises the keyword, an optional `single_source_from` (the same single-source `FROM` rule VISUALISE uses), and a repeated `tab_clause` — `LABEL` and `SPAN`, in any order, the same "any order, repeated" shape `viz_clause` gives VISUALISE's own clauses. Only `LABEL` is wired into the typed `Table` AST by [`/src/parser/builder.rs`](../src/parser/builder.rs) so far — `SPAN` parses but isn't consumed yet. (Revisit this paragraph's level of detail once most TABULATE clauses exist — describing two clauses inline is fine for now, but won't scale the way VISUALISE's own clause list needed a dedicated table instead.)
+`grammar.js` defines a `query` rule that is `optional(sql_portion) + repeat(choice(visualise_statement, tabulate_statement))`. The SQL portion is recognised structurally enough to know where it ends (statement boundaries, recursive subqueries, WITH compound statements) without re-implementing a SQL parser — the actual SQL is handed off to the configured `Reader`. The VISUALISE side is parsed in detail (clauses, layer types, mappings, settings, scales, facets, projections, labels) so [`/src/parser/builder.rs`](../src/parser/builder.rs) can build a typed AST from it. `tabulate_statement` (the plain-table counterpart to VISUALISE — a query result with no plot) is parsed the same way, with a smaller clause set so far, so [`/src/parser/builder.rs`](../src/parser/builder.rs) can build a typed `Table` from it.
For ggsql language semantics, see [`/doc/syntax/`](../doc/syntax/) — this package only defines *how text is parsed*, not what the resulting tree means.
diff --git a/tree-sitter-ggsql/grammar.js b/tree-sitter-ggsql/grammar.js
index 2589905d..b2cc0db6 100644
--- a/tree-sitter-ggsql/grammar.js
+++ b/tree-sitter-ggsql/grammar.js
@@ -685,6 +685,17 @@ module.exports = grammar({
tab_clause: $ => choice(
$.label_clause,
$.span_clause,
+ $.format_clause,
+ ),
+
+ // FORMAT — configures cell formatting for a group of columns. Multiple
+ // FORMAT clauses repeat (FORMAT ... FORMAT ...) for different column
+ // groups, the same model SPAN uses.
+ format_clause: $ => seq(
+ caseInsensitive('FORMAT'),
+ $.column_list,
+ optional($.setting_clause),
+ optional($.renaming_clause)
),
// SPAN — groups columns under one spanner cell. Multiple spanners repeat
@@ -698,13 +709,13 @@ module.exports = grammar({
// Reuses label_assignment's value shape.
field('label', choice($.string, $.null_literal)),
caseInsensitive('ACROSS'),
- $.span_columns,
+ $.column_list,
optional($.setting_clause)
),
- // The group of columns this SPAN covers — same plain identifier-list
- // shape as partition_columns/facet_vars/project_aesthetics.
- span_columns: $ => seq(
+ // Shared comma-separated identifier list: SPAN's columns, PARTITION BY's
+ // columns, FACET's row/column vars, FORMAT's columns.
+ column_list: $ => seq(
$.identifier,
repeat(seq(',', $.identifier))
),
@@ -843,12 +854,7 @@ module.exports = grammar({
partition_clause: $ => seq(
caseInsensitive('PARTITION'),
caseInsensitive('BY'),
- $.partition_columns
- ),
-
- partition_columns: $ => seq(
- $.identifier,
- repeat(seq(',', $.identifier))
+ $.column_list
),
// FILTER clause for layer filtering: FILTER
@@ -998,12 +1004,12 @@ module.exports = grammar({
optional($.scale_to_clause),
optional($.scale_via_clause),
optional($.setting_clause), // reuse existing setting_clause from DRAW
- optional($.scale_renaming_clause) // custom label mappings
+ optional($.renaming_clause) // custom label mappings
),
- // RENAMING clause for custom axis/legend labels
- // Syntax: RENAMING 'A' => 'Alpha', 'B' => 'Beta', 'C' => NULL
- scale_renaming_clause: $ => seq(
+ // RENAMING clause: SCALE uses it for custom axis/legend labels, FORMAT
+ // for custom cell labels. Syntax: RENAMING 'A' => 'Alpha', 'B' => 'Beta', 'C' => NULL
+ renaming_clause: $ => seq(
caseInsensitive('RENAMING'),
$.renaming_assignment,
repeat(seq(',', $.renaming_assignment))
@@ -1054,21 +1060,16 @@ module.exports = grammar({
// Single variable = wrap layout, BY clause = grid layout
facet_clause: $ => seq(
caseInsensitive('FACET'),
- $.facet_vars,
+ $.column_list,
optional(seq(
alias(caseInsensitive('BY'), $.facet_by),
- $.facet_vars
+ $.column_list
)),
optional($.setting_clause) // Reuse from DRAW/SCALE
),
facet_by: $ => 'BY',
- facet_vars: $ => seq(
- $.identifier,
- repeat(seq(',', $.identifier))
- ),
-
// PROJECT clause - PROJECT [aesthetics] TO coord_type [SETTING prop => value, ...]
// Examples:
// PROJECT TO cartesian (defaults to x, y)
@@ -1085,7 +1086,9 @@ module.exports = grammar({
optional(seq(caseInsensitive('SETTING'), $.project_properties))
),
- // Optional list of position aesthetic names for PROJECT clause
+ // Optional list of position aesthetic names for PROJECT clause. Kept
+ // separate from column_list even though the grammar shape is identical:
+ // this names aesthetics (x, y, angle, radius, ...), not columns.
project_aesthetics: $ => seq(
$.identifier,
repeat(seq(',', $.identifier))
diff --git a/tree-sitter-ggsql/test/corpus/basic.txt b/tree-sitter-ggsql/test/corpus/basic.txt
index 8afc0403..c08441de 100644
--- a/tree-sitter-ggsql/test/corpus/basic.txt
+++ b/tree-sitter-ggsql/test/corpus/basic.txt
@@ -1281,7 +1281,7 @@ DRAW line PARTITION BY category
(draw_clause
(geom_type)
(partition_clause
- (partition_columns
+ (column_list
(identifier
(bare_identifier))))))))
@@ -1317,7 +1317,7 @@ DRAW line PARTITION BY category, region
(draw_clause
(geom_type)
(partition_clause
- (partition_columns
+ (column_list
(identifier
(bare_identifier))
(identifier
@@ -1369,7 +1369,7 @@ DRAW line SETTING opacity => 0.5 FILTER year > 2020 PARTITION BY category
(filter_token
(number))))
(partition_clause
- (partition_columns
+ (column_list
(identifier
(bare_identifier))))))))
@@ -2013,7 +2013,7 @@ DRAW line PARTITION BY category ORDER BY date ASC
(draw_clause
(geom_type)
(partition_clause
- (partition_columns
+ (column_list
(identifier
(bare_identifier))))
(order_clause
@@ -2069,7 +2069,7 @@ DRAW line SETTING opacity => 0.5 FILTER year > 2020 PARTITION BY region ORDER BY
(filter_token
(number))))
(partition_clause
- (partition_columns
+ (column_list
(identifier
(bare_identifier))))
(order_clause
@@ -2593,7 +2593,7 @@ SCALE DISCRETE x RENAMING 'A' => 'Alpha', 'B' => 'Beta'
(scale_clause
(scale_type_identifier)
(aesthetic_name)
- (scale_renaming_clause
+ (renaming_clause
(renaming_assignment
name: (string)
value: (string))
@@ -2631,7 +2631,7 @@ SCALE DISCRETE x RENAMING 'internal' => NULL
(scale_clause
(scale_type_identifier)
(aesthetic_name)
- (scale_renaming_clause
+ (renaming_clause
(renaming_assignment
name: (string)
value: (null_literal)))))))
@@ -2666,7 +2666,7 @@ SCALE CONTINUOUS x RENAMING * => '{} units'
(scale_clause
(scale_type_identifier)
(aesthetic_name)
- (scale_renaming_clause
+ (renaming_clause
(renaming_assignment
value: (string)))))))
@@ -2700,7 +2700,7 @@ SCALE DISCRETE x RENAMING 'A' => 'Alpha', * => 'Category {}'
(scale_clause
(scale_type_identifier)
(aesthetic_name)
- (scale_renaming_clause
+ (renaming_clause
(renaming_assignment
name: (string)
value: (string))
@@ -2911,7 +2911,7 @@ FACET region
(geom_type)))
(viz_clause
(facet_clause
- (facet_vars
+ (column_list
(identifier
(bare_identifier)))))))
@@ -2949,11 +2949,11 @@ FACET region BY category
(geom_type)))
(viz_clause
(facet_clause
- (facet_vars
+ (column_list
(identifier
(bare_identifier)))
(facet_by)
- (facet_vars
+ (column_list
(identifier
(bare_identifier)))))))
@@ -2991,7 +2991,7 @@ FACET region SETTING scales => 'free_y', ncol => 3
(geom_type)))
(viz_clause
(facet_clause
- (facet_vars
+ (column_list
(identifier
(bare_identifier)))
(setting_clause
@@ -4611,7 +4611,7 @@ TABULATE FROM sales SPAN 'Pretty Name' ACROSS foo, bar, baz
(tab_clause
(span_clause
label: (string)
- (span_columns
+ (column_list
(identifier
(bare_identifier))
(identifier
@@ -4637,7 +4637,7 @@ TABULATE FROM sales SPAN 'A' ACROSS foo
(tab_clause
(span_clause
label: (string)
- (span_columns
+ (column_list
(identifier
(bare_identifier)))))))
@@ -4659,7 +4659,7 @@ TABULATE FROM sales SPAN NULL ACROSS foo, bar
(tab_clause
(span_clause
label: (null_literal)
- (span_columns
+ (column_list
(identifier
(bare_identifier))
(identifier
@@ -4683,7 +4683,7 @@ TABULATE FROM sales SPAN 'W' ACROSS foo SETTING width => '40%'
(tab_clause
(span_clause
label: (string)
- (span_columns
+ (column_list
(identifier
(bare_identifier)))
(setting_clause
@@ -4719,8 +4719,42 @@ TABULATE FROM sales LABEL id => 'ID' SPAN 'A' ACROSS foo, bar
(tab_clause
(span_clause
label: (string)
- (span_columns
+ (column_list
(identifier
(bare_identifier))
(identifier
(bare_identifier)))))))
+
+================================================================================
+TABULATE FORMAT clause
+================================================================================
+
+TABULATE FROM sales FORMAT foo, bar SETTING width => '20%' RENAMING null => '-'
+
+--------------------------------------------------------------------------------
+
+(query
+ (tabulate_statement
+ (tabulate_keyword)
+ (single_source_from
+ source: (qualified_name
+ (identifier
+ (bare_identifier))))
+ (tab_clause
+ (format_clause
+ (column_list
+ (identifier
+ (bare_identifier))
+ (identifier
+ (bare_identifier)))
+ (setting_clause
+ (parameter_assignment
+ name: (parameter_name
+ (identifier
+ (bare_identifier)))
+ value: (parameter_value
+ (string))))
+ (renaming_clause
+ (renaming_assignment
+ name: (null_literal)
+ value: (string)))))))
|---|
|