Line data    Source code

       1              : //! EXPLAIN and CALL 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          135 :     pub(super) fn format_explain(&self, node_id: usize) -> FmtReg {
       9          135 :         let f = &self.fmt;
      10          135 :         let node: &'a Node = &self.ast[node_id];
      11          135 :         let [statement, options] = attrs!(self.children(node), [K::EXT_EXPLAIN_STATEMENT, K::EXT_EXPLAIN_OPTIONS]);
      12          135 :         let Some(statement) = statement else { return self.format_unimplemented(node) };
      13          135 :         let stmt_reg = self.reg(statement);
      14          135 :         if stmt_reg == 0 {
      15            0 :             return self.format_unimplemented(node);
      16          135 :         }
      17          135 :         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           51 :         }
      25           51 :         f.concat(&[f.text("explain "), stmt_reg])
      26          135 :     }
      27              : 
      28              :     /// `call <name> (<args>)`, with one argument per line if they don't fit on one
      29          106 :     pub(super) fn format_call(&self, node: &'a Node) -> FmtReg {
      30          106 :         let f = &self.fmt;
      31          106 :         let [name, args] = attrs!(self.children(node), [K::SQL_CALL_NAME, K::SQL_CALL_ARGS]);
      32          106 :         let Some(name) = name else { return self.format_unimplemented(node) };
      33          106 :         let name_reg = self.reg(name);
      34          106 :         if name_reg == 0 {
      35            0 :             return self.format_unimplemented(node);
      36          106 :         }
      37          106 :         let Some(args) = args else { return f.concat(&[f.text("call "), name_reg, f.text(" ()")]) };
      38           91 :         let args_reg = self.reg(args);
      39           91 :         if args_reg == 0 {
      40            0 :             return self.format_unimplemented(node);
      41           91 :         }
      42           91 :         f.concat(&[f.text("call "), name_reg, f.text(" "), f.parenthesized_list(args_reg)])
      43          106 :     }
      44              : 
      45            9 :     pub(super) fn format_explain_expressions(&self, node: &'a Node) -> FmtReg {
      46            9 :         let f = &self.fmt;
      47            9 :         let [expressions] = attrs!(self.children(node), [K::EXT_EXPLAIN_EXPRESSIONS]);
      48            9 :         let Some(expressions) = expressions else { return self.format_unimplemented(node) };
      49            9 :         let expressions_reg = self.reg(expressions);
      50            9 :         if expressions_reg == 0 {
      51            0 :             return self.format_unimplemented(node);
      52            9 :         }
      53            9 :         f.concat(&[f.text("expressions "), f.parenthesized(expressions_reg)])
      54            9 :     }
      55              : }