Line data    Source code

       1              : //! EXPLAIN statements.
       2              : 
       3              : use dashql_parser::attrs;
       4              : use super::{FmtReg, Formatter, FormattingJoinPolicy, K};
       5              : use dashql_buffers::parser::Node;
       6              : 
       7              : impl<'a> Formatter<'a> {
       8          126 :     pub(super) fn format_explain(&self, node_id: usize) -> FmtReg {
       9          126 :         let f = &self.fmt;
      10          126 :         let node: &'a Node = &self.ast[node_id];
      11          126 :         let [statement, options] = attrs!(self.children(node), [K::EXT_EXPLAIN_STATEMENT, K::EXT_EXPLAIN_OPTIONS]);
      12          126 :         let Some(statement) = statement else { return self.format_unimplemented(node) };
      13          126 :         let stmt_reg = self.reg(statement);
      14          126 :         if stmt_reg == 0 {
      15            0 :             return self.format_unimplemented(node);
      16          126 :         }
      17          126 :         if let Some(options) = options.filter(|o| o.children_count() > 0) {
      18           84 :             let options_reg = self.reg(options);
      19           84 :             if options_reg == 0 {
      20            0 :                 return self.format_unimplemented(node);
      21           84 :             }
      22           84 :             let header = f.concat(&[f.text("explain "), f.parenthesized(options_reg)]);
      23           84 :             return self.space_join(&[header, stmt_reg], FormattingJoinPolicy::ForceBreak, false);
      24           42 :         }
      25           42 :         f.concat(&[f.text("explain "), stmt_reg])
      26          126 :     }
      27              : 
      28            9 :     pub(super) fn format_explain_expressions(&self, node: &'a Node) -> FmtReg {
      29            9 :         let f = &self.fmt;
      30            9 :         let [expressions] = attrs!(self.children(node), [K::EXT_EXPLAIN_EXPRESSIONS]);
      31            9 :         let Some(expressions) = expressions else { return self.format_unimplemented(node) };
      32            9 :         let expressions_reg = self.reg(expressions);
      33            9 :         if expressions_reg == 0 {
      34            0 :             return self.format_unimplemented(node);
      35            9 :         }
      36            9 :         f.concat(&[f.text("expressions "), f.parenthesized(expressions_reg)])
      37            9 :     }
      38              : }