diff --git a/crates/squawk_fmt/src/fmt.rs b/crates/squawk_fmt/src/fmt.rs
index 35c0c4f8..ab075f74 100644
--- a/crates/squawk_fmt/src/fmt.rs
+++ b/crates/squawk_fmt/src/fmt.rs
@@ -94,12 +94,7 @@ fn build_commit<'a>(commit: ast::Commit) -> Doc<'a> {
                     .append(Doc::text("prepared"));
             }
             if let Some(literal) = commit.literal() {
-                doc = doc.append(
-                    Doc::line_or_space()
-                        .append(leading_comments(literal.syntax()))
-                        .append(build_literal(literal))
-                        .nest(2),
-                );
+                doc = append_nested_node(doc, literal, build_literal);
             }
             doc.group()
                 .append(build_semicolon(commit.semicolon_token()))
@@ -143,12 +138,7 @@ fn build_rollback<'a>(rollback: ast::Rollback) -> Doc<'a> {
                     .append(Doc::text("prepared"));
             }
             if let Some(literal) = rollback.literal() {
-                doc = doc.append(
-                    Doc::line_or_space()
-                        .append(leading_comments(literal.syntax()))
-                        .append(build_literal(literal))
-                        .nest(2),
-                );
+                doc = append_nested_node(doc, literal, build_literal);
             }
             doc.group()
                 .append(build_semicolon(rollback.semicolon_token()))
@@ -264,12 +254,7 @@ fn build_prepare_transaction<'a>(prepare: &ast::PrepareTransaction) -> Doc<'a> {
             .append(Doc::text("transaction"));
     }
     if let Some(literal) = prepare.literal() {
-        doc = doc.append(
-            Doc::line_or_space()
-                .append(leading_comments(literal.syntax()))
-                .append(build_literal(literal))
-                .nest(2),
-        );
+        doc = append_nested_node(doc, literal, build_literal);
     }
     doc.group()
         .append(build_semicolon(prepare.semicolon_token()))
@@ -322,14 +307,7 @@ fn build_insert<'a>(insert: &ast::Insert) -> Doc<'a> {
             .append(leading_comments_token(&into_token))
             .append(Doc::text("into"));
     }
-    if let Some(relation) = insert.relation_name_ref() {
-        doc = doc
-            .append(Doc::space())
-            .append(leading_comments(relation.syntax()));
-        if let Some(path) = relation.path_ref() {
-            doc = doc.append(build_path_ref(&path));
-        }
-    }
+    doc = append_commented_path_ref(doc, insert.relation_name_ref());
     if let Some(alias) = insert.alias() {
         doc = doc
             .append(Doc::space())
@@ -463,12 +441,7 @@ fn build_on_conflict_clause<'a>(on_conflict: ast::OnConflictClause) -> Doc<'a> {
             .append(build_conflict_target(target));
     }
     if let Some(action) = on_conflict.conflict_action() {
-        doc = doc.append(
-            Doc::line_or_space()
-                .append(leading_comments(action.syntax()))
-                .append(build_conflict_action(action))
-                .nest(2),
-        );
+        doc = append_nested_node(doc, action, build_conflict_action);
     }
     doc.group()
 }
@@ -483,15 +456,7 @@ fn build_conflict_target<'a>(target: ast::ConflictTarget) -> Doc<'a> {
                     .append(leading_comments_token(&token))
                     .append(Doc::text("constraint"));
             }
-            if let Some(name) = constraint.constraint_name_ref() {
-                doc = doc
-                    .append(Doc::space())
-                    .append(leading_comments(name.syntax()));
-                if let Some(path) = name.path_ref() {
-                    doc = doc.append(build_path_ref(&path));
-                }
-            }
-            doc
+            append_commented_path_ref(doc, constraint.constraint_name_ref())
         }
         ast::ConflictTarget::ConflictOnIndex(index) => {
             let mut doc = index
@@ -531,20 +496,12 @@ fn build_conflict_index_item_list<'a>(items: ast::ConflictIndexItemList) -> Doc<
 }
 
 fn build_conflict_index_item<'a>(item: ast::ConflictIndexItem) -> Doc<'a> {
-    let mut doc = if let Some(collate) = item.collate() {
+    let doc = if let Some(collate) = item.collate() {
         build_collate_expr(collate)
     } else {
         item.expr().map(build_expr).unwrap_or_else(Doc::nil)
     };
-    if let Some(op_class) = item.op_class_ref() {
-        doc = doc
-            .append(Doc::space())
-            .append(leading_comments(op_class.syntax()));
-        if let Some(path) = op_class.path_ref() {
-            doc = doc.append(build_path_ref(&path));
-        }
-    }
-    doc
+    append_commented_path_ref(doc, item.op_class_ref())
 }
 
 fn build_conflict_action<'a>(action: ast::ConflictAction) -> Doc<'a> {
@@ -1094,12 +1051,7 @@ fn build_merge_when_not_matched_prefix<'a>(
 fn build_merge_condition<'a>(condition: ast::MergeCondition) -> Doc<'a> {
     let mut doc = Doc::text("and");
     if let Some(expr) = condition.expr() {
-        doc = doc.append(
-            Doc::line_or_space()
-                .append(leading_comments(expr.syntax()))
-                .append(build_expr(expr))
-                .nest(2),
-        );
+        doc = append_nested_node(doc, expr, build_expr);
     }
     doc
 }
@@ -1458,12 +1410,7 @@ fn build_truncate<'a>(truncate: &ast::Truncate) -> Doc<'a> {
             )
             .collect(),
         );
-        doc = doc.append(
-            Doc::line_or_space()
-                .append(leading_comments(table_list.syntax()))
-                .append(tables)
-                .nest(2),
-        );
+        doc = append_nested_clause(doc, table_list.syntax(), tables);
     }
 
     if let Some(identity_action) = truncate.identity_action() {
@@ -1605,12 +1552,7 @@ fn build_create_trigger<'a>(stmt: &ast::CreateTrigger) -> Doc<'a> {
     if let Some(referencing) = stmt.referencing() {
         let mut clause = Doc::text("referencing");
         for table in referencing.referencing_tables() {
-            clause = clause.append(
-                Doc::line_or_space()
-                    .append(leading_comments(table.syntax()))
-                    .append(build_referencing_table(table))
-                    .nest(2),
-            );
+            clause = append_nested_node(clause, table, build_referencing_table);
         }
         doc = doc.append(
             Doc::hard_line()
@@ -1784,12 +1726,7 @@ fn build_create_transform<'a>(stmt: &ast::CreateTransform) -> Doc<'a> {
             .append(Doc::text("for"));
     }
     if let Some(ty) = stmt.ty() {
-        doc = doc.append(
-            Doc::line_or_space()
-                .append(leading_comments(ty.syntax()))
-                .append(build_type(ty))
-                .nest(2),
-        );
+        doc = append_nested_node(doc, ty, build_type);
     }
     if let Some(language) = stmt.language_token() {
         doc = doc.append(
@@ -1927,6 +1864,14 @@ fn build_function_param_list<'a>(params: ast::ParamList) -> Doc<'a> {
         .map(comments_before)
         .unwrap_or_else(Doc::nil)
         .append(Doc::text("("));
+    let is_empty = params.star_token().is_none()
+        && params.params().next().is_none()
+        && params
+            .r_paren_token()
+            .is_none_or(|r_paren| comment_tokens_before(r_paren).is_empty());
+    if is_empty {
+        return doc.append(Doc::text(")"));
+    }
     let mut body = if let Some(star) = params.star_token() {
         leading_comments_token(&star).append(Doc::text("*"))
     } else {
@@ -2083,13 +2028,8 @@ fn build_function_option<'a>(option: ast::FuncOption) -> Doc<'a> {
                     .append(Doc::space())
                     .append(leading_comments_token(&all))
                     .append(Doc::text("all"));
-            } else if let Some(parameter) = option.config_parameter_ref() {
-                doc = doc
-                    .append(Doc::space())
-                    .append(leading_comments(parameter.syntax()));
-                if let Some(path) = parameter.path_ref() {
-                    doc = doc.append(build_path_ref(&path));
-                }
+            } else {
+                doc = append_commented_path_ref(doc, option.config_parameter_ref());
             }
             doc
         }
@@ -2101,16 +2041,8 @@ fn build_function_option<'a>(option: ast::FuncOption) -> Doc<'a> {
             .map(|set| build_set_config_param(&set))
             .unwrap_or_else(Doc::nil),
         ast::FuncOption::SupportFuncOption(option) => {
-            let mut doc = Doc::text("support");
-            if let Some(function) = option.function_name_ref() {
-                doc = doc
-                    .append(Doc::space())
-                    .append(leading_comments(function.syntax()));
-                if let Some(path) = function.path_ref() {
-                    doc = doc.append(build_path_ref(&path));
-                }
-            }
-            doc
+            let doc = Doc::text("support");
+            append_commented_path_ref(doc, option.function_name_ref())
         }
         ast::FuncOption::TransformFuncOption(option) => {
             let transforms = option.transform_for_types().map(|transform| {
@@ -2190,14 +2122,7 @@ fn build_atomic_body<'a>(options: ast::AtomicBody) -> Doc<'a> {
 
 fn build_call<'a>(call: &ast::Call) -> Doc<'a> {
     let mut doc = Doc::text("call");
-    if let Some(procedure) = call.procedure_name_ref() {
-        doc = doc
-            .append(Doc::space())
-            .append(leading_comments(procedure.syntax()));
-        if let Some(path) = procedure.path_ref() {
-            doc = doc.append(build_path_ref(&path));
-        }
-    }
+    doc = append_commented_path_ref(doc, call.procedure_name_ref());
     if let Some(args) = call.arg_list() {
         doc = doc
             .append(comments_before(args.syntax().clone()))
@@ -2284,12 +2209,7 @@ fn build_declare<'a>(declare: &ast::Declare) -> Doc<'a> {
     let mut doc = Doc::text("declare");
 
     if let Some(cursor) = declare.cursor() {
-        doc = doc.append(
-            Doc::line_or_space()
-                .append(leading_comments(cursor.syntax()))
-                .append(build_name(cursor.syntax()))
-                .nest(2),
-        );
+        doc = append_nested_clause(doc, cursor.syntax(), build_name(cursor.syntax()));
     }
     if let Some(binary) = declare.binary_token() {
         doc = doc.append(
@@ -2300,20 +2220,14 @@ fn build_declare<'a>(declare: &ast::Declare) -> Doc<'a> {
         );
     }
     if let Some(sensitivity) = declare.cursor_sensitivity() {
-        doc = doc.append(
-            Doc::line_or_space()
-                .append(leading_comments(sensitivity.syntax()))
-                .append(build_keyword_node(sensitivity.syntax()))
-                .nest(2),
+        doc = append_nested_clause(
+            doc,
+            sensitivity.syntax(),
+            build_keyword_node(sensitivity.syntax()),
         );
     }
     if let Some(scroll) = declare.cursor_scroll() {
-        doc = doc.append(
-            Doc::line_or_space()
-                .append(leading_comments(scroll.syntax()))
-                .append(build_keyword_node(scroll.syntax()))
-                .nest(2),
-        );
+        doc = append_nested_clause(doc, scroll.syntax(), build_keyword_node(scroll.syntax()));
     }
     if let Some(cursor) = declare.cursor_token() {
         doc = doc.append(
@@ -2324,12 +2238,7 @@ fn build_declare<'a>(declare: &ast::Declare) -> Doc<'a> {
         );
     }
     if let Some(hold) = declare.cursor_hold() {
-        doc = doc.append(
-            Doc::line_or_space()
-                .append(leading_comments(hold.syntax()))
-                .append(build_keyword_node(hold.syntax()))
-                .nest(2),
-        );
+        doc = append_nested_clause(doc, hold.syntax(), build_keyword_node(hold.syntax()));
     }
     doc = doc.group();
 
@@ -2365,28 +2274,13 @@ fn build_lock<'a>(lock: &ast::Lock) -> Doc<'a> {
             .append(Doc::text("table"));
     }
     if let Some(relations) = lock.relation_list() {
-        doc = doc.append(
-            Doc::line_or_space()
-                .append(leading_comments(relations.syntax()))
-                .append(build_lock_relation_list(relations))
-                .nest(2),
-        );
+        doc = append_nested_node(doc, relations, build_lock_relation_list);
     }
     if let Some(mode) = lock.lock_mode_clause() {
-        doc = doc.append(
-            Doc::line_or_space()
-                .append(leading_comments(mode.syntax()))
-                .append(build_lock_mode_clause(mode))
-                .nest(2),
-        );
+        doc = append_nested_node(doc, mode, build_lock_mode_clause);
     }
     if let Some(nowait) = lock.nowait() {
-        doc = doc.append(
-            Doc::line_or_space()
-                .append(leading_comments(nowait.syntax()))
-                .append(build_keyword_node(nowait.syntax()))
-                .nest(2),
-        );
+        doc = append_nested_clause(doc, nowait.syntax(), build_keyword_node(nowait.syntax()));
     }
     doc.group().append(build_semicolon(lock.semicolon_token()))
 }
@@ -2427,12 +2321,7 @@ fn build_reindex<'a>(reindex: &ast::Reindex) -> Doc<'a> {
             .append(build_reindex_option_list(options));
     }
     if let Some(target) = reindex.reindex_target() {
-        doc = doc.append(
-            Doc::line_or_space()
-                .append(leading_comments(target.syntax()))
-                .append(build_reindex_target(target))
-                .nest(2),
-        );
+        doc = append_nested_node(doc, target, build_reindex_target);
     }
     doc.group()
         .append(build_semicolon(reindex.semicolon_token()))
@@ -2607,12 +2496,7 @@ fn build_reset<'a>(reset: &ast::Reset) -> Doc<'a> {
 fn build_load<'a>(load: &ast::Load) -> Doc<'a> {
     let mut doc = Doc::text("load");
     if let Some(literal) = load.literal() {
-        doc = doc.append(
-            Doc::line_or_space()
-                .append(leading_comments(literal.syntax()))
-                .append(build_literal(literal))
-                .nest(2),
-        );
+        doc = append_nested_node(doc, literal, build_literal);
     }
     doc.group().append(build_semicolon(load.semicolon_token()))
 }
@@ -2620,12 +2504,7 @@ fn build_load<'a>(load: &ast::Load) -> Doc<'a> {
 fn build_discard<'a>(discard: &ast::Discard) -> Doc<'a> {
     let mut doc = Doc::text("discard");
     if let Some(target) = discard.discard_target() {
-        doc = doc.append(
-            Doc::line_or_space()
-                .append(leading_comments(target.syntax()))
-                .append(build_keyword_node(target.syntax()))
-                .nest(2),
-        );
+        doc = append_nested_clause(doc, target.syntax(), build_keyword_node(target.syntax()));
     }
     doc.group()
         .append(build_semicolon(discard.semicolon_token()))
@@ -2634,12 +2513,7 @@ fn build_discard<'a>(discard: &ast::Discard) -> Doc<'a> {
 fn build_fetch<'a>(fetch: &ast::Fetch) -> Doc<'a> {
     let mut doc = Doc::text("fetch");
     if let Some(action) = fetch.cursor_action() {
-        doc = doc.append(
-            Doc::line_or_space()
-                .append(leading_comments(action.syntax()))
-                .append(build_cursor_action(action))
-                .nest(2),
-        );
+        doc = append_nested_node(doc, action, build_cursor_action);
     }
     if let Some(token) = fetch.from_token().or_else(|| fetch.in_token()) {
         let keyword = if token.kind() == SyntaxKind::FROM_KW {
@@ -2655,12 +2529,7 @@ fn build_fetch<'a>(fetch: &ast::Fetch) -> Doc<'a> {
         );
     }
     if let Some(cursor) = fetch.cursor_ref() {
-        doc = doc.append(
-            Doc::line_or_space()
-                .append(leading_comments(cursor.syntax()))
-                .append(build_name(cursor.syntax()))
-                .nest(2),
-        );
+        doc = append_nested_clause(doc, cursor.syntax(), build_name(cursor.syntax()));
     }
     doc.group().append(build_semicolon(fetch.semicolon_token()))
 }
@@ -2740,12 +2609,7 @@ fn build_cluster<'a>(cluster: &ast::Cluster) -> Doc<'a> {
             .append(leading_comments_token(&verbose))
             .append(Doc::text("verbose"));
     } else if let Some(options) = cluster.option_item_list() {
-        doc = doc.append(
-            Doc::line_or_space()
-                .append(leading_comments(options.syntax()))
-                .append(build_option_item_list(options))
-                .nest(2),
-        );
+        doc = append_nested_node(doc, options, build_option_item_list);
     }
 
     if let Some(table) = cluster.table_name_ref() {
@@ -2761,12 +2625,7 @@ fn build_cluster<'a>(cluster: &ast::Cluster) -> Doc<'a> {
                 .append(build_cluster_using_index(using_index));
         }
     } else if let Some(legacy) = cluster.cluster_legacy() {
-        doc = doc.append(
-            Doc::line_or_space()
-                .append(leading_comments(legacy.syntax()))
-                .append(build_cluster_legacy(legacy))
-                .nest(2),
-        );
+        doc = append_nested_node(doc, legacy, build_cluster_legacy);
     }
 
     doc.group()
@@ -2774,16 +2633,8 @@ fn build_cluster<'a>(cluster: &ast::Cluster) -> Doc<'a> {
 }
 
 fn build_cluster_using_index<'a>(using_index: ast::ClusterUsingIndex) -> Doc<'a> {
-    let mut doc = Doc::text("using");
-    if let Some(index) = using_index.index_ref() {
-        doc = doc
-            .append(Doc::space())
-            .append(leading_comments(index.syntax()));
-        if let Some(path) = index.path_ref() {
-            doc = doc.append(build_path_ref(&path));
-        }
-    }
-    doc
+    let doc = Doc::text("using");
+    append_commented_path_ref(doc, using_index.index_ref())
 }
 
 fn build_cluster_legacy<'a>(legacy: ast::ClusterLegacy) -> Doc<'a> {
@@ -2799,14 +2650,7 @@ fn build_cluster_legacy<'a>(legacy: ast::ClusterLegacy) -> Doc<'a> {
             .append(Doc::line_or_space())
             .append(leading_comments(on_path.syntax()))
             .append(Doc::text("on"));
-        if let Some(table) = on_path.table_name_ref() {
-            doc = doc
-                .append(Doc::space())
-                .append(leading_comments(table.syntax()));
-            if let Some(path) = table.path_ref() {
-                doc = doc.append(build_path_ref(&path));
-            }
-        }
+        doc = append_commented_path_ref(doc, on_path.table_name_ref());
     }
     doc.group()
 }
@@ -2852,7 +2696,7 @@ fn build_option_item_value<'a>(value: ast::OptionItemValue) -> Doc<'a> {
     } else if let Some(name) = value.option_item_value_name() {
         build_keyword_node(name.syntax())
     } else {
-        Doc::text("default")
+        build_keyword_node(value.syntax())
     }
 }
 
@@ -2898,12 +2742,7 @@ fn build_analyze<'a>(analyze: &ast::Analyze) -> Doc<'a> {
             .append(build_analyze_option_list(options));
     }
     if let Some(tables) = analyze.table_and_columns_list() {
-        doc = doc.append(
-            Doc::line_or_space()
-                .append(leading_comments(tables.syntax()))
-                .append(build_table_and_columns_list(tables))
-                .nest(2),
-        );
+        doc = append_nested_node(doc, tables, build_table_and_columns_list);
     }
 
     doc.group()
@@ -2936,12 +2775,7 @@ fn build_vacuum<'a>(vacuum: &ast::Vacuum) -> Doc<'a> {
     }
 
     if let Some(tables) = vacuum.table_and_columns_list() {
-        doc = doc.append(
-            Doc::line_or_space()
-                .append(leading_comments(tables.syntax()))
-                .append(build_table_and_columns_list(tables))
-                .nest(2),
-        );
+        doc = append_nested_node(doc, tables, build_table_and_columns_list);
     }
 
     doc.group()
@@ -2988,12 +2822,8 @@ fn build_vacuum_option_value<'a>(value: ast::VacuumOptionValue) -> Doc<'a> {
         build_expr(expr)
     } else if let Some(name) = value.vacuum_option_value_name() {
         build_keyword_node(name.syntax())
-    } else if value.no_token().is_some() {
-        Doc::text("no")
-    } else if value.yes_token().is_some() {
-        Doc::text("yes")
     } else {
-        unreachable!("vacuum option value must have a value")
+        build_keyword_node(value.syntax())
     }
 }
 
@@ -3265,16 +3095,8 @@ fn build_copy_option_value<'a>(value: ast::CopyOptionValue) -> Doc<'a> {
         build_keyword_node(name.syntax())
     } else if let Some(expr) = value.expr() {
         build_expr(expr)
-    } else if value.star_token().is_some() {
-        Doc::text("*")
-    } else if value.default_token().is_some() {
-        Doc::text("default")
-    } else if value.on_token().is_some() {
-        Doc::text("on")
-    } else if value.off_token().is_some() {
-        Doc::text("off")
     } else {
-        unreachable!("copy option value must have a value")
+        build_keyword_node(value.syntax())
     }
 }
 
@@ -3542,25 +3364,14 @@ fn build_stmt<'a>(stmt: ast::Stmt) -> Doc<'a> {
 fn build_alter_view<'a>(stmt: &ast::AlterView) -> Doc<'a> {
     let mut doc =
         build_keyword_tokens([(stmt.alter_token(), "alter"), (stmt.view_token(), "view")]);
-    if let Some(if_exists) = stmt.if_exists() {
-        doc = doc
-            .append(Doc::space())
-            .append(leading_comments(if_exists.syntax()))
-            .append(build_if_exists(if_exists));
-    }
+    doc = append_if_exists(doc, stmt.if_exists());
     if let Some(view) = stmt.view_ref() {
         doc = doc
             .append(Doc::space())
             .append(build_extension_path_value(&view));
     }
     if let Some(action) = stmt.action() {
-        let syntax = action.syntax().clone();
-        doc = doc.append(
-            Doc::line_or_space()
-                .append(leading_comments(&syntax))
-                .append(build_alter_view_action(action))
-                .nest(2),
-        );
+        doc = append_nested_node(doc, action, build_alter_view_action);
     }
     doc.group().append(build_semicolon(stmt.semicolon_token()))
 }
@@ -3788,12 +3599,7 @@ fn build_create_cast<'a>(stmt: &ast::CreateCast) -> Doc<'a> {
                 (method.function_token(), "function"),
             ]),
         };
-        doc = doc.append(
-            Doc::line_or_space()
-                .append(leading_comments(&method_syntax))
-                .append(method_doc)
-                .nest(2),
-        );
+        doc = append_nested_clause(doc, &method_syntax, method_doc);
     }
     if let Some(context) = stmt.cast_context() {
         let context_syntax = context.syntax().clone();
@@ -3807,12 +3613,7 @@ fn build_create_cast<'a>(stmt: &ast::CreateCast) -> Doc<'a> {
                 (context.implicit_token(), "implicit"),
             ]),
         };
-        doc = doc.append(
-            Doc::line_or_space()
-                .append(leading_comments(&context_syntax))
-                .append(context_doc)
-                .nest(2),
-        );
+        doc = append_nested_clause(doc, &context_syntax, context_doc);
     }
     doc.group().append(build_semicolon(stmt.semicolon_token()))
 }
@@ -3822,16 +3623,7 @@ fn build_create_collation<'a>(stmt: &ast::CreateCollation) -> Doc<'a> {
         (stmt.create_token(), "create"),
         (stmt.collation_token(), "collation"),
     ]);
-    if let Some(if_not_exists) = stmt.if_not_exists() {
-        doc = doc
-            .append(Doc::space())
-            .append(leading_comments(if_not_exists.syntax()))
-            .append(build_keyword_tokens([
-                (if_not_exists.if_token(), "if"),
-                (if_not_exists.not_token(), "not"),
-                (if_not_exists.exists_token(), "exists"),
-            ]));
-    }
+    doc = append_if_not_exists(doc, stmt.if_not_exists());
     if let Some(collation) = stmt.collation() {
         let name = leading_comments(collation.syntax()).append(
             collation
@@ -3860,12 +3652,7 @@ fn build_create_collation<'a>(stmt: &ast::CreateCollation) -> Doc<'a> {
                         from_doc = from_doc.append(build_path_ref(&path));
                     }
                 }
-                doc = doc.append(
-                    Doc::line_or_space()
-                        .append(leading_comments(&definition_syntax))
-                        .append(from_doc.group())
-                        .nest(2),
-                );
+                doc = append_nested_clause(doc, &definition_syntax, from_doc.group());
             }
         }
     }
@@ -3941,12 +3728,7 @@ fn build_create_database<'a>(stmt: &ast::CreateDatabase) -> Doc<'a> {
     if let Some(options) = stmt.database_option_list()
         && (options.with_token().is_some() || options.database_options().next().is_some())
     {
-        doc = doc.append(
-            Doc::line_or_space()
-                .append(leading_comments(options.syntax()))
-                .append(build_database_option_list(options))
-                .nest(2),
-        );
+        doc = append_nested_node(doc, options, build_database_option_list);
     }
     doc.group().append(build_semicolon(stmt.semicolon_token()))
 }
@@ -3987,22 +3769,10 @@ fn build_create_domain<'a>(stmt: &ast::CreateDomain) -> Doc<'a> {
         );
     }
     if let Some(collate) = stmt.collate() {
-        let syntax = collate.syntax().clone();
-        doc = doc.append(
-            Doc::line_or_space()
-                .append(leading_comments(&syntax))
-                .append(build_collate_expr(collate))
-                .nest(2),
-        );
+        doc = append_nested_node(doc, collate, build_collate_expr);
     }
     for constraint in stmt.constraints() {
-        let syntax = constraint.syntax().clone();
-        doc = doc.append(
-            Doc::line_or_space()
-                .append(leading_comments(&syntax))
-                .append(build_domain_constraint(constraint))
-                .nest(2),
-        );
+        doc = append_nested_node(doc, constraint, build_domain_constraint);
     }
     doc.group().append(build_semicolon(stmt.semicolon_token()))
 }
@@ -4034,12 +3804,7 @@ fn build_create_event_trigger<'a>(stmt: &ast::CreateEventTrigger) -> Doc<'a> {
             .append(build_name(event.syntax()));
     }
     if let Some(when_clause) = stmt.event_trigger_when_clause() {
-        doc = doc.append(
-            Doc::line_or_space()
-                .append(leading_comments(when_clause.syntax()))
-                .append(build_event_trigger_when_clause(when_clause))
-                .nest(2),
-        );
+        doc = append_nested_node(doc, when_clause, build_event_trigger_when_clause);
     }
     let mut execute_clause = stmt
         .execute_token()
@@ -4140,16 +3905,7 @@ fn build_create_extension<'a>(stmt: &ast::CreateExtension) -> Doc<'a> {
         (stmt.create_token(), "create"),
         (stmt.extension_token(), "extension"),
     ]);
-    if let Some(if_not_exists) = stmt.if_not_exists() {
-        doc = doc
-            .append(Doc::space())
-            .append(leading_comments(if_not_exists.syntax()))
-            .append(build_keyword_tokens([
-                (if_not_exists.if_token(), "if"),
-                (if_not_exists.not_token(), "not"),
-                (if_not_exists.exists_token(), "exists"),
-            ]));
-    }
+    doc = append_if_not_exists(doc, stmt.if_not_exists());
     if let Some(extension) = stmt.extension() {
         doc = doc
             .append(Doc::space())
@@ -4175,12 +3931,7 @@ fn build_create_extension<'a>(stmt: &ast::CreateExtension) -> Doc<'a> {
                 .append(leading_comments(name.syntax()))
                 .append(build_name(name.syntax()));
         }
-        doc = doc.append(
-            Doc::line_or_space()
-                .append(leading_comments(schema.syntax()))
-                .append(clause)
-                .nest(2),
-        );
+        doc = append_nested_clause(doc, schema.syntax(), clause);
     }
     if let Some(version) = stmt.extension_version_clause() {
         let mut clause = version
@@ -4198,12 +3949,7 @@ fn build_create_extension<'a>(stmt: &ast::CreateExtension) -> Doc<'a> {
                 .append(leading_comments(value.syntax()))
                 .append(build_name(value.syntax()));
         }
-        doc = doc.append(
-            Doc::line_or_space()
-                .append(leading_comments(version.syntax()))
-                .append(clause)
-                .nest(2),
-        );
+        doc = append_nested_clause(doc, version.syntax(), clause);
     }
     if let Some(cascade_token) = stmt.cascade_token() {
         doc = doc.append(
@@ -4230,20 +3976,10 @@ fn build_create_foreign_data_wrapper<'a>(stmt: &ast::CreateForeignDataWrapper) -
             .append(build_name(name.syntax()));
     }
     if let Some(options) = stmt.fdw_option_list() {
-        doc = doc.append(
-            Doc::line_or_space()
-                .append(leading_comments(options.syntax()))
-                .append(build_create_fdw_option_list(options))
-                .nest(2),
-        );
+        doc = append_nested_node(doc, options, build_create_fdw_option_list);
     }
     if let Some(options) = stmt.alter_option_list() {
-        doc = doc.append(
-            Doc::line_or_space()
-                .append(leading_comments(options.syntax()))
-                .append(build_alter_option_list(&options))
-                .nest(2),
-        );
+        doc = append_nested_clause(doc, options.syntax(), build_alter_option_list(&options));
     }
     doc.group().append(build_semicolon(stmt.semicolon_token()))
 }
@@ -4658,20 +4394,10 @@ fn build_create_property_graph<'a>(stmt: &ast::CreatePropertyGraph) -> Doc<'a> {
             .append(graph_doc);
     }
     if let Some(tables) = stmt.vertex_tables() {
-        doc = doc.append(
-            Doc::line_or_space()
-                .append(leading_comments(tables.syntax()))
-                .append(build_vertex_tables(tables))
-                .nest(2),
-        );
+        doc = append_nested_node(doc, tables, build_vertex_tables);
     }
     if let Some(tables) = stmt.edge_tables() {
-        doc = doc.append(
-            Doc::line_or_space()
-                .append(leading_comments(tables.syntax()))
-                .append(build_edge_tables(tables))
-                .nest(2),
-        );
+        doc = append_nested_node(doc, tables, build_edge_tables);
     }
     doc.group().append(build_semicolon(stmt.semicolon_token()))
 }
@@ -4720,12 +4446,7 @@ fn build_create_role<'a>(stmt: &ast::CreateRole) -> Doc<'a> {
             .append(build_name(role.syntax()));
     }
     if let Some(options) = stmt.role_option_list() {
-        doc = doc.append(
-            Doc::line_or_space()
-                .append(leading_comments(options.syntax()))
-                .append(build_role_option_list(&options))
-                .nest(2),
-        );
+        doc = append_nested_clause(doc, options.syntax(), build_role_option_list(&options));
     }
     doc.group().append(build_semicolon(stmt.semicolon_token()))
 }
@@ -4740,12 +4461,7 @@ fn build_create_user<'a>(stmt: &ast::CreateUser) -> Doc<'a> {
             .append(build_name(role.syntax()));
     }
     if let Some(options) = stmt.role_option_list() {
-        doc = doc.append(
-            Doc::line_or_space()
-                .append(leading_comments(options.syntax()))
-                .append(build_role_option_list(&options))
-                .nest(2),
-        );
+        doc = append_nested_clause(doc, options.syntax(), build_role_option_list(&options));
     }
     doc.group().append(build_semicolon(stmt.semicolon_token()))
 }
@@ -4756,12 +4472,7 @@ fn build_create_user_mapping<'a>(stmt: &ast::CreateUserMapping) -> Doc<'a> {
         (stmt.user_token(), "user"),
         (stmt.mapping_token(), "mapping"),
     ]);
-    if let Some(if_not_exists) = stmt.if_not_exists() {
-        doc = doc
-            .append(Doc::space())
-            .append(leading_comments(if_not_exists.syntax()))
-            .append(build_keyword_node(if_not_exists.syntax()));
-    }
+    doc = append_if_not_exists(doc, stmt.if_not_exists());
     if let Some(token) = stmt.for_token() {
         doc = doc
             .append(Doc::space())
@@ -4775,20 +4486,10 @@ fn build_create_user_mapping<'a>(stmt: &ast::CreateUserMapping) -> Doc<'a> {
             .append(build_user_mapping_role(&role));
     }
     if let Some(server) = stmt.server_clause() {
-        doc = doc.append(
-            Doc::line_or_space()
-                .append(leading_comments(server.syntax()))
-                .append(build_server_clause(server))
-                .nest(2),
-        );
+        doc = append_nested_node(doc, server, build_server_clause);
     }
     if let Some(options) = stmt.alter_option_list() {
-        doc = doc.append(
-            Doc::line_or_space()
-                .append(leading_comments(options.syntax()))
-                .append(build_alter_option_list(&options))
-                .nest(2),
-        );
+        doc = append_nested_clause(doc, options.syntax(), build_alter_option_list(&options));
     }
     doc.group().append(build_semicolon(stmt.semicolon_token()))
 }
@@ -4990,21 +4691,10 @@ fn build_create_rule<'a>(stmt: &ast::CreateRule) -> Doc<'a> {
 fn build_rule_on<'a>(rule_on: ast::RuleOn) -> (Doc<'a>, Doc<'a>) {
     let mut head = Doc::text("on");
     if let Some(event) = rule_on.rule_event() {
-        let event_doc = if event.select_token().is_some() {
-            Doc::text("select")
-        } else if event.insert_token().is_some() {
-            Doc::text("insert")
-        } else if event.update_token().is_some() {
-            Doc::text("update")
-        } else if event.delete_token().is_some() {
-            Doc::text("delete")
-        } else {
-            build_name(event.syntax())
-        };
         head = head
             .append(Doc::space())
             .append(leading_comments(event.syntax()))
-            .append(event_doc);
+            .append(build_keyword_node(event.syntax()));
     }
 
     let mut tail = Doc::nil();
@@ -5020,12 +4710,7 @@ fn build_rule_on<'a>(rule_on: ast::RuleOn) -> (Doc<'a>, Doc<'a>) {
             .append(build_extension_path_value(&relation));
     }
     if let Some(where_clause) = rule_on.where_clause() {
-        tail = tail.append(
-            Doc::line_or_space()
-                .append(leading_comments(where_clause.syntax()))
-                .append(build_rule_where_clause(where_clause))
-                .nest(2),
-        );
+        tail = append_nested_node(tail, where_clause, build_rule_where_clause);
     }
     (head, tail.group())
 }
@@ -5105,24 +4790,9 @@ fn build_create_schema<'a>(stmt: &ast::CreateSchema) -> Doc<'a> {
         (stmt.create_token(), "create"),
         (stmt.schema_token(), "schema"),
     ]);
-    if let Some(if_not_exists) = stmt.if_not_exists() {
-        doc = doc
-            .append(Doc::space())
-            .append(leading_comments(if_not_exists.syntax()))
-            .append(build_keyword_tokens([
-                (if_not_exists.if_token(), "if"),
-                (if_not_exists.not_token(), "not"),
-                (if_not_exists.exists_token(), "exists"),
-            ]));
-    }
+    doc = append_if_not_exists(doc, stmt.if_not_exists());
     if let Some(target) = stmt.create_schema_target() {
-        let syntax = target.syntax().clone();
-        doc = doc.append(
-            Doc::line_or_space()
-                .append(leading_comments(&syntax))
-                .append(build_create_schema_target(target))
-                .nest(2),
-        );
+        doc = append_nested_node(doc, target, build_create_schema_target);
     }
     for element in stmt.schema_elements() {
         let syntax = element.syntax().clone();
@@ -5215,37 +4885,19 @@ fn build_create_sequence<'a>(stmt: &ast::CreateSequence) -> Doc<'a> {
             .append(leading_comments_token(&token))
             .append(Doc::text("sequence"));
     }
-    if let Some(if_not_exists) = stmt.if_not_exists() {
-        doc = doc
-            .append(Doc::space())
-            .append(leading_comments(if_not_exists.syntax()))
-            .append(build_keyword_tokens([
-                (if_not_exists.if_token(), "if"),
-                (if_not_exists.not_token(), "not"),
-                (if_not_exists.exists_token(), "exists"),
-            ]));
-    }
+    doc = append_if_not_exists(doc, stmt.if_not_exists());
     if let Some(sequence) = stmt.sequence() {
-        doc = doc.append(
-            Doc::line_or_space()
-                .append(leading_comments(sequence.syntax()))
-                .append(
-                    sequence
-                        .path()
-                        .map(|path| build_path(&path))
-                        .unwrap_or_else(Doc::nil),
-                )
-                .nest(2),
+        doc = append_nested_clause(
+            doc,
+            sequence.syntax(),
+            sequence
+                .path()
+                .map(|path| build_path(&path))
+                .unwrap_or_else(Doc::nil),
         );
     }
     for option in stmt.sequence_options() {
-        let syntax = option.syntax().clone();
-        doc = doc.append(
-            Doc::line_or_space()
-                .append(leading_comments(&syntax))
-                .append(build_sequence_option(option))
-                .nest(2),
-        );
+        doc = append_nested_node(doc, option, build_sequence_option);
     }
     doc.group().append(build_semicolon(stmt.semicolon_token()))
 }
@@ -5255,23 +4907,9 @@ fn build_create_server<'a>(stmt: &ast::CreateServer) -> Doc<'a> {
         (stmt.create_token(), "create"),
         (stmt.server_token(), "server"),
     ]);
-    if let Some(if_not_exists) = stmt.if_not_exists() {
-        doc = doc
-            .append(Doc::space())
-            .append(leading_comments(if_not_exists.syntax()))
-            .append(build_keyword_tokens([
-                (if_not_exists.if_token(), "if"),
-                (if_not_exists.not_token(), "not"),
-                (if_not_exists.exists_token(), "exists"),
-            ]));
-    }
+    doc = append_if_not_exists(doc, stmt.if_not_exists());
     if let Some(server) = stmt.server() {
-        doc = doc.append(
-            Doc::line_or_space()
-                .append(leading_comments(server.syntax()))
-                .append(build_name(server.syntax()))
-                .nest(2),
-        );
+        doc = append_nested_clause(doc, server.syntax(), build_name(server.syntax()));
     }
     if let Some(server_type) = stmt.server_type() {
         let mut clause = build_keyword_tokens([(server_type.type_token(), "type")]);
@@ -5281,24 +4919,14 @@ fn build_create_server<'a>(stmt: &ast::CreateServer) -> Doc<'a> {
                 .append(leading_comments(literal.syntax()))
                 .append(build_literal(literal));
         }
-        doc = doc.append(
-            Doc::line_or_space()
-                .append(leading_comments(server_type.syntax()))
-                .append(clause)
-                .nest(2),
-        );
+        doc = append_nested_clause(doc, server_type.syntax(), clause);
     }
     if let Some(version) = stmt.server_version() {
         let clause = append_optional_literal(
             build_keyword_tokens([(version.version_token(), "version")]),
             version.literal(),
         );
-        doc = doc.append(
-            Doc::line_or_space()
-                .append(leading_comments(version.syntax()))
-                .append(clause)
-                .nest(2),
-        );
+        doc = append_nested_clause(doc, version.syntax(), clause);
     }
     let mut wrapper: Option<Doc<'a>> = None;
     for (token, keyword) in [
@@ -5325,12 +4953,7 @@ fn build_create_server<'a>(stmt: &ast::CreateServer) -> Doc<'a> {
         doc = doc.append(Doc::line_or_space().append(wrapper).nest(2));
     }
     if let Some(options) = stmt.alter_option_list() {
-        doc = doc.append(
-            Doc::line_or_space()
-                .append(leading_comments(options.syntax()))
-                .append(build_alter_option_list(&options))
-                .nest(2),
-        );
+        doc = append_nested_clause(doc, options.syntax(), build_alter_option_list(&options));
     }
     doc.group().append(build_semicolon(stmt.semicolon_token()))
 }
@@ -5340,16 +4963,7 @@ fn build_create_statistics<'a>(stmt: &ast::CreateStatistics) -> Doc<'a> {
         (stmt.create_token(), "create"),
         (stmt.statistics_token(), "statistics"),
     ]);
-    if let Some(if_not_exists) = stmt.if_not_exists() {
-        doc = doc
-            .append(Doc::space())
-            .append(leading_comments(if_not_exists.syntax()))
-            .append(build_keyword_tokens([
-                (if_not_exists.if_token(), "if"),
-                (if_not_exists.not_token(), "not"),
-                (if_not_exists.exists_token(), "exists"),
-            ]));
-    }
+    doc = append_if_not_exists(doc, stmt.if_not_exists());
     let mut statistics_doc = stmt.statistics().map(|statistics| {
         let name = statistics
             .path()
@@ -5370,20 +4984,10 @@ fn build_create_statistics<'a>(stmt: &ast::CreateStatistics) -> Doc<'a> {
             .group();
     }
     if let Some(on) = stmt.statistics_on_clause() {
-        doc = doc.append(
-            Doc::line_or_space()
-                .append(leading_comments(on.syntax()))
-                .append(build_statistics_on_clause(on))
-                .nest(2),
-        );
+        doc = append_nested_node(doc, on, build_statistics_on_clause);
     }
     if let Some(from) = stmt.from_table() {
-        doc = doc.append(
-            Doc::line_or_space()
-                .append(leading_comments(from.syntax()))
-                .append(build_statistics_from_table(from))
-                .nest(2),
-        );
+        doc = append_nested_node(doc, from, build_statistics_from_table);
     }
     doc.group().append(build_semicolon(stmt.semicolon_token()))
 }
@@ -5449,12 +5053,7 @@ fn build_create_tablespace<'a>(stmt: &ast::CreateTablespace) -> Doc<'a> {
                 .append(leading_comments(role.syntax()))
                 .append(build_role_ref(&role));
         }
-        doc = doc.append(
-            Doc::line_or_space()
-                .append(leading_comments(owner.syntax()))
-                .append(clause)
-                .nest(2),
-        );
+        doc = append_nested_clause(doc, owner.syntax(), clause);
     }
     if let Some(location) = stmt.location_token() {
         let mut clause = leading_comments_token(&location).append(Doc::text("location"));
@@ -5467,12 +5066,7 @@ fn build_create_tablespace<'a>(stmt: &ast::CreateTablespace) -> Doc<'a> {
         doc = doc.append(Doc::hard_line().append(clause).nest(2));
     }
     if let Some(params) = stmt.with_params() {
-        doc = doc.append(
-            Doc::line_or_space()
-                .append(leading_comments(params.syntax()))
-                .append(build_with_params(params))
-                .nest(2),
-        );
+        doc = append_nested_node(doc, params, build_with_params);
     }
     doc.group().append(build_semicolon(stmt.semicolon_token()))
 }
@@ -5491,14 +5085,7 @@ fn build_create_text_search_configuration<'a>(
             .path()
             .map(|path| build_path(&path))
             .unwrap_or_else(Doc::nil);
-        doc = doc
-            .append(
-                Doc::line_or_space()
-                    .append(leading_comments(name.syntax()))
-                    .append(name_doc)
-                    .nest(2),
-            )
-            .group();
+        doc = append_nested_clause(doc, name.syntax(), name_doc).group();
     }
     if let Some(attributes) = stmt.attribute_list() {
         doc = doc
@@ -5593,20 +5180,10 @@ fn build_create_group<'a>(stmt: &ast::CreateGroup) -> Doc<'a> {
         (stmt.group_token(), "group"),
     ]);
     if let Some(role) = stmt.role() {
-        doc = doc.append(
-            Doc::line_or_space()
-                .append(leading_comments(role.syntax()))
-                .append(build_name(role.syntax()))
-                .nest(2),
-        );
+        doc = append_nested_clause(doc, role.syntax(), build_name(role.syntax()));
     }
     if let Some(options) = stmt.role_option_list() {
-        doc = doc.append(
-            Doc::line_or_space()
-                .append(leading_comments(options.syntax()))
-                .append(build_role_option_list(&options))
-                .nest(2),
-        );
+        doc = append_nested_clause(doc, options.syntax(), build_role_option_list(&options));
     }
     doc.group().append(build_semicolon(stmt.semicolon_token()))
 }
@@ -5632,47 +5209,39 @@ fn build_create_language<'a>(stmt: &ast::CreateLanguage) -> Doc<'a> {
         }
     }
     if let Some(language) = stmt.language() {
-        doc = doc.append(
-            Doc::line_or_space()
-                .append(leading_comments(language.syntax()))
-                .append(build_name(language.syntax()))
-                .nest(2),
-        );
+        doc = append_nested_clause(doc, language.syntax(), build_name(language.syntax()));
     }
     if let Some(handler) = stmt.handler_clause() {
-        doc = doc.append(
-            Doc::line_or_space()
-                .append(leading_comments(handler.syntax()))
-                .append(build_language_function_clause(
-                    handler.handler_token(),
-                    "handler",
-                    handler.function_name_ref(),
-                ))
-                .nest(2),
+        doc = append_nested_clause(
+            doc,
+            handler.syntax(),
+            build_language_function_clause(
+                handler.handler_token(),
+                "handler",
+                handler.function_name_ref(),
+            ),
         );
     }
     if let Some(inline) = stmt.inline_clause() {
-        doc = doc.append(
-            Doc::line_or_space()
-                .append(leading_comments(inline.syntax()))
-                .append(build_language_function_clause(
-                    inline.inline_token(),
-                    "inline",
-                    inline.function_name_ref(),
-                ))
-                .nest(2),
+        doc = append_nested_clause(
+            doc,
+            inline.syntax(),
+            build_language_function_clause(
+                inline.inline_token(),
+                "inline",
+                inline.function_name_ref(),
+            ),
         );
     }
     if let Some(validator) = stmt.validator_clause() {
-        doc = doc.append(
-            Doc::line_or_space()
-                .append(leading_comments(validator.syntax()))
-                .append(build_language_function_clause(
-                    validator.validator_token(),
-                    "validator",
-                    validator.function_name_ref(),
-                ))
-                .nest(2),
+        doc = append_nested_clause(
+            doc,
+            validator.syntax(),
+            build_language_function_clause(
+                validator.validator_token(),
+                "validator",
+                validator.function_name_ref(),
+            ),
         );
     }
     doc.group().append(build_semicolon(stmt.semicolon_token()))
@@ -5805,19 +5374,11 @@ fn build_create_operator_family<'a>(stmt: &ast::CreateOperatorFamily) -> Doc<'a>
         (stmt.family_token(), "family"),
     ]);
     if let Some(family) = stmt.op_family_name() {
-        doc = doc
-            .append(
-                Doc::line_or_space()
-                    .append(leading_comments(family.syntax()))
-                    .append(
-                        family
-                            .path()
-                            .map(|path| build_path(&path))
-                            .unwrap_or_else(Doc::nil),
-                    )
-                    .nest(2),
-            )
-            .group();
+        let family_doc = family
+            .path()
+            .map(|path| build_path(&path))
+            .unwrap_or_else(Doc::nil);
+        doc = append_nested_clause(doc, family.syntax(), family_doc).group();
     }
     if let Some(using) = stmt.using_method() {
         doc = doc.append(
@@ -5848,12 +5409,7 @@ fn build_create_policy<'a>(stmt: &ast::CreatePolicy) -> Doc<'a> {
                 .append(Doc::space())
                 .append(build_extension_path_value(&table));
         }
-        doc = doc.append(
-            Doc::line_or_space()
-                .append(leading_comments(on.syntax()))
-                .append(on_doc)
-                .nest(2),
-        );
+        doc = append_nested_clause(doc, on.syntax(), on_doc);
     }
     if let Some(policy_type) = stmt.as_policy_type() {
         let mut type_doc = build_keyword_tokens([(policy_type.as_token(), "as")]);
@@ -5863,12 +5419,7 @@ fn build_create_policy<'a>(stmt: &ast::CreatePolicy) -> Doc<'a> {
                 .append(leading_comments_token(&ident))
                 .append(Doc::text(ident.text().to_ascii_lowercase()));
         }
-        doc = doc.append(
-            Doc::line_or_space()
-                .append(leading_comments(policy_type.syntax()))
-                .append(type_doc)
-                .nest(2),
-        );
+        doc = append_nested_clause(doc, policy_type.syntax(), type_doc);
     }
     if let Some(command) = stmt.policy_command() {
         let mut command_doc = build_keyword_tokens([(command.for_token(), "for")]);
@@ -5879,12 +5430,7 @@ fn build_create_policy<'a>(stmt: &ast::CreatePolicy) -> Doc<'a> {
                 .append(leading_comments(&syntax))
                 .append(build_keyword_node(&syntax));
         }
-        doc = doc.append(
-            Doc::line_or_space()
-                .append(leading_comments(command.syntax()))
-                .append(command_doc)
-                .nest(2),
-        );
+        doc = append_nested_clause(doc, command.syntax(), command_doc);
     }
     if let Some(roles) = stmt.policy_roles() {
         let mut roles_doc = build_keyword_tokens([(roles.to_token(), "to")]);
@@ -5894,40 +5440,33 @@ fn build_create_policy<'a>(stmt: &ast::CreatePolicy) -> Doc<'a> {
                 .append(leading_comments(list.syntax()))
                 .append(build_role_ref_list(list));
         }
-        doc = doc.append(
-            Doc::line_or_space()
-                .append(leading_comments(roles.syntax()))
-                .append(roles_doc)
-                .nest(2),
-        );
+        doc = append_nested_clause(doc, roles.syntax(), roles_doc);
     }
     if let Some(using) = stmt.using_expr_clause() {
-        doc = doc.append(
-            Doc::line_or_space()
-                .append(leading_comments(using.syntax()))
-                .append(build_policy_expr_clause(
-                    build_keyword_tokens([(using.using_token(), "using")]),
-                    using.l_paren_token(),
-                    using.expr(),
-                    using.r_paren_token(),
-                ))
-                .nest(2),
+        doc = append_nested_clause(
+            doc,
+            using.syntax(),
+            build_policy_expr_clause(
+                build_keyword_tokens([(using.using_token(), "using")]),
+                using.l_paren_token(),
+                using.expr(),
+                using.r_paren_token(),
+            ),
         );
     }
     if let Some(check) = stmt.with_check_expr_clause() {
-        doc = doc.append(
-            Doc::line_or_space()
-                .append(leading_comments(check.syntax()))
-                .append(build_policy_expr_clause(
-                    build_keyword_tokens([
-                        (check.with_token(), "with"),
-                        (check.check_token(), "check"),
-                    ]),
-                    check.l_paren_token(),
-                    check.expr(),
-                    check.r_paren_token(),
-                ))
-                .nest(2),
+        doc = append_nested_clause(
+            doc,
+            check.syntax(),
+            build_policy_expr_clause(
+                build_keyword_tokens([
+                    (check.with_token(), "with"),
+                    (check.check_token(), "check"),
+                ]),
+                check.l_paren_token(),
+                check.expr(),
+                check.r_paren_token(),
+            ),
         );
     }
     doc.group().append(build_semicolon(stmt.semicolon_token()))
@@ -6000,12 +5539,7 @@ fn build_create_materialized_view<'a>(view: &ast::CreateMaterializedView) -> Doc
                 .append(Doc::text(keyword));
         }
     }
-    if let Some(if_not_exists) = view.if_not_exists() {
-        doc = doc
-            .append(Doc::space())
-            .append(leading_comments(if_not_exists.syntax()))
-            .append(build_keyword_node(if_not_exists.syntax()));
-    }
+    doc = append_if_not_exists(doc, view.if_not_exists());
     let mut view_doc = view.view().and_then(|name| {
         name.path()
             .map(|path| leading_comments(name.syntax()).append(build_path(&path)))
@@ -6026,20 +5560,10 @@ fn build_create_materialized_view<'a>(view: &ast::CreateMaterializedView) -> Doc
         || view.with_params().is_some()
         || view.tablespace_clause().is_some();
     if let Some(using) = view.using_method() {
-        doc = doc.append(
-            Doc::line_or_space()
-                .append(leading_comments(using.syntax()))
-                .append(build_using_method(using))
-                .nest(2),
-        );
+        doc = append_nested_node(doc, using, build_using_method);
     }
     if let Some(params) = view.with_params() {
-        doc = doc.append(
-            Doc::line_or_space()
-                .append(leading_comments(params.syntax()))
-                .append(build_with_params(params))
-                .nest(2),
-        );
+        doc = append_nested_node(doc, params, build_with_params);
     }
     if let Some(tablespace) = view.tablespace_clause() {
         let mut option = Doc::text("tablespace");
@@ -6049,12 +5573,7 @@ fn build_create_materialized_view<'a>(view: &ast::CreateMaterializedView) -> Doc
                 .append(leading_comments(name.syntax()))
                 .append(build_name(name.syntax()));
         }
-        doc = doc.append(
-            Doc::line_or_space()
-                .append(leading_comments(tablespace.syntax()))
-                .append(option)
-                .nest(2),
-        );
+        doc = append_nested_clause(doc, tablespace.syntax(), option);
     }
     if let Some(as_token) = view.as_token() {
         let as_doc = leading_comments_token(&as_token).append(Doc::text("as"));
@@ -6633,29 +6152,14 @@ fn build_granted_by_clause<'a>(granted: ast::GrantedByClause) -> Doc<'a> {
 fn build_grant<'a>(grant: &ast::Grant) -> Doc<'a> {
     let mut doc = Doc::text("grant");
     if let Some(privileges) = grant.privileges() {
-        doc = doc.append(
-            Doc::line_or_space()
-                .append(leading_comments(privileges.syntax()))
-                .append(build_privileges(privileges))
-                .nest(2),
-        );
+        doc = append_nested_node(doc, privileges, build_privileges);
     }
     if let Some(on) = grant.on_privilege_objects_clause() {
         let mut on_doc = Doc::text("on");
         if let Some(objects) = on.privilege_objects() {
-            on_doc = on_doc.append(
-                Doc::line_or_space()
-                    .append(leading_comments(objects.syntax()))
-                    .append(build_privilege_objects(objects))
-                    .nest(2),
-            );
+            on_doc = append_nested_node(on_doc, objects, build_privilege_objects);
         }
-        doc = doc.append(
-            Doc::line_or_space()
-                .append(leading_comments(on.syntax()))
-                .append(on_doc)
-                .nest(2),
-        );
+        doc = append_nested_clause(doc, on.syntax(), on_doc);
     }
     if let Some(to) = grant.to_token() {
         doc = doc.append(
@@ -6666,28 +6170,13 @@ fn build_grant<'a>(grant: &ast::Grant) -> Doc<'a> {
         );
     }
     if let Some(roles) = grant.role_ref_list() {
-        doc = doc.append(
-            Doc::line_or_space()
-                .append(leading_comments(roles.syntax()))
-                .append(build_role_ref_list(roles))
-                .nest(2),
-        );
+        doc = append_nested_node(doc, roles, build_role_ref_list);
     }
     if let Some(with) = grant.grant_with_clause() {
-        doc = doc.append(
-            Doc::line_or_space()
-                .append(leading_comments(with.syntax()))
-                .append(build_grant_with_clause(with))
-                .nest(2),
-        );
+        doc = append_nested_node(doc, with, build_grant_with_clause);
     }
     if let Some(granted) = grant.granted_by_clause() {
-        doc = doc.append(
-            Doc::line_or_space()
-                .append(leading_comments(granted.syntax()))
-                .append(build_granted_by_clause(granted))
-                .nest(2),
-        );
+        doc = append_nested_node(doc, granted, build_granted_by_clause);
     }
     doc.group().append(build_semicolon(grant.semicolon_token()))
 }
@@ -6704,37 +6193,17 @@ fn build_revoke_option_for<'a>(option: ast::RevokeOptionFor) -> Doc<'a> {
 fn build_revoke<'a>(revoke: &ast::Revoke) -> Doc<'a> {
     let mut doc = Doc::text("revoke");
     if let Some(option) = revoke.revoke_option_for() {
-        doc = doc.append(
-            Doc::line_or_space()
-                .append(leading_comments(option.syntax()))
-                .append(build_revoke_option_for(option))
-                .nest(2),
-        );
+        doc = append_nested_node(doc, option, build_revoke_option_for);
     }
     if let Some(privileges) = revoke.privileges() {
-        doc = doc.append(
-            Doc::line_or_space()
-                .append(leading_comments(privileges.syntax()))
-                .append(build_privileges(privileges))
-                .nest(2),
-        );
+        doc = append_nested_node(doc, privileges, build_privileges);
     }
     if let Some(on) = revoke.on_privilege_objects_clause() {
         let mut on_doc = Doc::text("on");
         if let Some(objects) = on.privilege_objects() {
-            on_doc = on_doc.append(
-                Doc::line_or_space()
-                    .append(leading_comments(objects.syntax()))
-                    .append(build_privilege_objects(objects))
-                    .nest(2),
-            );
+            on_doc = append_nested_node(on_doc, objects, build_privilege_objects);
         }
-        doc = doc.append(
-            Doc::line_or_space()
-                .append(leading_comments(on.syntax()))
-                .append(on_doc)
-                .nest(2),
-        );
+        doc = append_nested_clause(doc, on.syntax(), on_doc);
     }
     if let Some(from) = revoke.from_token() {
         doc = doc.append(
@@ -6745,28 +6214,13 @@ fn build_revoke<'a>(revoke: &ast::Revoke) -> Doc<'a> {
         );
     }
     if let Some(roles) = revoke.role_ref_list() {
-        doc = doc.append(
-            Doc::line_or_space()
-                .append(leading_comments(roles.syntax()))
-                .append(build_role_ref_list(roles))
-                .nest(2),
-        );
+        doc = append_nested_node(doc, roles, build_role_ref_list);
     }
     if let Some(granted) = revoke.granted_by_clause() {
-        doc = doc.append(
-            Doc::line_or_space()
-                .append(leading_comments(granted.syntax()))
-                .append(build_granted_by_clause(granted))
-                .nest(2),
-        );
+        doc = append_nested_node(doc, granted, build_granted_by_clause);
     }
     if let Some(behavior) = revoke.drop_behavior() {
-        doc = doc.append(
-            Doc::line_or_space()
-                .append(leading_comments(behavior.syntax()))
-                .append(build_drop_behavior(behavior))
-                .nest(2),
-        );
+        doc = append_nested_node(doc, behavior, build_drop_behavior);
     }
     doc.group()
         .append(build_semicolon(revoke.semicolon_token()))
@@ -6833,12 +6287,7 @@ fn build_import_foreign_schema<'a>(import: &ast::ImportForeignSchema) -> Doc<'a>
             .append(build_name(schema.syntax()));
     }
     if let Some(filter) = import.import_table_filter() {
-        doc = doc.append(
-            Doc::line_or_space()
-                .append(leading_comments(filter.syntax()))
-                .append(build_import_table_filter(filter))
-                .nest(2),
-        );
+        doc = append_nested_node(doc, filter, build_import_table_filter);
     }
     if let Some(from) = import.from_token() {
         let mut from_doc = leading_comments_token(&from).append(Doc::text("from"));
@@ -6850,12 +6299,7 @@ fn build_import_foreign_schema<'a>(import: &ast::ImportForeignSchema) -> Doc<'a>
         }
         doc = doc.append(Doc::line_or_space().append(from_doc).nest(2));
     } else if let Some(server) = import.server_clause() {
-        doc = doc.append(
-            Doc::line_or_space()
-                .append(leading_comments(server.syntax()))
-                .append(build_server_clause(server))
-                .nest(2),
-        );
+        doc = append_nested_node(doc, server, build_server_clause);
     }
     if let Some(into) = import.into_schema() {
         let mut into_doc = Doc::text("into");
@@ -6865,20 +6309,10 @@ fn build_import_foreign_schema<'a>(import: &ast::ImportForeignSchema) -> Doc<'a>
                 .append(leading_comments(schema.syntax()))
                 .append(build_name(schema.syntax()));
         }
-        doc = doc.append(
-            Doc::line_or_space()
-                .append(leading_comments(into.syntax()))
-                .append(into_doc)
-                .nest(2),
-        );
+        doc = append_nested_clause(doc, into.syntax(), into_doc);
     }
     if let Some(options) = import.alter_option_list() {
-        doc = doc.append(
-            Doc::line_or_space()
-                .append(leading_comments(options.syntax()))
-                .append(build_alter_option_list(&options))
-                .nest(2),
-        );
+        doc = append_nested_clause(doc, options.syntax(), build_alter_option_list(&options));
     }
     doc.group()
         .append(build_semicolon(import.semicolon_token()))
@@ -6887,12 +6321,7 @@ fn build_import_foreign_schema<'a>(import: &ast::ImportForeignSchema) -> Doc<'a>
 fn build_listen<'a>(listen: &ast::Listen) -> Doc<'a> {
     let mut doc = Doc::text("listen");
     if let Some(channel) = listen.channel() {
-        doc = doc.append(
-            Doc::line_or_space()
-                .append(leading_comments(channel.syntax()))
-                .append(build_name(channel.syntax()))
-                .nest(2),
-        );
+        doc = append_nested_clause(doc, channel.syntax(), build_name(channel.syntax()));
     }
     doc.group()
         .append(build_semicolon(listen.semicolon_token()))
@@ -6901,12 +6330,7 @@ fn build_listen<'a>(listen: &ast::Listen) -> Doc<'a> {
 fn build_move<'a>(move_stmt: &ast::Move) -> Doc<'a> {
     let mut doc = Doc::text("move");
     if let Some(action) = move_stmt.cursor_action() {
-        doc = doc.append(
-            Doc::line_or_space()
-                .append(leading_comments(action.syntax()))
-                .append(build_cursor_action(action))
-                .nest(2),
-        );
+        doc = append_nested_node(doc, action, build_cursor_action);
     }
     if let Some(token) = move_stmt.from_token().or_else(|| move_stmt.in_token()) {
         let keyword = if token.kind() == SyntaxKind::FROM_KW {
@@ -6922,12 +6346,7 @@ fn build_move<'a>(move_stmt: &ast::Move) -> Doc<'a> {
         );
     }
     if let Some(cursor) = move_stmt.cursor_ref() {
-        doc = doc.append(
-            Doc::line_or_space()
-                .append(leading_comments(cursor.syntax()))
-                .append(build_name(cursor.syntax()))
-                .nest(2),
-        );
+        doc = append_nested_clause(doc, cursor.syntax(), build_name(cursor.syntax()));
     }
     doc.group()
         .append(build_semicolon(move_stmt.semicolon_token()))
@@ -6945,12 +6364,7 @@ fn build_notify<'a>(notify: &ast::Notify) -> Doc<'a> {
         doc = doc.append(comments_before(comma)).append(Doc::text(","));
     }
     if let Some(payload) = notify.literal() {
-        doc = doc.append(
-            Doc::line_or_space()
-                .append(leading_comments(payload.syntax()))
-                .append(build_literal(payload))
-                .nest(2),
-        );
+        doc = append_nested_node(doc, payload, build_literal);
     }
     doc.group()
         .append(build_semicolon(notify.semicolon_token()))
@@ -6963,12 +6377,7 @@ fn build_reassign<'a>(reassign: &ast::Reassign) -> Doc<'a> {
         (reassign.by_token(), "by"),
     ]);
     if let Some(roles) = reassign.before() {
-        doc = doc.append(
-            Doc::line_or_space()
-                .append(leading_comments(roles.syntax()))
-                .append(build_role_ref_list(roles))
-                .nest(2),
-        );
+        doc = append_nested_node(doc, roles, build_role_ref_list);
     }
     if let Some(to) = reassign.to_token() {
         let mut to_doc = leading_comments_token(&to).append(Doc::text("to"));
@@ -6980,12 +6389,7 @@ fn build_reassign<'a>(reassign: &ast::Reassign) -> Doc<'a> {
         }
         doc = doc.append(Doc::line_or_space().append(to_doc).nest(2));
     } else if let Some(roles) = reassign.after() {
-        doc = doc.append(
-            Doc::line_or_space()
-                .append(leading_comments(roles.syntax()))
-                .append(build_role_ref_list(roles))
-                .nest(2),
-        );
+        doc = append_nested_node(doc, roles, build_role_ref_list);
     }
     doc.group()
         .append(build_semicolon(reassign.semicolon_token()))
@@ -7006,12 +6410,7 @@ fn build_refresh<'a>(refresh: &ast::Refresh) -> Doc<'a> {
         );
     }
     if let Some(data) = refresh.data_option() {
-        doc = doc.append(
-            Doc::line_or_space()
-                .append(leading_comments(data.syntax()))
-                .append(build_keyword_node(data.syntax()))
-                .nest(2),
-        );
+        doc = append_nested_clause(doc, data.syntax(), build_keyword_node(data.syntax()));
     }
     doc.group()
         .append(build_semicolon(refresh.semicolon_token()))
@@ -7020,20 +6419,10 @@ fn build_refresh<'a>(refresh: &ast::Refresh) -> Doc<'a> {
 fn build_repack<'a>(repack: &ast::Repack) -> Doc<'a> {
     let mut doc = Doc::text("repack");
     if let Some(options) = repack.option_item_list() {
-        doc = doc.append(
-            Doc::line_or_space()
-                .append(leading_comments(options.syntax()))
-                .append(build_option_item_list(options))
-                .nest(2),
-        );
+        doc = append_nested_node(doc, options, build_option_item_list);
     }
     if let Some(tables) = repack.table_and_columns_list() {
-        doc = doc.append(
-            Doc::line_or_space()
-                .append(leading_comments(tables.syntax()))
-                .append(build_table_and_columns_list(tables))
-                .nest(2),
-        );
+        doc = append_nested_node(doc, tables, build_table_and_columns_list);
     }
     if let Some(using_index) = repack.using_index() {
         let mut using_doc = Doc::text("using");
@@ -7048,12 +6437,7 @@ fn build_repack<'a>(repack: &ast::Repack) -> Doc<'a> {
                 .append(Doc::space())
                 .append(build_extension_path_value(&index));
         }
-        doc = doc.append(
-            Doc::line_or_space()
-                .append(leading_comments(using_index.syntax()))
-                .append(using_doc)
-                .nest(2),
-        );
+        doc = append_nested_clause(doc, using_index.syntax(), using_doc);
     }
     doc.group()
         .append(build_semicolon(repack.semicolon_token()))
@@ -7302,12 +6686,7 @@ fn build_security_label<'a>(label: &ast::SecurityLabel) -> Doc<'a> {
                 .append(leading_comments(literal.syntax()))
                 .append(build_literal(literal));
         }
-        doc = doc.append(
-            Doc::line_or_space()
-                .append(leading_comments(provider.syntax()))
-                .append(provider_doc)
-                .nest(2),
-        );
+        doc = append_nested_clause(doc, provider.syntax(), provider_doc);
     }
     let object = label.security_label_object();
     if let Some(on) = label.on_token() {
@@ -7320,12 +6699,7 @@ fn build_security_label<'a>(label: &ast::SecurityLabel) -> Doc<'a> {
         }
         doc = doc.append(Doc::line_or_space().append(on_doc).nest(2));
     } else if let Some(object) = object {
-        doc = doc.append(
-            Doc::line_or_space()
-                .append(leading_comments(object.syntax()))
-                .append(build_security_label_object(object))
-                .nest(2),
-        );
+        doc = append_nested_node(doc, object, build_security_label_object);
     }
 
     let value = if let Some(literal) = label.literal() {
@@ -7372,12 +6746,7 @@ fn build_set_constraints<'a>(set: &ast::SetConstraints) -> Doc<'a> {
         doc = doc.append(Doc::line_or_space().append(target).nest(2));
     }
     if let Some(timing) = set.constraint_timing() {
-        doc = doc.append(
-            Doc::line_or_space()
-                .append(leading_comments(timing.syntax()))
-                .append(build_keyword_node(timing.syntax()))
-                .nest(2),
-        );
+        doc = append_nested_clause(doc, timing.syntax(), build_keyword_node(timing.syntax()));
     }
     doc.group().append(build_semicolon(set.semicolon_token()))
 }
@@ -7436,12 +6805,7 @@ fn build_set_role_target<'a>(target: ast::SetRoleTarget) -> Doc<'a> {
 fn build_set_role<'a>(set: &ast::SetRole) -> Doc<'a> {
     let mut doc = Doc::text("set");
     if let Some(scope) = set.set_scope() {
-        doc = doc.append(
-            Doc::line_or_space()
-                .append(leading_comments(scope.syntax()))
-                .append(build_keyword_node(scope.syntax()))
-                .nest(2),
-        );
+        doc = append_nested_clause(doc, scope.syntax(), build_keyword_node(scope.syntax()));
     }
     if let Some(role) = set.role_token() {
         doc = doc.append(
@@ -7476,12 +6840,7 @@ fn build_set_session_auth_target<'a>(target: ast::SetSessionAuthTarget) -> Doc<'
 fn build_set_session_auth<'a>(set: &ast::SetSessionAuth) -> Doc<'a> {
     let mut doc = Doc::text("set");
     if let Some(scope) = set.set_scope() {
-        doc = doc.append(
-            Doc::line_or_space()
-                .append(leading_comments(scope.syntax()))
-                .append(build_keyword_node(scope.syntax()))
-                .nest(2),
-        );
+        doc = append_nested_clause(doc, scope.syntax(), build_keyword_node(scope.syntax()));
     }
     if let Some(session) = set.session_token() {
         doc = doc.append(
@@ -7550,23 +6909,13 @@ fn build_set_transaction<'a>(set: &ast::SetTransaction) -> Doc<'a> {
             }
         }
         if let Some(modes) = characteristics.transaction_mode_list() {
-            body = body.append(
-                Doc::line_or_space()
-                    .append(leading_comments(modes.syntax()))
-                    .append(build_transaction_mode_list(modes))
-                    .nest(2),
-            );
+            body = append_nested_node(body, modes, build_transaction_mode_list);
         }
         Some((leading_comments(characteristics.syntax()), body))
     } else if let Some(modes) = set.transaction_modes() {
         let mut body = Doc::text("transaction");
         if let Some(list) = modes.transaction_mode_list() {
-            body = body.append(
-                Doc::line_or_space()
-                    .append(leading_comments(list.syntax()))
-                    .append(build_transaction_mode_list(list))
-                    .nest(2),
-            );
+            body = append_nested_node(body, list, build_transaction_mode_list);
         }
         Some((leading_comments(modes.syntax()), body))
     } else {
@@ -7579,12 +6928,7 @@ fn build_set_transaction<'a>(set: &ast::SetTransaction) -> Doc<'a> {
                     .append(Doc::text("snapshot"));
             }
             if let Some(literal) = snapshot.literal() {
-                body = body.append(
-                    Doc::line_or_space()
-                        .append(leading_comments(literal.syntax()))
-                        .append(build_literal(literal))
-                        .nest(2),
-                );
+                body = append_nested_node(body, literal, build_literal);
             }
             (leading_comments(snapshot.syntax()), body)
         })
@@ -7640,20 +6984,10 @@ fn build_unlisten<'a>(unlisten: &ast::Unlisten) -> Doc<'a> {
 fn build_set<'a>(set: &ast::Set) -> Doc<'a> {
     let mut doc = Doc::text("set");
     if let Some(scope) = set.set_scope() {
-        doc = doc.append(
-            Doc::line_or_space()
-                .append(leading_comments(scope.syntax()))
-                .append(build_keyword_node(scope.syntax()))
-                .nest(2),
-        );
+        doc = append_nested_clause(doc, scope.syntax(), build_keyword_node(scope.syntax()));
     }
     if let Some(target) = set.set_target() {
-        doc = doc.append(
-            Doc::line_or_space()
-                .append(leading_comments(target.syntax()))
-                .append(build_set_target(target))
-                .nest(2),
-        );
+        doc = append_nested_node(doc, target, build_set_target);
     }
     doc.group().append(build_semicolon(set.semicolon_token()))
 }
@@ -7748,14 +7082,7 @@ fn build_set_config<'a>(set: ast::SetConfig) -> Doc<'a> {
 
 fn build_set_config_param<'a>(set: &ast::SetConfigParam) -> Doc<'a> {
     let mut doc = Doc::text("set");
-    if let Some(parameter) = set.config_parameter_ref() {
-        doc = doc
-            .append(Doc::space())
-            .append(leading_comments(parameter.syntax()));
-        if let Some(path) = parameter.path_ref() {
-            doc = doc.append(build_path_ref(&path));
-        }
-    }
+    doc = append_commented_path_ref(doc, set.config_parameter_ref());
     if let Some(assignment) = set.config_assignment() {
         let comments = leading_comments(assignment.syntax());
         doc = doc
@@ -7822,12 +7149,7 @@ fn build_create_index<'a>(create_index: &ast::CreateIndex) -> Doc<'a> {
             .append(leading_comments_token(&concurrently_token))
             .append(Doc::text("concurrently"));
     }
-    if let Some(if_not_exists) = create_index.if_not_exists() {
-        doc = doc
-            .append(Doc::space())
-            .append(leading_comments(if_not_exists.syntax()))
-            .append(build_keyword_node(if_not_exists.syntax()));
-    }
+    doc = append_if_not_exists(doc, create_index.if_not_exists());
     if let Some(index) = create_index.index() {
         doc = doc
             .append(Doc::space())
@@ -7880,20 +7202,10 @@ fn build_create_index<'a>(create_index: &ast::CreateIndex) -> Doc<'a> {
         doc = doc.append(Doc::line_or_space().append(include_doc).nest(2));
     }
     if let Some(nulls) = create_index.nulls_distinct_option() {
-        doc = doc.append(
-            Doc::line_or_space()
-                .append(leading_comments(nulls.syntax()))
-                .append(build_keyword_node(nulls.syntax()))
-                .nest(2),
-        );
+        doc = append_nested_clause(doc, nulls.syntax(), build_keyword_node(nulls.syntax()));
     }
     if let Some(params) = create_index.with_params() {
-        doc = doc.append(
-            Doc::line_or_space()
-                .append(leading_comments(params.syntax()))
-                .append(build_with_params(params))
-                .nest(2),
-        );
+        doc = append_nested_node(doc, params, build_with_params);
     }
     if let Some(tablespace) = create_index.tablespace_clause() {
         let mut tablespace_doc =
@@ -7907,12 +7219,7 @@ fn build_create_index<'a>(create_index: &ast::CreateIndex) -> Doc<'a> {
         doc = doc.append(Doc::line_or_space().append(tablespace_doc).nest(2));
     }
     if let Some(where_clause) = create_index.where_clause() {
-        doc = doc.append(
-            Doc::line_or_space()
-                .append(leading_comments(where_clause.syntax()))
-                .append(build_where_clause(where_clause))
-                .nest(2),
-        );
+        doc = append_nested_node(doc, where_clause, build_where_clause);
     }
 
     doc.group()
@@ -8021,12 +7328,7 @@ fn build_create_table_as<'a>(create_table_as: &ast::CreateTableAs) -> Doc<'a> {
     }
     doc = doc.append(Doc::text("table"));
 
-    if let Some(if_not_exists) = create_table_as.if_not_exists() {
-        doc = doc
-            .append(Doc::space())
-            .append(leading_comments(if_not_exists.syntax()))
-            .append(build_keyword_node(if_not_exists.syntax()));
-    }
+    doc = append_if_not_exists(doc, create_table_as.if_not_exists());
     if let Some(table_name) = create_table_as.table_name() {
         doc = doc
             .append(Doc::space())
@@ -8196,12 +7498,7 @@ fn build_create_foreign_table<'a>(create_table: &ast::CreateForeignTable) -> Doc
             .append(leading_comments_token(&table))
             .append(Doc::text("table"));
     }
-    if let Some(if_not_exists) = create_table.if_not_exists() {
-        doc = doc
-            .append(Doc::space())
-            .append(leading_comments(if_not_exists.syntax()))
-            .append(build_keyword_node(if_not_exists.syntax()));
-    }
+    doc = append_if_not_exists(doc, create_table.if_not_exists());
     if let Some(table_name) = create_table.table_name() {
         doc = doc
             .append(Doc::space())
@@ -8234,37 +7531,17 @@ fn build_create_foreign_table<'a>(create_table: &ast::CreateForeignTable) -> Doc
             doc = append_table_arg_list(doc, arg_list);
         }
         if let Some(inherits) = create_table.inherits() {
-            doc = doc.append(
-                Doc::line_or_space()
-                    .append(leading_comments(inherits.syntax()))
-                    .append(build_create_table_inherits(inherits))
-                    .nest(2),
-            );
+            doc = append_nested_node(doc, inherits, build_create_table_inherits);
         }
         if let Some(partition_type) = create_table.partition_type() {
-            doc = doc.append(
-                Doc::line_or_space()
-                    .append(leading_comments(partition_type.syntax()))
-                    .append(build_create_table_partition_type(partition_type))
-                    .nest(2),
-            );
+            doc = append_nested_node(doc, partition_type, build_create_table_partition_type);
         }
     }
     if let Some(server) = create_table.server_clause() {
-        doc = doc.append(
-            Doc::line_or_space()
-                .append(leading_comments(server.syntax()))
-                .append(build_server_clause(server))
-                .nest(2),
-        );
+        doc = append_nested_node(doc, server, build_server_clause);
     }
     if let Some(options) = create_table.alter_option_list() {
-        doc = doc.append(
-            Doc::line_or_space()
-                .append(leading_comments(options.syntax()))
-                .append(build_alter_option_list(&options))
-                .nest(2),
-        );
+        doc = append_nested_clause(doc, options.syntax(), build_alter_option_list(&options));
     }
 
     doc.group()
@@ -8327,12 +7604,7 @@ fn build_create_table<'a>(create_table: &ast::CreateTable) -> Doc<'a> {
     }
     doc = doc.append(Doc::text("table"));
 
-    if let Some(if_not_exists) = create_table.if_not_exists() {
-        doc = doc
-            .append(Doc::space())
-            .append(leading_comments(if_not_exists.syntax()))
-            .append(build_keyword_node(if_not_exists.syntax()));
-    }
+    doc = append_if_not_exists(doc, create_table.if_not_exists());
 
     if let Some(table_name) = create_table.table_name() {
         doc = doc
@@ -8399,21 +7671,11 @@ fn build_create_table<'a>(create_table: &ast::CreateTable) -> Doc<'a> {
     }
 
     if let Some(inherits) = create_table.inherits() {
-        doc = doc.append(
-            Doc::line_or_space()
-                .append(leading_comments(inherits.syntax()))
-                .append(build_create_table_inherits(inherits))
-                .nest(2),
-        );
+        doc = append_nested_node(doc, inherits, build_create_table_inherits);
     }
 
     if let Some(partition_by) = create_table.partition_by() {
-        doc = doc.append(
-            Doc::line_or_space()
-                .append(leading_comments(partition_by.syntax()))
-                .append(build_create_table_partition_by(partition_by))
-                .nest(2),
-        );
+        doc = append_nested_node(doc, partition_by, build_create_table_partition_by);
     }
 
     if let Some(using_method) = create_table.using_method() {
@@ -8482,15 +7744,7 @@ fn build_create_table_partition_of<'a>(partition_of: ast::PartitionOf) -> Doc<'a
         doc = doc.append(Doc::space());
     }
     doc = doc.append(Doc::text("of"));
-    if let Some(table) = partition_of.table_name_ref() {
-        doc = doc
-            .append(Doc::space())
-            .append(leading_comments(table.syntax()));
-        if let Some(path) = table.path_ref() {
-            doc = doc.append(build_path_ref(&path));
-        }
-    }
-    doc
+    append_commented_path_ref(doc, partition_of.table_name_ref())
 }
 
 fn build_create_table_inherits<'a>(inherits: ast::Inherits) -> Doc<'a> {
@@ -8560,14 +7814,7 @@ fn build_create_table_partition_items<'a>(items: ast::PartitionItemList) -> Doc<
                 item_doc = item_doc.append(build_collate_expr(collate));
             }
         }
-        if let Some(op_class) = item.op_class_ref() {
-            item_doc = item_doc
-                .append(Doc::space())
-                .append(leading_comments(op_class.syntax()));
-            if let Some(path) = op_class.path_ref() {
-                item_doc = item_doc.append(build_path_ref(&path));
-            }
-        }
+        item_doc = append_commented_path_ref(item_doc, item.op_class_ref());
         if let Some(attributes) = item.attribute_list() {
             item_doc = item_doc
                 .append(Doc::space())
@@ -8857,12 +8104,26 @@ fn build_column<'a>(column: &ast::Column) -> Doc<'a> {
             ast::ColumnClause::Collate(collate) => build_collate_expr(collate),
             ast::ColumnClause::ColumnConstraint(constraint) => build_column_constraint(constraint),
         };
-        doc = append_column_clause(doc, &syntax, clause);
+        doc = append_nested_clause(doc, &syntax, clause);
     }
     doc.group()
 }
 
-fn append_column_clause<'a>(doc: Doc<'a>, syntax: &SyntaxNode, clause: Doc<'a>) -> Doc<'a> {
+fn append_nested_node<'a, T: AstNode>(
+    doc: Doc<'a>,
+    node: T,
+    build: impl FnOnce(T) -> Doc<'a>,
+) -> Doc<'a> {
+    let comments = leading_comments(node.syntax());
+    doc.append(
+        Doc::line_or_space()
+            .append(comments)
+            .append(build(node))
+            .nest(2),
+    )
+}
+
+fn append_nested_clause<'a>(doc: Doc<'a>, syntax: &SyntaxNode, clause: Doc<'a>) -> Doc<'a> {
     doc.append(
         Doc::line_or_space()
             .append(leading_comments(syntax))
@@ -9021,14 +8282,7 @@ fn build_references_constraint<'a>(constraint: ast::ReferencesConstraint) -> Doc
             .append(leading_comments_token(&references))
             .append(Doc::text("references"));
     }
-    if let Some(table) = constraint.table() {
-        doc = doc
-            .append(Doc::space())
-            .append(leading_comments(table.syntax()));
-        if let Some(path) = table.path_ref() {
-            doc = doc.append(build_path_ref(&path));
-        }
-    }
+    doc = append_commented_path_ref(doc, constraint.table());
     if let Some(column) = constraint.column() {
         if let Some(l_paren) = constraint.l_paren_token() {
             doc = doc.append(comments_before(l_paren));
@@ -9137,12 +8391,7 @@ fn build_generated_constraint<'a>(constraint: ast::GeneratedConstraint) -> Doc<'
     }
     doc = doc.group();
     for option in constraint.constraint_options() {
-        doc = doc.append(
-            Doc::line_or_space()
-                .append(leading_comments(option.syntax()))
-                .append(build_keyword_node(option.syntax()))
-                .nest(2),
-        );
+        doc = append_nested_clause(doc, option.syntax(), build_keyword_node(option.syntax()));
     }
     doc.group()
 }
@@ -9474,28 +8723,13 @@ fn build_index_parameters<'a>(parameters: ast::IndexParameters) -> Doc<'a> {
     }
     let mut doc = prefix.unwrap_or_else(Doc::nil);
     if let Some(include) = parameters.constraint_include_clause() {
-        doc = doc.append(
-            Doc::line_or_space()
-                .append(leading_comments(include.syntax()))
-                .append(build_constraint_include_clause(include))
-                .nest(2),
-        );
+        doc = append_nested_node(doc, include, build_constraint_include_clause);
     }
     if let Some(with_params) = parameters.with_params() {
-        doc = doc.append(
-            Doc::line_or_space()
-                .append(leading_comments(with_params.syntax()))
-                .append(build_with_params(with_params))
-                .nest(2),
-        );
+        doc = append_nested_node(doc, with_params, build_with_params);
     }
     if let Some(tablespace) = parameters.constraint_index_tablespace() {
-        doc = doc.append(
-            Doc::line_or_space()
-                .append(leading_comments(tablespace.syntax()))
-                .append(build_constraint_index_tablespace(tablespace))
-                .nest(2),
-        );
+        doc = append_nested_node(doc, tablespace, build_constraint_index_tablespace);
     }
     doc
 }
@@ -9646,48 +8880,10 @@ fn build_attribute_value<'a>(value: ast::AttributeValue) -> Doc<'a> {
         build_type(ty)
     } else if let Some(custom_op) = value.custom_op() {
         build_custom_operator(custom_op)
-    } else if value.eq_token().is_some() {
-        Doc::text("=")
-    } else if value.l_angle_token().is_some() {
-        Doc::text("<")
-    } else if value.r_angle_token().is_some() {
-        Doc::text(">")
-    } else if value.lteq_token().is_some() {
-        Doc::text("<=")
-    } else if value.gteq_token().is_some() {
-        Doc::text(">=")
-    } else if value.neqb_token().is_some() {
-        Doc::text("<>")
-    } else if value.neq_token().is_some() {
-        Doc::text("!=")
-    } else if value.plus_token().is_some() {
-        Doc::text("+")
-    } else if value.minus_token().is_some() {
-        Doc::text("-")
-    } else if value.star_token().is_some() {
-        Doc::text("*")
-    } else if value.slash_token().is_some() {
-        Doc::text("/")
-    } else if value.percent_token().is_some() {
-        Doc::text("%")
-    } else if value.caret_token().is_some() {
-        Doc::text("^")
-    } else if value.any_token().is_some() {
-        Doc::text("any")
-    } else if value.none_token().is_some() {
-        Doc::text("none")
-    } else if value.primary_token().is_some() {
-        Doc::text("primary")
-    } else if value.default_token().is_some() {
-        Doc::text("default")
-    } else if value.null_token().is_some() {
-        Doc::text("null")
-    } else if value.constraint_token().is_some() {
-        Doc::text("constraint")
     } else if let Some(operator_call) = value.operator_call() {
         build_operator_call(&operator_call)
     } else {
-        Doc::nil()
+        build_keyword_node(value.syntax())
     }
 }
 
@@ -9999,36 +9195,16 @@ fn build_exclude_constraint<'a>(constraint: ast::ExcludeConstraint) -> Doc<'a> {
             .append(build_constraint_exclusion_list(list));
     }
     if let Some(include) = constraint.constraint_include_clause() {
-        doc = doc.append(
-            Doc::line_or_space()
-                .append(leading_comments(include.syntax()))
-                .append(build_constraint_include_clause(include))
-                .nest(2),
-        );
+        doc = append_nested_node(doc, include, build_constraint_include_clause);
     }
     if let Some(with_params) = constraint.with_params() {
-        doc = doc.append(
-            Doc::line_or_space()
-                .append(leading_comments(with_params.syntax()))
-                .append(build_with_params(with_params))
-                .nest(2),
-        );
+        doc = append_nested_node(doc, with_params, build_with_params);
     }
     if let Some(tablespace) = constraint.constraint_index_tablespace() {
-        doc = doc.append(
-            Doc::line_or_space()
-                .append(leading_comments(tablespace.syntax()))
-                .append(build_constraint_index_tablespace(tablespace))
-                .nest(2),
-        );
+        doc = append_nested_node(doc, tablespace, build_constraint_index_tablespace);
     }
     if let Some(where_clause) = constraint.where_condition_clause() {
-        doc = doc.append(
-            Doc::line_or_space()
-                .append(leading_comments(where_clause.syntax()))
-                .append(build_where_condition_clause(where_clause))
-                .nest(2),
-        );
+        doc = append_nested_node(doc, where_clause, build_where_condition_clause);
     }
     let options = append_constraint_options(Doc::nil(), constraint.constraint_options()).nest(2);
     doc.append(options).group()
@@ -10093,14 +9269,7 @@ fn build_where_condition_clause<'a>(where_clause: ast::WhereConditionClause) ->
 fn build_like_clause<'a>(like_clause: &ast::LikeClause) -> Doc<'a> {
     let mut doc = Doc::text("like");
 
-    if let Some(relation_name) = like_clause.relation_name_ref() {
-        doc = doc
-            .append(Doc::space())
-            .append(leading_comments(relation_name.syntax()));
-        if let Some(path) = relation_name.path_ref() {
-            doc = doc.append(build_path_ref(&path));
-        }
-    }
+    doc = append_commented_path_ref(doc, like_clause.relation_name_ref());
 
     let options: Vec<Doc<'a>> = like_clause
         .like_options()
@@ -10191,7 +9360,7 @@ fn build_values_rows<'a>(values: &ast::Values, nest_rows: bool) -> Doc<'a> {
 }
 
 fn build_row<'a>(row: ast::Row) -> Doc<'a> {
-    let mut doc = row
+    let doc = row
         .l_paren_token()
         .map(comments_before)
         .unwrap_or_else(Doc::nil)
@@ -10204,8 +9373,7 @@ fn build_row<'a>(row: ast::Row) -> Doc<'a> {
             body = body.append(comments_before(r_paren));
         }
     }
-    doc = doc.append(wrap_body(body)).append(Doc::text(")")).group();
-    doc
+    doc.append(wrap_body(body)).append(Doc::text(")")).group()
 }
 
 fn build_table<'a>(table: &ast::Table) -> Doc<'a> {
@@ -10222,12 +9390,7 @@ fn build_table<'a>(table: &ast::Table) -> Doc<'a> {
 
     let mut table_doc = Doc::text("table");
     if let Some(relation) = table.relation_name() {
-        table_doc = table_doc.append(
-            Doc::line_or_space()
-                .append(leading_comments(relation.syntax()))
-                .append(build_relation_name(relation))
-                .nest(2),
-        );
+        table_doc = append_nested_node(table_doc, relation, build_relation_name);
     }
     doc = doc.append(table_doc.group());
 
@@ -10612,7 +9775,7 @@ fn build_column_name_refs<'a>(columns: impl Iterator<Item = ast::ColumnNameRef>)
 }
 
 fn build_cte_column_list<'a>(columns: ast::ColumnList) -> Doc<'a> {
-    let mut doc = columns
+    let doc = columns
         .l_paren_token()
         .map(comments_before)
         .unwrap_or_else(Doc::nil)
@@ -10627,8 +9790,7 @@ fn build_cte_column_list<'a>(columns: ast::ColumnList) -> Doc<'a> {
     if let Some(r_paren) = columns.r_paren_token() {
         body = body.append(comments_before(r_paren));
     }
-    doc = doc.append(wrap_body(body)).append(Doc::text(")")).group();
-    doc
+    doc.append(wrap_body(body)).append(Doc::text(")")).group()
 }
 
 fn build_with_query<'a>(query: ast::WithQuery) -> Doc<'a> {
@@ -10777,20 +9939,10 @@ fn build_create_publication<'a>(stmt: &ast::CreatePublication) -> Doc<'a> {
             .append(build_name(publication.syntax()));
     }
     if let Some(clause) = stmt.publication_for_clause() {
-        doc = doc.append(
-            Doc::line_or_space()
-                .append(leading_comments(clause.syntax()))
-                .append(build_publication_for_clause(clause))
-                .nest(2),
-        );
+        doc = append_nested_node(doc, clause, build_publication_for_clause);
     }
     if let Some(params) = stmt.with_params() {
-        doc = doc.append(
-            Doc::line_or_space()
-                .append(leading_comments(params.syntax()))
-                .append(build_with_params(params))
-                .nest(2),
-        );
+        doc = append_nested_node(doc, params, build_with_params);
     }
     doc.append(build_semicolon(stmt.semicolon_token())).group()
 }
@@ -11004,12 +10156,7 @@ fn build_alter_foreign_table<'a>(stmt: &ast::AlterForeignTable) -> Doc<'a> {
                 .append(Doc::text(keyword));
         }
     }
-    if let Some(if_exists) = stmt.if_exists() {
-        doc = doc
-            .append(Doc::space())
-            .append(leading_comments(if_exists.syntax()))
-            .append(build_if_exists(if_exists));
-    }
+    doc = append_if_exists(doc, stmt.if_exists());
     if let Some(table) = stmt.table_relation_name() {
         doc = doc
             .append(Doc::space())
@@ -11038,27 +10185,12 @@ fn append_commented_name<'a>(mut doc: Doc<'a>, node: Option<impl AstNode>) -> Do
     doc
 }
 
-fn append_commented_constraint_ref<'a>(
-    mut doc: Doc<'a>,
-    constraint: Option<ast::ConstraintNameRef>,
-) -> Doc<'a> {
-    if let Some(constraint) = constraint {
-        doc = doc
-            .append(Doc::space())
-            .append(leading_comments(constraint.syntax()));
-        if let Some(path) = constraint.path_ref() {
-            doc = doc.append(build_path_ref(&path));
-        }
-    }
-    doc
-}
-
-fn append_commented_table_ref<'a>(mut doc: Doc<'a>, table: Option<ast::TableNameRef>) -> Doc<'a> {
-    if let Some(table) = table {
+fn append_commented_path_ref<'a>(mut doc: Doc<'a>, node: Option<impl ast::HasPathRef>) -> Doc<'a> {
+    if let Some(node) = node {
         doc = doc
             .append(Doc::space())
-            .append(leading_comments(table.syntax()));
-        if let Some(path) = table.path_ref() {
+            .append(leading_comments(node.syntax()));
+        if let Some(path) = node.path_ref() {
             doc = doc.append(build_path_ref(&path));
         }
     }
@@ -11071,16 +10203,7 @@ fn build_alter_foreign_table_action<'a>(action: ast::AlterTableAction) -> Doc<'a
         ast::AlterTableAction::AddColumn(node) => {
             let mut doc =
                 build_keyword_tokens([(node.add_token(), "add"), (node.column_token(), "column")]);
-            if let Some(if_not_exists) = node.if_not_exists() {
-                doc = doc
-                    .append(Doc::space())
-                    .append(leading_comments(if_not_exists.syntax()))
-                    .append(build_keyword_tokens([
-                        (if_not_exists.if_token(), "if"),
-                        (if_not_exists.not_token(), "not"),
-                        (if_not_exists.exists_token(), "exists"),
-                    ]));
-            }
+            doc = append_if_not_exists(doc, node.if_not_exists());
             doc = append_commented_name(doc, node.column_name());
             if let Some(ty) = node.ty() {
                 doc = doc
@@ -11089,16 +10212,14 @@ fn build_alter_foreign_table_action<'a>(action: ast::AlterTableAction) -> Doc<'a
                     .append(build_type(ty));
             }
             if let Some(options) = node.alter_option_list() {
-                let syntax = options.syntax().clone();
-                doc = append_column_clause(doc, &syntax, build_alter_option_list(&options));
+                doc =
+                    append_nested_clause(doc, options.syntax(), build_alter_option_list(&options));
             }
             if let Some(collate) = node.collate() {
-                let syntax = collate.syntax().clone();
-                doc = append_column_clause(doc, &syntax, build_collate_expr(collate));
+                doc = append_nested_node(doc, collate, build_collate_expr);
             }
             for constraint in node.constraints() {
-                let syntax = constraint.syntax().clone();
-                doc = append_column_clause(doc, &syntax, build_domain_constraint(constraint));
+                doc = append_nested_node(doc, constraint, build_domain_constraint);
             }
             doc.group()
         }
@@ -11124,12 +10245,7 @@ fn build_alter_foreign_table_action<'a>(action: ast::AlterTableAction) -> Doc<'a
             ]);
             doc = append_commented_name(doc, node.column_name_ref());
             if let Some(option) = node.option() {
-                doc = doc.append(
-                    Doc::line_or_space()
-                        .append(leading_comments(option.syntax()))
-                        .append(build_alter_column_option(option))
-                        .nest(2),
-                );
+                doc = append_nested_node(doc, option, build_alter_column_option);
             }
             doc.group()
         }
@@ -11138,7 +10254,7 @@ fn build_alter_foreign_table_action<'a>(action: ast::AlterTableAction) -> Doc<'a
                 (node.alter_token(), "alter"),
                 (node.constraint_token(), "constraint"),
             ]);
-            doc = append_commented_constraint_ref(doc, node.constraint_name_ref());
+            doc = append_commented_path_ref(doc, node.constraint_name_ref());
             for option in node.constraint_options() {
                 doc = doc
                     .append(Doc::space())
@@ -11152,36 +10268,23 @@ fn build_alter_foreign_table_action<'a>(action: ast::AlterTableAction) -> Doc<'a
                 (node.attach_token(), "attach"),
                 (node.partition_token(), "partition"),
             ]);
-            doc = append_commented_table_ref(doc, node.table_name_ref());
+            doc = append_commented_path_ref(doc, node.table_name_ref());
             if let Some(kind) = node.partition_type() {
-                doc = doc.append(
-                    Doc::line_or_space()
-                        .append(leading_comments(kind.syntax()))
-                        .append(build_create_table_partition_type(kind))
-                        .nest(2),
-                );
+                doc = append_nested_node(doc, kind, build_create_table_partition_type);
             }
             doc.group()
         }
         ast::AlterTableAction::ClusterOn(node) => {
-            let mut doc =
+            let doc =
                 build_keyword_tokens([(node.cluster_token(), "cluster"), (node.on_token(), "on")]);
-            if let Some(index) = node.index_ref() {
-                doc = doc
-                    .append(Doc::space())
-                    .append(leading_comments(index.syntax()));
-                if let Some(path) = index.path_ref() {
-                    doc = doc.append(build_path_ref(&path));
-                }
-            }
-            doc
+            append_commented_path_ref(doc, node.index_ref())
         }
         ast::AlterTableAction::DetachPartition(node) => {
             let mut doc = build_keyword_tokens([
                 (node.detach_token(), "detach"),
                 (node.partition_token(), "partition"),
             ]);
-            doc = append_commented_table_ref(doc, node.table_name_ref());
+            doc = append_commented_path_ref(doc, node.table_name_ref());
             if let Some(option) = node.detach_partition_option() {
                 doc = doc
                     .append(Doc::space())
@@ -11284,12 +10387,7 @@ fn build_alter_foreign_table_action<'a>(action: ast::AlterTableAction) -> Doc<'a
                 (node.drop_token(), "drop"),
                 (node.column_token(), "column"),
             ]);
-            if let Some(if_exists) = node.if_exists() {
-                doc = doc
-                    .append(Doc::space())
-                    .append(leading_comments(if_exists.syntax()))
-                    .append(build_if_exists(if_exists));
-            }
+            doc = append_if_exists(doc, node.if_exists());
             doc = append_commented_name(doc, node.column_name_ref());
             if let Some(behavior) = node.drop_behavior() {
                 doc = doc
@@ -11304,13 +10402,8 @@ fn build_alter_foreign_table_action<'a>(action: ast::AlterTableAction) -> Doc<'a
                 (node.drop_token(), "drop"),
                 (node.constraint_token(), "constraint"),
             ]);
-            if let Some(if_exists) = node.if_exists() {
-                doc = doc
-                    .append(Doc::space())
-                    .append(leading_comments(if_exists.syntax()))
-                    .append(build_if_exists(if_exists));
-            }
-            doc = append_commented_constraint_ref(doc, node.constraint_name_ref());
+            doc = append_if_exists(doc, node.if_exists());
+            doc = append_commented_path_ref(doc, node.constraint_name_ref());
             if let Some(behavior) = node.drop_behavior() {
                 doc = doc
                     .append(Doc::space())
@@ -11320,9 +10413,9 @@ fn build_alter_foreign_table_action<'a>(action: ast::AlterTableAction) -> Doc<'a
             doc
         }
         ast::AlterTableAction::InheritTable(node) => {
-            append_commented_table_ref(Doc::text("inherit"), node.table_name_ref())
+            append_commented_path_ref(Doc::text("inherit"), node.table_name_ref())
         }
-        ast::AlterTableAction::NoInheritTable(node) => append_commented_table_ref(
+        ast::AlterTableAction::NoInheritTable(node) => append_commented_path_ref(
             build_keyword_tokens([(node.no_token(), "no"), (node.inherit_token(), "inherit")]),
             node.table_name_ref(),
         ),
@@ -11360,7 +10453,7 @@ fn build_alter_foreign_table_action<'a>(action: ast::AlterTableAction) -> Doc<'a
                 (node.rename_token(), "rename"),
                 (node.constraint_token(), "constraint"),
             ]);
-            doc = append_commented_constraint_ref(doc, node.constraint_name_ref());
+            doc = append_commented_path_ref(doc, node.constraint_name_ref());
             if let Some(to) = node.to_token() {
                 doc = doc
                     .append(Doc::space())
@@ -11423,7 +10516,7 @@ fn build_alter_foreign_table_action<'a>(action: ast::AlterTableAction) -> Doc<'a
             });
             build_rename_to(node.to_token(), target)
         }
-        ast::AlterTableAction::ValidateConstraint(node) => append_commented_constraint_ref(
+        ast::AlterTableAction::ValidateConstraint(node) => append_commented_path_ref(
             build_keyword_tokens([
                 (node.validate_token(), "validate"),
                 (node.constraint_token(), "constraint"),
@@ -11462,7 +10555,7 @@ fn build_alter_foreign_table_action<'a>(action: ast::AlterTableAction) -> Doc<'a
                 (node.split_token(), "split"),
                 (node.partition_token(), "partition"),
             ]);
-            doc = append_commented_table_ref(doc, node.table_name_ref());
+            doc = append_commented_path_ref(doc, node.table_name_ref());
             if let Some(into) = node.into_token() {
                 doc = doc
                     .append(Doc::space())
@@ -11502,28 +10595,16 @@ fn build_alter_column_option<'a>(option: ast::AlterColumnOption) -> Doc<'a> {
             build_keyword_tokens([(n.no_token(), "no"), (n.inherit_token(), "inherit")])
         }
         ast::AlterColumnOption::DropExpression(n) => {
-            let mut doc = build_keyword_tokens([
+            let doc = build_keyword_tokens([
                 (n.drop_token(), "drop"),
                 (n.expression_token(), "expression"),
             ]);
-            if let Some(x) = n.if_exists() {
-                doc = doc
-                    .append(Doc::space())
-                    .append(leading_comments(x.syntax()))
-                    .append(build_if_exists(x));
-            }
-            doc
+            append_if_exists(doc, n.if_exists())
         }
         ast::AlterColumnOption::DropIdentity(n) => {
-            let mut doc =
+            let doc =
                 build_keyword_tokens([(n.drop_token(), "drop"), (n.identity_token(), "identity")]);
-            if let Some(x) = n.if_exists() {
-                doc = doc
-                    .append(Doc::space())
-                    .append(leading_comments(x.syntax()))
-                    .append(build_if_exists(x));
-            }
-            doc
+            append_if_exists(doc, n.if_exists())
         }
         ast::AlterColumnOption::ResetOptions(n) => {
             let mut doc = Doc::text("reset");
@@ -11551,12 +10632,7 @@ fn build_alter_column_option<'a>(option: ast::AlterColumnOption) -> Doc<'a> {
             let mut doc =
                 build_keyword_tokens([(n.set_token(), "set"), (n.default_token(), "default")]);
             if let Some(expr) = n.expr() {
-                doc = doc.append(
-                    Doc::line_or_space()
-                        .append(leading_comments(expr.syntax()))
-                        .append(build_expr(expr))
-                        .nest(2),
-                );
+                doc = append_nested_node(doc, expr, build_expr);
             }
             doc.group()
         }
@@ -11689,27 +10765,16 @@ fn build_alter_column_option<'a>(option: ast::AlterColumnOption) -> Doc<'a> {
                     .append(build_type(ty));
             }
             if let Some(collate) = n.collate() {
-                doc = doc.append(
-                    Doc::line_or_space()
-                        .append(leading_comments(collate.syntax()))
-                        .append(build_collate_expr(collate))
-                        .nest(2),
-                );
+                doc = append_nested_node(doc, collate, build_collate_expr);
             }
             if let Some(using) = n.using_expr() {
-                doc = doc.append(
-                    Doc::line_or_space()
-                        .append(leading_comments(using.syntax()))
-                        .append(build_keyword_tokens([(using.using_token(), "using")]))
-                        .nest(2),
+                doc = append_nested_clause(
+                    doc,
+                    using.syntax(),
+                    build_keyword_tokens([(using.using_token(), "using")]),
                 );
                 if let Some(expr) = using.expr() {
-                    doc = doc.append(
-                        Doc::line_or_space()
-                            .append(leading_comments(expr.syntax()))
-                            .append(build_expr(expr))
-                            .nest(2),
-                    );
+                    doc = append_nested_node(doc, expr, build_expr);
                 }
             }
             doc.group()
@@ -11717,12 +10782,7 @@ fn build_alter_column_option<'a>(option: ast::AlterColumnOption) -> Doc<'a> {
         ast::AlterColumnOption::SetGeneratedOptions(n) => {
             let mut doc = Doc::nil();
             for x in n.set_generated_options() {
-                doc = doc.append(
-                    Doc::line_or_space()
-                        .append(leading_comments(x.syntax()))
-                        .append(build_set_generated_option(x))
-                        .nest(2),
-                );
+                doc = append_nested_node(doc, x, build_set_generated_option);
             }
             doc.group()
         }
@@ -11787,14 +10847,9 @@ fn build_partition_list<'a>(list: ast::PartitionList) -> Doc<'a> {
     let items = list.partitions().map(|partition| {
         let syntax = partition.syntax().clone();
         let mut doc = build_keyword_tokens([(partition.partition_token(), "partition")]);
-        doc = append_commented_table_ref(doc, partition.table_name_ref());
+        doc = append_commented_path_ref(doc, partition.table_name_ref());
         if let Some(kind) = partition.partition_type() {
-            doc = doc.append(
-                Doc::line_or_space()
-                    .append(leading_comments(kind.syntax()))
-                    .append(build_create_table_partition_type(kind))
-                    .nest(2),
-            );
+            doc = append_nested_node(doc, kind, build_create_table_partition_type);
         }
         (leading_comments(&syntax).append(doc.group()), syntax)
     });
@@ -11884,12 +10939,7 @@ fn build_alter_foreign_data_wrapper<'a>(stmt: &ast::AlterForeignDataWrapper) ->
             }
             ast::AlterForeignDataWrapperAction::OwnerTo(owner) => build_owner_to_role(&owner),
         };
-        doc = doc.append(
-            Doc::line_or_space()
-                .append(leading_comments(&action_syntax))
-                .append(action_doc)
-                .nest(2),
-        );
+        doc = append_nested_clause(doc, &action_syntax, action_doc);
     }
     doc.group().append(build_semicolon(stmt.semicolon_token()))
 }
@@ -11931,13 +10981,13 @@ fn build_fdw_option<'a>(option: ast::FdwOption) -> Doc<'a> {
                 .group()
         }
         ast::FdwOption::OptionConnection(node) => {
-            build_fdw_function_option("connection", node.function_name_ref())
+            append_commented_path_ref(Doc::text("connection"), node.function_name_ref())
         }
         ast::FdwOption::OptionHandler(node) => {
-            build_fdw_function_option("handler", node.function_name_ref())
+            append_commented_path_ref(Doc::text("handler"), node.function_name_ref())
         }
         ast::FdwOption::OptionValidator(node) => {
-            build_fdw_function_option("validator", node.function_name_ref())
+            append_commented_path_ref(Doc::text("validator"), node.function_name_ref())
         }
         ast::FdwOption::OptionNoConnection(node) => build_keyword_tokens([
             (node.no_token(), "no"),
@@ -11953,22 +11003,6 @@ fn build_fdw_option<'a>(option: ast::FdwOption) -> Doc<'a> {
     }
 }
 
-fn build_fdw_function_option<'a>(
-    keyword: &'static str,
-    function: Option<ast::FunctionNameRef>,
-) -> Doc<'a> {
-    let mut doc = Doc::text(keyword);
-    if let Some(function) = function {
-        doc = doc
-            .append(Doc::space())
-            .append(leading_comments(function.syntax()));
-        if let Some(path) = function.path_ref() {
-            doc = doc.append(build_path_ref(&path));
-        }
-    }
-    doc
-}
-
 fn build_alter_function<'a>(stmt: &ast::AlterFunction) -> Doc<'a> {
     let mut doc = Doc::text("alter");
     if let Some(token) = stmt.function_token() {
@@ -12014,12 +11048,7 @@ fn build_alter_function<'a>(stmt: &ast::AlterFunction) -> Doc<'a> {
             ast::AlterFunctionAction::OwnerTo(node) => build_owner_to_role(&node),
             ast::AlterFunctionAction::SetSchema(node) => build_set_schema(&node),
         };
-        doc = doc.append(
-            Doc::line_or_space()
-                .append(leading_comments(&action_syntax))
-                .append(action_doc)
-                .nest(2),
-        );
+        doc = append_nested_clause(doc, &action_syntax, action_doc);
     }
     if let Some(token) = stmt.restrict_token() {
         doc = doc.append(
@@ -12073,12 +11102,7 @@ fn build_alter_procedure<'a>(stmt: &ast::AlterProcedure) -> Doc<'a> {
             }
             ast::AlterProcedureAction::SetSchema(n) => build_set_schema(n),
         };
-        doc = doc.append(
-            Doc::line_or_space()
-                .append(leading_comments(action.syntax()))
-                .append(action_doc)
-                .nest(2),
-        );
+        doc = append_nested_clause(doc, action.syntax(), action_doc);
     }
     append_restrict(doc, stmt.restrict_token())
         .group()
@@ -12126,12 +11150,7 @@ fn build_alter_routine<'a>(stmt: &ast::AlterRoutine) -> Doc<'a> {
             }
             ast::AlterRoutineAction::SetSchema(n) => build_set_schema(n),
         };
-        doc = doc.append(
-            Doc::line_or_space()
-                .append(leading_comments(action.syntax()))
-                .append(action_doc)
-                .nest(2),
-        );
+        doc = append_nested_clause(doc, action.syntax(), action_doc);
     }
     append_restrict(doc, stmt.restrict_token())
         .group()
@@ -12166,30 +11185,17 @@ fn build_alter_rule<'a>(stmt: &ast::AlterRule) -> Doc<'a> {
     }
     if let Some(on) = stmt.on_relation() {
         let mut part = Doc::text("on");
-        if let Some(relation) = on.relation_name_ref() {
-            part = part
-                .append(Doc::space())
-                .append(leading_comments(relation.syntax()));
-            if let Some(path) = relation.path_ref() {
-                part = part.append(build_path_ref(&path));
-            }
-        }
-        doc = doc.append(
-            Doc::line_or_space()
-                .append(leading_comments(on.syntax()))
-                .append(part)
-                .nest(2),
-        );
+        part = append_commented_path_ref(part, on.relation_name_ref());
+        doc = append_nested_clause(doc, on.syntax(), part);
     }
     if let Some(rename) = stmt.rule_rename_to() {
         let target = rename
             .rule()
             .map(|rule| leading_comments(rule.syntax()).append(build_name(rule.syntax())));
-        doc = doc.append(
-            Doc::line_or_space()
-                .append(leading_comments(rename.syntax()))
-                .append(build_rename_to(rename.to_token(), target))
-                .nest(2),
+        doc = append_nested_clause(
+            doc,
+            rename.syntax(),
+            build_rename_to(rename.to_token(), target),
         );
     }
     doc.group().append(build_semicolon(stmt.semicolon_token()))
@@ -12219,12 +11225,7 @@ fn build_alter_schema<'a>(stmt: &ast::AlterSchema) -> Doc<'a> {
                 build_rename_to(rename.to_token(), target)
             }
         };
-        doc = doc.append(
-            Doc::line_or_space()
-                .append(leading_comments(action.syntax()))
-                .append(action_doc)
-                .nest(2),
-        );
+        doc = append_nested_clause(doc, action.syntax(), action_doc);
     }
     doc.group().append(build_semicolon(stmt.semicolon_token()))
 }
@@ -12237,20 +11238,8 @@ fn build_alter_sequence<'a>(stmt: &ast::AlterSequence) -> Doc<'a> {
             .append(leading_comments_token(&token))
             .append(Doc::text("sequence"));
     }
-    if let Some(if_exists) = stmt.if_exists() {
-        doc = doc
-            .append(Doc::space())
-            .append(leading_comments(if_exists.syntax()))
-            .append(build_if_exists(if_exists));
-    }
-    if let Some(sequence) = stmt.sequence_ref() {
-        doc = doc
-            .append(Doc::space())
-            .append(leading_comments(sequence.syntax()));
-        if let Some(path) = sequence.path_ref() {
-            doc = doc.append(build_path_ref(&path));
-        }
-    }
+    doc = append_if_exists(doc, stmt.if_exists());
+    doc = append_commented_path_ref(doc, stmt.sequence_ref());
     for action in stmt.actions() {
         let part = leading_comments(action.syntax());
         let part = part.append(match action {
@@ -12310,12 +11299,7 @@ fn build_alter_server<'a>(stmt: &ast::AlterServer) -> Doc<'a> {
                 append_optional_literal(Doc::text("version"), version.literal())
             }
         };
-        doc = doc.append(
-            Doc::line_or_space()
-                .append(leading_comments(action.syntax()))
-                .append(action_doc)
-                .nest(2),
-        );
+        doc = append_nested_clause(doc, action.syntax(), action_doc);
     }
     doc.group().append(build_semicolon(stmt.semicolon_token()))
 }
@@ -12328,14 +11312,7 @@ fn build_alter_statistics<'a>(stmt: &ast::AlterStatistics) -> Doc<'a> {
             .append(leading_comments_token(&token))
             .append(Doc::text("statistics"));
     }
-    if let Some(statistics) = stmt.statistics_ref() {
-        doc = doc
-            .append(Doc::space())
-            .append(leading_comments(statistics.syntax()));
-        if let Some(path) = statistics.path_ref() {
-            doc = doc.append(build_path_ref(&path));
-        }
-    }
+    doc = append_commented_path_ref(doc, stmt.statistics_ref());
     if let Some(action) = stmt.action() {
         let action_doc = match &action {
             ast::AlterStatisticsAction::OwnerTo(action) => build_owner_to_role(action),
@@ -12370,12 +11347,7 @@ fn build_alter_statistics<'a>(stmt: &ast::AlterStatistics) -> Doc<'a> {
                 build_rename_to(action.to_token(), target)
             }
         };
-        doc = doc.append(
-            Doc::line_or_space()
-                .append(leading_comments(action.syntax()))
-                .append(action_doc)
-                .nest(2),
-        );
+        doc = append_nested_clause(doc, action.syntax(), action_doc);
     }
     doc.group().append(build_semicolon(stmt.semicolon_token()))
 }
@@ -12393,12 +11365,7 @@ fn build_alter_system<'a>(stmt: &ast::AlterSystem) -> Doc<'a> {
             ast::AlterSystemAction::ResetConfigParam(action) => build_reset_config_param(action),
             ast::AlterSystemAction::SetConfigParam(action) => build_set_config_param(action),
         };
-        doc = doc.append(
-            Doc::line_or_space()
-                .append(leading_comments(action.syntax()))
-                .append(action_doc)
-                .nest(2),
-        );
+        doc = append_nested_clause(doc, action.syntax(), action_doc);
     }
     doc.group().append(build_semicolon(stmt.semicolon_token()))
 }
@@ -12417,12 +11384,7 @@ fn build_alter_table<'a>(stmt: &ast::AlterTable) -> Doc<'a> {
             .append(leading_comments(all.syntax()))
             .append(build_all_in_tablespace(all));
     } else {
-        if let Some(if_exists) = stmt.if_exists() {
-            doc = doc
-                .append(Doc::space())
-                .append(leading_comments(if_exists.syntax()))
-                .append(build_if_exists(if_exists));
-        }
+        doc = append_if_exists(doc, stmt.if_exists());
         if let Some(table) = stmt.table_relation_name() {
             doc = doc
                 .append(Doc::space())
@@ -12477,12 +11439,7 @@ fn build_alter_tablespace<'a>(stmt: &ast::AlterTablespace) -> Doc<'a> {
                 build_rename_to(action.to_token(), target)
             }
         };
-        doc = doc.append(
-            Doc::line_or_space()
-                .append(leading_comments(action.syntax()))
-                .append(action_doc)
-                .nest(2),
-        );
+        doc = append_nested_clause(doc, action.syntax(), action_doc);
     }
     doc.group().append(build_semicolon(stmt.semicolon_token()))
 }
@@ -12494,14 +11451,7 @@ fn build_alter_text_search_configuration<'a>(stmt: &ast::AlterTextSearchConfigur
         stmt.configuration_token(),
         "configuration",
     );
-    if let Some(name) = stmt.text_search_configuration_ref() {
-        doc = doc
-            .append(Doc::space())
-            .append(leading_comments(name.syntax()));
-        if let Some(path) = name.path_ref() {
-            doc = doc.append(build_path_ref(&path));
-        }
-    }
+    doc = append_commented_path_ref(doc, stmt.text_search_configuration_ref());
     if let Some(action) = stmt.action() {
         let action_doc = match &action {
             ast::AlterTextSearchConfigurationAction::AddMapping(action) => {
@@ -12526,12 +11476,7 @@ fn build_alter_text_search_configuration<'a>(stmt: &ast::AlterTextSearchConfigur
                 build_rename_to(action.to_token(), target)
             }
         };
-        doc = doc.append(
-            Doc::line_or_space()
-                .append(leading_comments(action.syntax()))
-                .append(action_doc)
-                .nest(2),
-        );
+        doc = append_nested_clause(doc, action.syntax(), action_doc);
     }
     doc.group().append(build_semicolon(stmt.semicolon_token()))
 }
@@ -12543,14 +11488,7 @@ fn build_alter_text_search_dictionary<'a>(stmt: &ast::AlterTextSearchDictionary)
         stmt.dictionary_token(),
         "dictionary",
     );
-    if let Some(name) = stmt.text_search_dictionary_ref() {
-        doc = doc
-            .append(Doc::space())
-            .append(leading_comments(name.syntax()));
-        if let Some(path) = name.path_ref() {
-            doc = doc.append(build_path_ref(&path));
-        }
-    }
+    doc = append_commented_path_ref(doc, stmt.text_search_dictionary_ref());
     if let Some(action) = stmt.action() {
         let is_attribute_list = matches!(
             &action,
@@ -12590,14 +11528,7 @@ fn build_alter_text_search_parser<'a>(stmt: &ast::AlterTextSearchParser) -> Doc<
         stmt.parser_token(),
         "parser",
     );
-    if let Some(name) = stmt.text_search_parser_ref() {
-        doc = doc
-            .append(Doc::space())
-            .append(leading_comments(name.syntax()));
-        if let Some(path) = name.path_ref() {
-            doc = doc.append(build_path_ref(&path));
-        }
-    }
+    doc = append_commented_path_ref(doc, stmt.text_search_parser_ref());
     if let Some(action) = stmt.action() {
         let action_doc = match &action {
             ast::AlterTextSearchParserAction::SetSchema(action) => build_set_schema(action),
@@ -12612,12 +11543,7 @@ fn build_alter_text_search_parser<'a>(stmt: &ast::AlterTextSearchParser) -> Doc<
                 build_rename_to(action.to_token(), target)
             }
         };
-        doc = doc.append(
-            Doc::line_or_space()
-                .append(leading_comments(action.syntax()))
-                .append(action_doc)
-                .nest(2),
-        );
+        doc = append_nested_clause(doc, action.syntax(), action_doc);
     }
     doc.group().append(build_semicolon(stmt.semicolon_token()))
 }
@@ -12629,14 +11555,7 @@ fn build_alter_text_search_template<'a>(stmt: &ast::AlterTextSearchTemplate) ->
         stmt.template_token(),
         "template",
     );
-    if let Some(name) = stmt.text_search_template_ref() {
-        doc = doc
-            .append(Doc::space())
-            .append(leading_comments(name.syntax()));
-        if let Some(path) = name.path_ref() {
-            doc = doc.append(build_path_ref(&path));
-        }
-    }
+    doc = append_commented_path_ref(doc, stmt.text_search_template_ref());
     if let Some(action) = stmt.action() {
         let action_doc = match &action {
             ast::AlterTextSearchTemplateAction::SetSchema(action) => build_set_schema(action),
@@ -12651,12 +11570,7 @@ fn build_alter_text_search_template<'a>(stmt: &ast::AlterTextSearchTemplate) ->
                 build_rename_to(action.to_token(), target)
             }
         };
-        doc = doc.append(
-            Doc::line_or_space()
-                .append(leading_comments(action.syntax()))
-                .append(action_doc)
-                .nest(2),
-        );
+        doc = append_nested_clause(doc, action.syntax(), action_doc);
     }
     doc.group().append(build_semicolon(stmt.semicolon_token()))
 }
@@ -12677,20 +11591,8 @@ fn build_alter_trigger<'a>(stmt: &ast::AlterTrigger) -> Doc<'a> {
     }
     if let Some(on) = stmt.on_relation() {
         let mut on_doc = Doc::text("on");
-        if let Some(relation) = on.relation_name_ref() {
-            on_doc = on_doc
-                .append(Doc::space())
-                .append(leading_comments(relation.syntax()));
-            if let Some(path) = relation.path_ref() {
-                on_doc = on_doc.append(build_path_ref(&path));
-            }
-        }
-        doc = doc.append(
-            Doc::line_or_space()
-                .append(leading_comments(on.syntax()))
-                .append(on_doc)
-                .nest(2),
-        );
+        on_doc = append_commented_path_ref(on_doc, on.relation_name_ref());
+        doc = append_nested_clause(doc, on.syntax(), on_doc);
     }
     if let Some(action) = stmt.action() {
         let action_doc = match &action {
@@ -12715,12 +11617,7 @@ fn build_alter_trigger<'a>(stmt: &ast::AlterTrigger) -> Doc<'a> {
                 build_rename_to(action.to_token(), target)
             }
         };
-        doc = doc.append(
-            Doc::line_or_space()
-                .append(leading_comments(action.syntax()))
-                .append(action_doc)
-                .nest(2),
-        );
+        doc = append_nested_clause(doc, action.syntax(), action_doc);
     }
     doc.group().append(build_semicolon(stmt.semicolon_token()))
 }
@@ -12733,22 +11630,9 @@ fn build_alter_type<'a>(stmt: &ast::AlterType) -> Doc<'a> {
             .append(leading_comments_token(&type_token))
             .append(Doc::text("type"));
     }
-    if let Some(name) = stmt.type_name_ref() {
-        doc = doc
-            .append(Doc::space())
-            .append(leading_comments(name.syntax()));
-        if let Some(path) = name.path_ref() {
-            doc = doc.append(build_path_ref(&path));
-        }
-    }
+    doc = append_commented_path_ref(doc, stmt.type_name_ref());
     if let Some(action) = stmt.action() {
-        let syntax = action.syntax().clone();
-        doc = doc.append(
-            Doc::line_or_space()
-                .append(leading_comments(&syntax))
-                .append(build_alter_type_action(action))
-                .nest(2),
-        );
+        doc = append_nested_node(doc, action, build_alter_type_action);
     }
     doc.group().append(build_semicolon(stmt.semicolon_token()))
 }
@@ -12760,12 +11644,7 @@ fn build_alter_type_action<'a>(action: ast::AlterTypeAction) -> Doc<'a> {
                 (action.add_token(), "add"),
                 (action.value_token(), "value"),
             ]);
-            if let Some(if_not_exists) = action.if_not_exists() {
-                doc = doc
-                    .append(Doc::space())
-                    .append(leading_comments(if_not_exists.syntax()))
-                    .append(build_keyword_node(if_not_exists.syntax()));
-            }
+            doc = append_if_not_exists(doc, action.if_not_exists());
             if let Some(value) = action.literal() {
                 doc = doc
                     .append(Doc::space())
@@ -12784,12 +11663,7 @@ fn build_alter_type_action<'a>(action: ast::AlterTypeAction) -> Doc<'a> {
                         position.literal(),
                     ),
                 };
-                doc = doc.append(
-                    Doc::line_or_space()
-                        .append(leading_comments(&syntax))
-                        .append(position_doc)
-                        .nest(2),
-                );
+                doc = append_nested_clause(doc, &syntax, position_doc);
             }
             doc.group()
         }
@@ -12924,12 +11798,7 @@ fn build_alter_type_attribute_action<'a>(action: ast::AlterTypeAttributeAction)
                 (action.drop_token(), "drop"),
                 (action.attribute_token(), "attribute"),
             ]);
-            if let Some(if_exists) = action.if_exists() {
-                doc = doc
-                    .append(Doc::space())
-                    .append(leading_comments(if_exists.syntax()))
-                    .append(build_if_exists(if_exists));
-            }
+            doc = append_if_exists(doc, action.if_exists());
             if let Some(name) = action.composite_field_ref() {
                 doc = doc
                     .append(Doc::space())
@@ -12954,12 +11823,7 @@ fn append_alter_type_attribute_tail<'a>(
             .append(build_type(ty));
     }
     if let Some(collate) = collate {
-        doc = doc.append(
-            Doc::line_or_space()
-                .append(leading_comments(collate.syntax()))
-                .append(build_collate_expr(collate))
-                .nest(2),
-        );
+        doc = append_nested_node(doc, collate, build_collate_expr);
     }
     append_inline_drop_behavior(doc, behavior).group()
 }
@@ -13007,12 +11871,7 @@ fn build_alter_user<'a>(stmt: &ast::AlterUser) -> Doc<'a> {
                 .append(leading_comments(name.syntax()))
                 .append(build_name(name.syntax()));
         }
-        doc = doc.append(
-            Doc::line_or_space()
-                .append(leading_comments(database.syntax()))
-                .append(database_doc)
-                .nest(2),
-        );
+        doc = append_nested_clause(doc, database.syntax(), database_doc);
     }
     if let Some(action) = stmt.action() {
         let action_doc = match &action {
@@ -13026,12 +11885,7 @@ fn build_alter_user<'a>(stmt: &ast::AlterUser) -> Doc<'a> {
             }
             ast::AlterUserAction::SetConfigParam(action) => build_set_config_param(action),
         };
-        doc = doc.append(
-            Doc::line_or_space()
-                .append(leading_comments(action.syntax()))
-                .append(action_doc)
-                .nest(2),
-        );
+        doc = append_nested_clause(doc, action.syntax(), action_doc);
     }
     doc.group().append(build_semicolon(stmt.semicolon_token()))
 }
@@ -13057,20 +11911,10 @@ fn build_alter_user_mapping<'a>(stmt: &ast::AlterUserMapping) -> Doc<'a> {
             .append(build_role_ref(&role));
     }
     if let Some(server) = stmt.server_clause() {
-        doc = doc.append(
-            Doc::line_or_space()
-                .append(leading_comments(server.syntax()))
-                .append(build_server_clause(server))
-                .nest(2),
-        );
+        doc = append_nested_node(doc, server, build_server_clause);
     }
     if let Some(options) = stmt.alter_option_list() {
-        doc = doc.append(
-            Doc::line_or_space()
-                .append(leading_comments(options.syntax()))
-                .append(build_alter_option_list(&options))
-                .nest(2),
-        );
+        doc = append_nested_clause(doc, options.syntax(), build_alter_option_list(&options));
     }
     doc.group().append(build_semicolon(stmt.semicolon_token()))
 }
@@ -13181,14 +12025,7 @@ fn build_alter_mapping<'a>(action: &ast::AlterMapping) -> Doc<'a> {
 
 fn build_replace_dictionary<'a>(replace: ast::ReplaceDictionary) -> Doc<'a> {
     let mut doc = Doc::text("replace");
-    if let Some(before) = replace.before() {
-        doc = doc
-            .append(Doc::space())
-            .append(leading_comments(before.syntax()));
-        if let Some(path) = before.path_ref() {
-            doc = doc.append(build_path_ref(&path));
-        }
-    }
+    doc = append_commented_path_ref(doc, replace.before());
     if let Some(with) = replace.with_token() {
         doc = doc
             .append(Doc::line_or_space())
@@ -13214,12 +12051,7 @@ fn build_drop_mapping<'a>(action: &ast::DropMapping) -> Doc<'a> {
             .append(leading_comments_token(&mapping))
             .append(Doc::text("mapping"));
     }
-    if let Some(if_exists) = action.if_exists() {
-        doc = doc
-            .append(Doc::line_or_space())
-            .append(leading_comments(if_exists.syntax()))
-            .append(build_if_exists(if_exists));
-    }
+    doc = append_if_exists(doc, action.if_exists());
     if let Some(for_token) = action.for_token() {
         doc = doc
             .append(Doc::line_or_space())
@@ -13260,12 +12092,7 @@ fn build_alter_role<'a>(stmt: &ast::AlterRole) -> Doc<'a> {
                 .append(leading_comments(name.syntax()))
                 .append(build_name(name.syntax()));
         }
-        doc = doc.append(
-            Doc::line_or_space()
-                .append(leading_comments(db.syntax()))
-                .append(part)
-                .nest(2),
-        );
+        doc = append_nested_clause(doc, db.syntax(), part);
     }
     if let Some(action) = stmt.action() {
         let action_doc = match &action {
@@ -13279,12 +12106,7 @@ fn build_alter_role<'a>(stmt: &ast::AlterRole) -> Doc<'a> {
                 build_rename_to(n.to_token(), target)
             }
         };
-        doc = doc.append(
-            Doc::line_or_space()
-                .append(leading_comments(action.syntax()))
-                .append(action_doc)
-                .nest(2),
-        );
+        doc = append_nested_clause(doc, action.syntax(), action_doc);
     }
     doc.group().append(build_semicolon(stmt.semicolon_token()))
 }
@@ -13395,28 +12217,10 @@ fn build_alter_property_graph<'a>(stmt: &ast::AlterPropertyGraph) -> Doc<'a> {
             .append(leading_comments_token(&token))
             .append(Doc::text("graph"));
     }
-    if let Some(x) = stmt.if_exists() {
-        doc = doc
-            .append(Doc::space())
-            .append(leading_comments(x.syntax()))
-            .append(build_if_exists(x));
-    }
-    if let Some(x) = stmt.property_graph_ref() {
-        doc = doc
-            .append(Doc::space())
-            .append(leading_comments(x.syntax()));
-        if let Some(path) = x.path_ref() {
-            doc = doc.append(build_path_ref(&path));
-        }
-    }
+    doc = append_if_exists(doc, stmt.if_exists());
+    doc = append_commented_path_ref(doc, stmt.property_graph_ref());
     if let Some(action) = stmt.action() {
-        let syntax = action.syntax().clone();
-        doc = doc.append(
-            Doc::line_or_space()
-                .append(leading_comments(&syntax))
-                .append(build_alter_property_graph_action(action))
-                .nest(2),
-        );
+        doc = append_nested_node(doc, action, build_alter_property_graph_action);
     }
     doc.group().append(build_semicolon(stmt.semicolon_token()))
 }
@@ -13574,12 +12378,7 @@ fn build_alter_element_labels<'a>(n: ast::AlterVertexEdgeLabels) -> Doc<'a> {
                 .append(leading_comments(props.syntax()))
                 .append(build_element_properties(props));
         }
-        doc = doc.append(
-            Doc::line_or_space()
-                .append(leading_comments(x.syntax()))
-                .append(part)
-                .nest(2),
-        );
+        doc = append_nested_clause(doc, x.syntax(), part);
     }
     doc.group()
 }
@@ -13785,12 +12584,7 @@ fn build_vertex_table_def<'a>(n: ast::VertexTableDef) -> Doc<'a> {
             .append(build_element_key(x));
     }
     if let Some(x) = n.element_table_label_and_properties() {
-        doc = doc.append(
-            Doc::line_or_space()
-                .append(leading_comments(x.syntax()))
-                .append(build_element_label_properties(x))
-                .nest(2),
-        );
+        doc = append_nested_node(doc, x, build_element_label_properties);
     }
     doc.group()
 }
@@ -13845,42 +12639,35 @@ fn build_edge_table_def<'a>(n: ast::EdgeTableDef) -> Doc<'a> {
             .append(build_element_key(x));
     }
     if let Some(x) = n.source_vertex_table() {
-        doc = doc.append(
-            Doc::line_or_space()
-                .append(leading_comments(x.syntax()))
-                .append(build_vertex_reference(
-                    x.source_token(),
-                    "source",
-                    x.key_token(),
-                    x.column_ref_list(),
-                    x.references_table(),
-                    x.vertex_table_ref(),
-                ))
-                .nest(2),
+        doc = append_nested_clause(
+            doc,
+            x.syntax(),
+            build_vertex_reference(
+                x.source_token(),
+                "source",
+                x.key_token(),
+                x.column_ref_list(),
+                x.references_table(),
+                x.vertex_table_ref(),
+            ),
         );
     }
     if let Some(x) = n.dest_vertex_table() {
-        doc = doc.append(
-            Doc::line_or_space()
-                .append(leading_comments(x.syntax()))
-                .append(build_vertex_reference(
-                    x.destination_token(),
-                    "destination",
-                    x.key_token(),
-                    x.column_ref_list(),
-                    x.references_table(),
-                    x.vertex_table_ref(),
-                ))
-                .nest(2),
+        doc = append_nested_clause(
+            doc,
+            x.syntax(),
+            build_vertex_reference(
+                x.destination_token(),
+                "destination",
+                x.key_token(),
+                x.column_ref_list(),
+                x.references_table(),
+                x.vertex_table_ref(),
+            ),
         );
     }
     if let Some(x) = n.element_table_label_and_properties() {
-        doc = doc.append(
-            Doc::line_or_space()
-                .append(leading_comments(x.syntax()))
-                .append(build_element_label_properties(x))
-                .nest(2),
-        );
+        doc = append_nested_node(doc, x, build_element_label_properties);
     }
     doc.group()
 }
@@ -14154,12 +12941,7 @@ fn build_alter_group<'a>(stmt: &ast::AlterGroup) -> Doc<'a> {
                 build_rename_to(node.to_token(), target)
             }
         };
-        doc = doc.append(
-            Doc::line_or_space()
-                .append(leading_comments(&action_syntax))
-                .append(action_doc)
-                .nest(2),
-        );
+        doc = append_nested_clause(doc, &action_syntax, action_doc);
     }
     doc.group().append(build_semicolon(stmt.semicolon_token()))
 }
@@ -14209,27 +12991,16 @@ fn build_all_in_tablespace<'a>(all: ast::AllInTablespace) -> Doc<'a> {
                 .append(leading_comments(roles.syntax()))
                 .append(build_role_ref_list(roles));
         }
-        doc = doc.append(
-            Doc::line_or_space()
-                .append(leading_comments(owned.syntax()))
-                .append(owned_doc)
-                .nest(2),
-        );
+        doc = append_nested_clause(doc, owned.syntax(), owned_doc);
     }
     if let Some(set) = all.set_tablespace() {
-        doc = doc.append(
-            Doc::line_or_space()
-                .append(leading_comments(set.syntax()))
-                .append(build_set_tablespace(set))
-                .nest(2),
-        );
+        doc = append_nested_node(doc, set, build_set_tablespace);
     }
     if let Some(nowait) = all.nowait() {
-        doc = doc.append(
-            Doc::line_or_space()
-                .append(leading_comments(nowait.syntax()))
-                .append(build_keyword_tokens([(nowait.nowait_token(), "nowait")]))
-                .nest(2),
+        doc = append_nested_clause(
+            doc,
+            nowait.syntax(),
+            build_keyword_tokens([(nowait.nowait_token(), "nowait")]),
         );
     }
     doc.group()
@@ -14244,35 +13015,12 @@ fn build_alter_index<'a>(stmt: &ast::AlterIndex) -> Doc<'a> {
             .append(Doc::text("index"));
     }
     if let Some(all) = stmt.all_in_tablespace() {
-        doc = doc.append(
-            Doc::line_or_space()
-                .append(leading_comments(all.syntax()))
-                .append(build_all_in_tablespace(all))
-                .nest(2),
-        );
+        doc = append_nested_node(doc, all, build_all_in_tablespace);
     } else {
-        if let Some(if_exists) = stmt.if_exists() {
-            doc = doc
-                .append(Doc::space())
-                .append(leading_comments(if_exists.syntax()))
-                .append(build_if_exists(if_exists));
-        }
-        if let Some(index) = stmt.index_ref() {
-            doc = doc
-                .append(Doc::space())
-                .append(leading_comments(index.syntax()));
-            if let Some(path) = index.path_ref() {
-                doc = doc.append(build_path_ref(&path));
-            }
-        }
+        doc = append_if_exists(doc, stmt.if_exists());
+        doc = append_commented_path_ref(doc, stmt.index_ref());
         if let Some(action) = stmt.action() {
-            let syntax = action.syntax().clone();
-            doc = doc.append(
-                Doc::line_or_space()
-                    .append(leading_comments(&syntax))
-                    .append(build_alter_index_action(action))
-                    .nest(2),
-            );
+            doc = append_nested_node(doc, action, build_alter_index_action);
         }
     }
     doc.group().append(build_semicolon(stmt.semicolon_token()))
@@ -14297,12 +13045,7 @@ fn build_alter_index_action<'a>(action: ast::AlterIndexAction) -> Doc<'a> {
                     .append(build_literal(number));
             }
             if let Some(options) = action.set_options() {
-                doc = doc.append(
-                    Doc::line_or_space()
-                        .append(leading_comments(options.syntax()))
-                        .append(build_set_options(&options))
-                        .nest(2),
-                );
+                doc = append_nested_clause(doc, options.syntax(), build_set_options(&options));
             } else if let Some(statistics) = action.set_statistics() {
                 let mut statistics_doc = build_keyword_tokens([
                     (statistics.set_token(), "set"),
@@ -14319,29 +13062,16 @@ fn build_alter_index_action<'a>(action: ast::AlterIndexAction) -> Doc<'a> {
                         .append(leading_comments_token(&default))
                         .append(Doc::text("default"));
                 }
-                doc = doc.append(
-                    Doc::line_or_space()
-                        .append(leading_comments(statistics.syntax()))
-                        .append(statistics_doc)
-                        .nest(2),
-                );
+                doc = append_nested_clause(doc, statistics.syntax(), statistics_doc);
             }
             doc.group()
         }
         ast::AlterIndexAction::AttachIndexPartition(action) => {
-            let mut doc = build_keyword_tokens([
+            let doc = build_keyword_tokens([
                 (action.attach_token(), "attach"),
                 (action.partition_token(), "partition"),
             ]);
-            if let Some(index) = action.index_ref() {
-                doc = doc
-                    .append(Doc::space())
-                    .append(leading_comments(index.syntax()));
-                if let Some(path) = index.path_ref() {
-                    doc = doc.append(build_path_ref(&path));
-                }
-            }
-            doc
+            append_commented_path_ref(doc, action.index_ref())
         }
         ast::AlterIndexAction::DependsOnExtension(action) => build_depends_on_extension(
             false,
@@ -14412,12 +13142,7 @@ fn build_alter_language<'a>(stmt: &ast::AlterLanguage) -> Doc<'a> {
             }
             ast::AlterLanguageAction::OwnerTo(action) => build_owner_to_role(action),
         };
-        doc = doc.append(
-            Doc::line_or_space()
-                .append(leading_comments(action.syntax()))
-                .append(action_doc)
-                .nest(2),
-        );
+        doc = append_nested_clause(doc, action.syntax(), action_doc);
     }
     doc.group().append(build_semicolon(stmt.semicolon_token()))
 }
@@ -14591,21 +13316,9 @@ fn build_alter_operator_class<'a>(stmt: &ast::AlterOperatorClass) -> Doc<'a> {
                 .append(Doc::text(keyword));
         }
     }
-    if let Some(class) = stmt.op_class_ref() {
-        doc = doc
-            .append(Doc::space())
-            .append(leading_comments(class.syntax()));
-        if let Some(path) = class.path_ref() {
-            doc = doc.append(build_path_ref(&path));
-        }
-    }
+    doc = append_commented_path_ref(doc, stmt.op_class_ref());
     if let Some(using) = stmt.using_method() {
-        doc = doc.append(
-            Doc::line_or_space()
-                .append(leading_comments(using.syntax()))
-                .append(build_using_method(using))
-                .nest(2),
-        );
+        doc = append_nested_node(doc, using, build_using_method);
     }
     if let Some(action) = stmt.action() {
         let action_doc = match &action {
@@ -14622,12 +13335,7 @@ fn build_alter_operator_class<'a>(stmt: &ast::AlterOperatorClass) -> Doc<'a> {
             ast::AlterOperatorClassAction::OwnerTo(action) => build_owner_to(action),
             ast::AlterOperatorClassAction::SetSchema(action) => build_set_schema(action),
         };
-        doc = doc.append(
-            Doc::line_or_space()
-                .append(leading_comments(action.syntax()))
-                .append(action_doc)
-                .nest(2),
-        );
+        doc = append_nested_clause(doc, action.syntax(), action_doc);
     }
     doc.group().append(build_semicolon(stmt.semicolon_token()))
 }
@@ -14645,21 +13353,9 @@ fn build_alter_operator_family<'a>(stmt: &ast::AlterOperatorFamily) -> Doc<'a> {
                 .append(Doc::text(keyword));
         }
     }
-    if let Some(family) = stmt.op_family_ref() {
-        doc = doc
-            .append(Doc::space())
-            .append(leading_comments(family.syntax()));
-        if let Some(path) = family.path_ref() {
-            doc = doc.append(build_path_ref(&path));
-        }
-    }
+    doc = append_commented_path_ref(doc, stmt.op_family_ref());
     if let Some(using) = stmt.using_method() {
-        doc = doc.append(
-            Doc::line_or_space()
-                .append(leading_comments(using.syntax()))
-                .append(build_using_method(using))
-                .nest(2),
-        );
+        doc = append_nested_node(doc, using, build_using_method);
     }
     if let Some(action) = stmt.action() {
         let action_doc = match &action {
@@ -14679,15 +13375,10 @@ fn build_alter_operator_family<'a>(stmt: &ast::AlterOperatorFamily) -> Doc<'a> {
                 });
                 build_rename_to(action.to_token(), target)
             }
-            ast::AlterOperatorFamilyAction::OwnerTo(action) => build_owner_to(action),
-            ast::AlterOperatorFamilyAction::SetSchema(action) => build_set_schema(action),
-        };
-        doc = doc.append(
-            Doc::line_or_space()
-                .append(leading_comments(action.syntax()))
-                .append(action_doc)
-                .nest(2),
-        );
+            ast::AlterOperatorFamilyAction::OwnerTo(action) => build_owner_to(action),
+            ast::AlterOperatorFamilyAction::SetSchema(action) => build_set_schema(action),
+        };
+        doc = append_nested_clause(doc, action.syntax(), action_doc);
     }
     doc.group().append(build_semicolon(stmt.semicolon_token()))
 }
@@ -14703,12 +13394,7 @@ fn build_add_op_class_options<'a>(action: &ast::AddOpClassOptions) -> Doc<'a> {
             )
         });
         if let Some(options) = build_comma_separated_docs(options) {
-            doc = doc.append(
-                Doc::line_or_space()
-                    .append(leading_comments(list.syntax()))
-                    .append(options)
-                    .nest(2),
-            );
+            doc = append_nested_clause(doc, list.syntax(), options);
         }
     }
     doc.group()
@@ -14815,20 +13501,12 @@ fn build_op_class_purpose<'a>(purpose: ast::OpClassPurpose) -> Doc<'a> {
             (purpose.search_token(), "search"),
         ]),
         ast::OpClassPurpose::OpClassForOrderBy(purpose) => {
-            let mut doc = build_keyword_tokens([
+            let doc = build_keyword_tokens([
                 (purpose.for_token(), "for"),
                 (purpose.order_token(), "order"),
                 (purpose.by_token(), "by"),
             ]);
-            if let Some(family) = purpose.op_family_ref() {
-                doc = doc
-                    .append(Doc::space())
-                    .append(leading_comments(family.syntax()));
-                if let Some(path) = family.path_ref() {
-                    doc = doc.append(build_path_ref(&path));
-                }
-            }
-            doc
+            append_commented_path_ref(doc, purpose.op_family_ref())
         }
     }
 }
@@ -14849,12 +13527,7 @@ fn build_drop_op_class_options<'a>(action: &ast::DropOpClassOptions) -> Doc<'a>
             (leading_comments(&syntax).append(option_doc), syntax)
         });
         if let Some(options) = build_comma_separated_docs(options) {
-            doc = doc.append(
-                Doc::line_or_space()
-                    .append(leading_comments(list.syntax()))
-                    .append(options)
-                    .nest(2),
-            );
+            doc = append_nested_clause(doc, list.syntax(), options);
         }
     }
     doc.group()
@@ -14897,20 +13570,8 @@ fn build_alter_policy<'a>(stmt: &ast::AlterPolicy) -> Doc<'a> {
     }
     if let Some(on) = stmt.on_table() {
         let mut on_doc = Doc::text("on");
-        if let Some(table) = on.table_name_ref() {
-            on_doc = on_doc
-                .append(Doc::space())
-                .append(leading_comments(table.syntax()));
-            if let Some(path) = table.path_ref() {
-                on_doc = on_doc.append(build_path_ref(&path));
-            }
-        }
-        doc = doc.append(
-            Doc::line_or_space()
-                .append(leading_comments(on.syntax()))
-                .append(on_doc)
-                .nest(2),
-        );
+        on_doc = append_commented_path_ref(on_doc, on.table_name_ref());
+        doc = append_nested_clause(doc, on.syntax(), on_doc);
     }
     if let Some(action) = stmt.action() {
         let action_doc = match &action {
@@ -14922,12 +13583,7 @@ fn build_alter_policy<'a>(stmt: &ast::AlterPolicy) -> Doc<'a> {
                 build_rename_to(action.to_token(), target)
             }
         };
-        doc = doc.append(
-            Doc::line_or_space()
-                .append(leading_comments(action.syntax()))
-                .append(action_doc)
-                .nest(2),
-        );
+        doc = append_nested_clause(doc, action.syntax(), action_doc);
     }
     doc.group().append(build_semicolon(stmt.semicolon_token()))
 }
@@ -15010,27 +13666,10 @@ fn build_alter_materialized_view<'a>(stmt: &ast::AlterMaterializedView) -> Doc<'
         }
     }
     if let Some(all) = stmt.all_in_tablespace() {
-        doc = doc.append(
-            Doc::line_or_space()
-                .append(leading_comments(all.syntax()))
-                .append(build_all_in_tablespace(all))
-                .nest(2),
-        );
+        doc = append_nested_node(doc, all, build_all_in_tablespace);
     } else {
-        if let Some(if_exists) = stmt.if_exists() {
-            doc = doc
-                .append(Doc::space())
-                .append(leading_comments(if_exists.syntax()))
-                .append(build_if_exists(if_exists));
-        }
-        if let Some(view) = stmt.view_ref() {
-            doc = doc
-                .append(Doc::space())
-                .append(leading_comments(view.syntax()));
-            if let Some(path) = view.path_ref() {
-                doc = doc.append(build_path_ref(&path));
-            }
-        }
+        doc = append_if_exists(doc, stmt.if_exists());
+        doc = append_commented_path_ref(doc, stmt.view_ref());
         let actions = stmt.action().map(|action| {
             let syntax = action.syntax().clone();
             (
@@ -15142,14 +13781,7 @@ fn build_alter_collation<'a>(stmt: &ast::AlterCollation) -> Doc<'a> {
             .append(leading_comments_token(&token))
             .append(Doc::text("collation"));
     }
-    if let Some(collation) = stmt.collation_ref() {
-        doc = doc
-            .append(Doc::space())
-            .append(leading_comments(collation.syntax()));
-        if let Some(path) = collation.path_ref() {
-            doc = doc.append(build_path_ref(&path));
-        }
-    }
+    doc = append_commented_path_ref(doc, stmt.collation_ref());
     if let Some(action) = stmt.action() {
         let action_comments = leading_comments(action.syntax());
         let action_doc = match action {
@@ -15185,14 +13817,7 @@ fn build_alter_conversion<'a>(stmt: &ast::AlterConversion) -> Doc<'a> {
             .append(leading_comments_token(&token))
             .append(Doc::text("conversion"));
     }
-    if let Some(conversion) = stmt.conversion_ref() {
-        doc = doc
-            .append(Doc::space())
-            .append(leading_comments(conversion.syntax()));
-        if let Some(path) = conversion.path_ref() {
-            doc = doc.append(build_path_ref(&path));
-        }
-    }
+    doc = append_commented_path_ref(doc, stmt.conversion_ref());
     if let Some(action) = stmt.action() {
         let action_comments = leading_comments(action.syntax());
         let action_doc = match action {
@@ -15276,12 +13901,7 @@ fn build_alter_database<'a>(stmt: &ast::AlterDatabase) -> Doc<'a> {
             .append(build_name(database.syntax()));
     }
     if let Some(action) = stmt.action() {
-        doc = doc.append(
-            Doc::line_or_space()
-                .append(leading_comments(action.syntax()))
-                .append(build_alter_database_action(action))
-                .nest(2),
-        );
+        doc = append_nested_node(doc, action, build_alter_database_action);
     }
     doc.append(build_semicolon(stmt.semicolon_token())).group()
 }
@@ -15325,13 +13945,8 @@ fn build_reset_config_param<'a>(action: &ast::ResetConfigParam) -> Doc<'a> {
             .append(Doc::space())
             .append(leading_comments_token(&token))
             .append(Doc::text("all"));
-    } else if let Some(parameter) = action.config_parameter_ref() {
-        doc = doc
-            .append(Doc::space())
-            .append(leading_comments(parameter.syntax()));
-        if let Some(path) = parameter.path_ref() {
-            doc = doc.append(build_path_ref(&path));
-        }
+    } else {
+        doc = append_commented_path_ref(doc, action.config_parameter_ref());
     }
     doc
 }
@@ -15491,12 +14106,7 @@ fn build_alter_default_privileges<'a>(stmt: &ast::AlterDefaultPrivileges) -> Doc
                 .append(leading_comments(roles.syntax()))
                 .append(build_role_ref_list(roles));
         }
-        doc = doc.append(
-            Doc::line_or_space()
-                .append(leading_comments(for_roles.syntax()))
-                .append(clause)
-                .nest(2),
-        );
+        doc = append_nested_clause(doc, for_roles.syntax(), clause);
     }
     if let Some(in_schemas) = stmt.in_schemas() {
         let mut clause = build_keyword_tokens([
@@ -15512,20 +14122,10 @@ fn build_alter_default_privileges<'a>(stmt: &ast::AlterDefaultPrivileges) -> Doc
         }))
         .unwrap_or_else(Doc::nil);
         clause = clause.append(Doc::line_or_space().append(schemas).nest(2));
-        doc = doc.append(
-            Doc::line_or_space()
-                .append(leading_comments(in_schemas.syntax()))
-                .append(clause)
-                .nest(2),
-        );
+        doc = append_nested_clause(doc, in_schemas.syntax(), clause);
     }
     if let Some(action) = stmt.action() {
-        doc = doc.append(
-            Doc::line_or_space()
-                .append(leading_comments(action.syntax()))
-                .append(build_alter_default_privileges_action(action))
-                .nest(2),
-        );
+        doc = append_nested_node(doc, action, build_alter_default_privileges_action);
     }
     doc.group().append(build_semicolon(stmt.semicolon_token()))
 }
@@ -15589,20 +14189,10 @@ fn build_alter_default_privileges_action<'a>(action: ast::AlterDefaultPrivileges
                     .append(Doc::text("to"));
             }
             if let Some(roles) = grant.role_ref_list() {
-                doc = doc.append(
-                    Doc::line_or_space()
-                        .append(leading_comments(roles.syntax()))
-                        .append(build_role_ref_list(roles))
-                        .nest(2),
-                );
+                doc = append_nested_node(doc, roles, build_role_ref_list);
             }
             if let Some(with) = grant.grant_with_clause() {
-                doc = doc.append(
-                    Doc::line_or_space()
-                        .append(leading_comments(with.syntax()))
-                        .append(build_grant_with_clause(with))
-                        .nest(2),
-                );
+                doc = append_nested_node(doc, with, build_grant_with_clause);
             }
             doc.group()
         }
@@ -15651,20 +14241,10 @@ fn build_alter_default_privileges_action<'a>(action: ast::AlterDefaultPrivileges
                     .append(Doc::text("from"));
             }
             if let Some(roles) = revoke.role_ref_list() {
-                doc = doc.append(
-                    Doc::line_or_space()
-                        .append(leading_comments(roles.syntax()))
-                        .append(build_role_ref_list(roles))
-                        .nest(2),
-                );
+                doc = append_nested_node(doc, roles, build_role_ref_list);
             }
             if let Some(behavior) = revoke.drop_behavior() {
-                doc = doc.append(
-                    Doc::line_or_space()
-                        .append(leading_comments(behavior.syntax()))
-                        .append(build_drop_behavior(behavior))
-                        .nest(2),
-                );
+                doc = append_nested_node(doc, behavior, build_drop_behavior);
             }
             doc.group()
         }
@@ -15679,21 +14259,9 @@ fn build_alter_domain<'a>(stmt: &ast::AlterDomain) -> Doc<'a> {
             .append(leading_comments_token(&domain))
             .append(Doc::text("domain"));
     }
-    if let Some(domain) = stmt.domain_ref() {
-        doc = doc
-            .append(Doc::space())
-            .append(leading_comments(domain.syntax()));
-        if let Some(path) = domain.path_ref() {
-            doc = doc.append(build_path_ref(&path));
-        }
-    }
+    doc = append_commented_path_ref(doc, stmt.domain_ref());
     if let Some(action) = stmt.action() {
-        doc = doc.append(
-            Doc::line_or_space()
-                .append(leading_comments(action.syntax()))
-                .append(build_alter_domain_action(action))
-                .nest(2),
-        );
+        doc = append_nested_node(doc, action, build_alter_domain_action);
     }
     doc.group().append(build_semicolon(stmt.semicolon_token()))
 }
@@ -15759,12 +14327,7 @@ fn build_alter_domain_action<'a>(action: ast::AlterDomainAction) -> Doc<'a> {
         ast::AlterDomainAction::AddConstraint(node) => {
             let mut doc = Doc::text("add");
             if let Some(constraint) = node.constraint() {
-                doc = doc.append(
-                    Doc::line_or_space()
-                        .append(leading_comments(constraint.syntax()))
-                        .append(build_domain_constraint(constraint))
-                        .nest(2),
-                );
+                doc = append_nested_node(doc, constraint, build_domain_constraint);
             }
             doc.group()
         }
@@ -15783,20 +14346,8 @@ fn build_alter_domain_action<'a>(action: ast::AlterDomainAction) -> Doc<'a> {
                 (node.drop_token(), "drop"),
                 (node.constraint_token(), "constraint"),
             ]);
-            if let Some(if_exists) = node.if_exists() {
-                doc = doc
-                    .append(Doc::space())
-                    .append(leading_comments(if_exists.syntax()))
-                    .append(build_if_exists(if_exists));
-            }
-            if let Some(name) = node.constraint_name_ref() {
-                doc = doc
-                    .append(Doc::space())
-                    .append(leading_comments(name.syntax()));
-                if let Some(path) = name.path_ref() {
-                    doc = doc.append(build_path_ref(&path));
-                }
-            }
+            doc = append_if_exists(doc, node.if_exists());
+            doc = append_commented_path_ref(doc, node.constraint_name_ref());
             if let Some(behavior) = node.drop_behavior() {
                 doc = doc
                     .append(Doc::space())
@@ -15820,14 +14371,7 @@ fn build_alter_domain_action<'a>(action: ast::AlterDomainAction) -> Doc<'a> {
                 (node.rename_token(), "rename"),
                 (node.constraint_token(), "constraint"),
             ]);
-            if let Some(name) = node.constraint_name_ref() {
-                doc = doc
-                    .append(Doc::space())
-                    .append(leading_comments(name.syntax()));
-                if let Some(path) = name.path_ref() {
-                    doc = doc.append(build_path_ref(&path));
-                }
-            }
+            doc = append_commented_path_ref(doc, node.constraint_name_ref());
             if let Some(to) = node.to_token() {
                 doc = doc
                     .append(Doc::space())
@@ -15848,12 +14392,7 @@ fn build_alter_domain_action<'a>(action: ast::AlterDomainAction) -> Doc<'a> {
                 (node.default_token(), "default"),
             ]);
             if let Some(expr) = node.expr() {
-                doc = doc.append(
-                    Doc::line_or_space()
-                        .append(leading_comments(expr.syntax()))
-                        .append(build_expr(expr))
-                        .nest(2),
-                );
+                doc = append_nested_node(doc, expr, build_expr);
             }
             doc.group()
         }
@@ -15864,19 +14403,11 @@ fn build_alter_domain_action<'a>(action: ast::AlterDomainAction) -> Doc<'a> {
         ]),
         ast::AlterDomainAction::SetSchema(node) => build_set_schema(&node),
         ast::AlterDomainAction::ValidateConstraint(node) => {
-            let mut doc = build_keyword_tokens([
+            let doc = build_keyword_tokens([
                 (node.validate_token(), "validate"),
                 (node.constraint_token(), "constraint"),
             ]);
-            if let Some(name) = node.constraint_name_ref() {
-                doc = doc
-                    .append(Doc::space())
-                    .append(leading_comments(name.syntax()));
-                if let Some(path) = name.path_ref() {
-                    doc = doc.append(build_path_ref(&path));
-                }
-            }
-            doc
+            append_commented_path_ref(doc, node.constraint_name_ref())
         }
     }
 }
@@ -15950,12 +14481,7 @@ fn build_alter_extension<'a>(stmt: &ast::AlterExtension) -> Doc<'a> {
             .append(build_name(extension.syntax()));
     }
     if let Some(action) = stmt.action() {
-        doc = doc.append(
-            Doc::line_or_space()
-                .append(leading_comments(action.syntax()))
-                .append(build_alter_extension_action(action))
-                .nest(2),
-        );
+        doc = append_nested_node(doc, action, build_alter_extension_action);
     }
     doc.group().append(build_semicolon(stmt.semicolon_token()))
 }
@@ -15983,12 +14509,7 @@ fn build_alter_extension_action<'a>(action: ast::AlterExtensionAction) -> Doc<'a
                         .append(leading_comments(literal.syntax()))
                         .append(build_literal(literal));
                 }
-                doc = doc.append(
-                    Doc::line_or_space()
-                        .append(leading_comments(update_to.syntax()))
-                        .append(update_doc)
-                        .nest(2),
-                );
+                doc = append_nested_clause(doc, update_to.syntax(), update_doc);
             }
             doc.group()
         }
@@ -16002,12 +14523,7 @@ fn build_alter_extension_member_action<'a>(
 ) -> Doc<'a> {
     let mut doc = Doc::text(keyword);
     if let Some(object) = object {
-        doc = doc.append(
-            Doc::line_or_space()
-                .append(leading_comments(object.syntax()))
-                .append(build_extension_member_object(object))
-                .nest(2),
-        );
+        doc = append_nested_node(doc, object, build_extension_member_object);
     }
     doc.group()
 }
@@ -16221,12 +14737,7 @@ fn build_extension_member_object<'a>(object: ast::ExtensionMemberObject) -> Doc<
                     .map(|name| build_extension_path_value(&name)),
             );
             if let Some(using) = node.using_method() {
-                doc = doc.append(
-                    Doc::line_or_space()
-                        .append(leading_comments(using.syntax()))
-                        .append(build_using_method(using))
-                        .nest(2),
-                );
+                doc = append_nested_node(doc, using, build_using_method);
             }
             doc.group()
         }
@@ -16240,12 +14751,7 @@ fn build_extension_member_object<'a>(object: ast::ExtensionMemberObject) -> Doc<
                     .map(|name| build_extension_path_value(&name)),
             );
             if let Some(using) = node.using_method() {
-                doc = doc.append(
-                    Doc::line_or_space()
-                        .append(leading_comments(using.syntax()))
-                        .append(build_using_method(using))
-                        .nest(2),
-                );
+                doc = append_nested_node(doc, using, build_using_method);
             }
             doc.group()
         }
@@ -16346,12 +14852,7 @@ fn build_extension_member_object<'a>(object: ast::ExtensionMemberObject) -> Doc<
                 (node.for_token(), "for"),
             ]);
             if let Some(ty) = node.ty() {
-                doc = doc.append(
-                    Doc::line_or_space()
-                        .append(leading_comments(ty.syntax()))
-                        .append(build_type(ty))
-                        .nest(2),
-                );
+                doc = append_nested_node(doc, ty, build_type);
             }
             if let Some(token) = node.language_token() {
                 doc = doc
@@ -16395,12 +14896,7 @@ fn build_alter_publication<'a>(stmt: &ast::AlterPublication) -> Doc<'a> {
             .append(build_name(publication.syntax()));
     }
     if let Some(action) = stmt.action() {
-        doc = doc.append(
-            Doc::line_or_space()
-                .append(leading_comments(action.syntax()))
-                .append(build_alter_publication_action(action))
-                .nest(2),
-        );
+        doc = append_nested_node(doc, action, build_alter_publication_action);
     }
     doc.append(build_semicolon(stmt.semicolon_token())).group()
 }
@@ -16504,12 +15000,7 @@ fn build_create_subscription<'a>(stmt: &ast::CreateSubscription) -> Doc<'a> {
             .append(build_name(subscription.syntax()));
     }
     if let Some(source) = stmt.source() {
-        doc = doc.append(
-            Doc::line_or_space()
-                .append(leading_comments(source.syntax()))
-                .append(build_subscription_source(source))
-                .nest(2),
-        );
+        doc = append_nested_node(doc, source, build_subscription_source);
     }
     if let Some(token) = stmt.publication_token() {
         let mut publication_doc = leading_comments_token(&token).append(Doc::text("publication"));
@@ -16521,12 +15012,7 @@ fn build_create_subscription<'a>(stmt: &ast::CreateSubscription) -> Doc<'a> {
         doc = doc.append(Doc::line_or_space().append(publication_doc).nest(2));
     }
     if let Some(params) = stmt.with_params() {
-        doc = doc.append(
-            Doc::line_or_space()
-                .append(leading_comments(params.syntax()))
-                .append(build_with_params(params))
-                .nest(2),
-        );
+        doc = append_nested_node(doc, params, build_with_params);
     }
     doc.append(build_semicolon(stmt.semicolon_token())).group()
 }
@@ -16582,12 +15068,7 @@ fn build_alter_subscription<'a>(stmt: &ast::AlterSubscription) -> Doc<'a> {
             .append(build_name(subscription.syntax()));
     }
     if let Some(action) = stmt.action() {
-        doc = doc.append(
-            Doc::line_or_space()
-                .append(leading_comments(action.syntax()))
-                .append(build_alter_subscription_action(action))
-                .nest(2),
-        );
+        doc = append_nested_node(doc, action, build_alter_subscription_action);
     }
     doc.append(build_semicolon(stmt.semicolon_token())).group()
 }
@@ -16702,19 +15183,9 @@ fn build_drop_access_method<'a>(stmt: &ast::DropAccessMethod) -> Doc<'a> {
         (stmt.access_token(), "access"),
         (stmt.method_token(), "method"),
     ]);
-    if let Some(if_exists) = stmt.if_exists() {
-        doc = doc
-            .append(Doc::space())
-            .append(leading_comments(if_exists.syntax()))
-            .append(build_if_exists(if_exists));
-    }
+    doc = append_if_exists(doc, stmt.if_exists());
     if let Some(method) = stmt.access_method_ref() {
-        doc = doc.append(
-            Doc::line_or_space()
-                .append(leading_comments(method.syntax()))
-                .append(build_name(method.syntax()))
-                .nest(2),
-        );
+        doc = append_nested_clause(doc, method.syntax(), build_name(method.syntax()));
     }
     doc = append_drop_behavior(doc, stmt.drop_behavior());
     doc.group().append(build_semicolon(stmt.semicolon_token()))
@@ -16725,12 +15196,7 @@ fn build_drop_aggregate<'a>(stmt: &ast::DropAggregate) -> Doc<'a> {
         (stmt.drop_token(), "drop"),
         (stmt.aggregate_token(), "aggregate"),
     ]);
-    if let Some(if_exists) = stmt.if_exists() {
-        doc = doc
-            .append(Doc::space())
-            .append(leading_comments(if_exists.syntax()))
-            .append(build_if_exists(if_exists));
-    }
+    doc = append_if_exists(doc, stmt.if_exists());
     if let Some(aggregates) = build_comma_separated_docs(stmt.aggregates().map(|aggregate| {
         let syntax = aggregate.syntax().clone();
         (
@@ -16746,12 +15212,7 @@ fn build_drop_aggregate<'a>(stmt: &ast::DropAggregate) -> Doc<'a> {
 
 fn build_drop_cast<'a>(stmt: &ast::DropCast) -> Doc<'a> {
     let mut doc = build_keyword_tokens([(stmt.drop_token(), "drop"), (stmt.cast_token(), "cast")]);
-    if let Some(if_exists) = stmt.if_exists() {
-        doc = doc
-            .append(Doc::space())
-            .append(leading_comments(if_exists.syntax()))
-            .append(build_if_exists(if_exists));
-    }
+    doc = append_if_exists(doc, stmt.if_exists());
     if let Some(sig) = stmt.cast_sig() {
         doc = doc
             .append(Doc::space())
@@ -16772,12 +15233,7 @@ fn build_drop_collation<'a>(stmt: &ast::DropCollation) -> Doc<'a> {
         (stmt.drop_token(), "drop"),
         (stmt.collation_token(), "collation"),
     ]);
-    if let Some(if_exists) = stmt.if_exists() {
-        doc = doc
-            .append(Doc::space())
-            .append(leading_comments(if_exists.syntax()))
-            .append(build_if_exists(if_exists));
-    }
+    doc = append_if_exists(doc, stmt.if_exists());
     if let Some(collations) = build_comma_separated_docs(stmt.collation_refs().map(|collation| {
         let syntax = collation.syntax().clone();
         (build_extension_path_value(&collation), syntax)
@@ -16793,12 +15249,7 @@ fn build_drop_conversion<'a>(stmt: &ast::DropConversion) -> Doc<'a> {
         (stmt.drop_token(), "drop"),
         (stmt.conversion_token(), "conversion"),
     ]);
-    if let Some(if_exists) = stmt.if_exists() {
-        doc = doc
-            .append(Doc::space())
-            .append(leading_comments(if_exists.syntax()))
-            .append(build_if_exists(if_exists));
-    }
+    doc = append_if_exists(doc, stmt.if_exists());
     if let Some(conversion) = stmt.conversion_ref() {
         doc = doc.append(
             Doc::line_or_space()
@@ -16815,19 +15266,9 @@ fn build_drop_database<'a>(stmt: &ast::DropDatabase) -> Doc<'a> {
         (stmt.drop_token(), "drop"),
         (stmt.database_token(), "database"),
     ]);
-    if let Some(if_exists) = stmt.if_exists() {
-        doc = doc
-            .append(Doc::space())
-            .append(leading_comments(if_exists.syntax()))
-            .append(build_if_exists(if_exists));
-    }
+    doc = append_if_exists(doc, stmt.if_exists());
     if let Some(database) = stmt.database_ref() {
-        doc = doc.append(
-            Doc::line_or_space()
-                .append(leading_comments(database.syntax()))
-                .append(build_name(database.syntax()))
-                .nest(2),
-        );
+        doc = append_nested_clause(doc, database.syntax(), build_name(database.syntax()));
     }
     if let Some(force_clause) = stmt.drop_database_force_clause() {
         doc = doc
@@ -16875,12 +15316,7 @@ fn build_drop_database_force_clause<'a>(clause: ast::DropDatabaseForceClause) ->
 fn build_drop_domain<'a>(stmt: &ast::DropDomain) -> Doc<'a> {
     let mut doc =
         build_keyword_tokens([(stmt.drop_token(), "drop"), (stmt.domain_token(), "domain")]);
-    if let Some(if_exists) = stmt.if_exists() {
-        doc = doc
-            .append(Doc::space())
-            .append(leading_comments(if_exists.syntax()))
-            .append(build_if_exists(if_exists));
-    }
+    doc = append_if_exists(doc, stmt.if_exists());
     if let Some(domains) = build_comma_separated_docs(stmt.domain_refs().map(|domain| {
         let syntax = domain.syntax().clone();
         (build_extension_path_value(&domain), syntax)
@@ -16897,19 +15333,9 @@ fn build_drop_event_trigger<'a>(stmt: &ast::DropEventTrigger) -> Doc<'a> {
         (stmt.event_token(), "event"),
         (stmt.trigger_token(), "trigger"),
     ]);
-    if let Some(if_exists) = stmt.if_exists() {
-        doc = doc
-            .append(Doc::space())
-            .append(leading_comments(if_exists.syntax()))
-            .append(build_if_exists(if_exists));
-    }
+    doc = append_if_exists(doc, stmt.if_exists());
     if let Some(trigger) = stmt.event_trigger_ref() {
-        doc = doc.append(
-            Doc::line_or_space()
-                .append(leading_comments(trigger.syntax()))
-                .append(build_name(trigger.syntax()))
-                .nest(2),
-        );
+        doc = append_nested_clause(doc, trigger.syntax(), build_name(trigger.syntax()));
     }
     doc = append_drop_behavior(doc, stmt.drop_behavior());
     doc.group().append(build_semicolon(stmt.semicolon_token()))
@@ -16920,12 +15346,7 @@ fn build_drop_extension<'a>(stmt: &ast::DropExtension) -> Doc<'a> {
         (stmt.drop_token(), "drop"),
         (stmt.extension_token(), "extension"),
     ]);
-    if let Some(if_exists) = stmt.if_exists() {
-        doc = doc
-            .append(Doc::space())
-            .append(leading_comments(if_exists.syntax()))
-            .append(build_if_exists(if_exists));
-    }
+    doc = append_if_exists(doc, stmt.if_exists());
     if let Some(extensions) = build_comma_separated_docs(stmt.extension_refs().map(|extension| {
         let syntax = extension.syntax().clone();
         (
@@ -16946,12 +15367,7 @@ fn build_drop_foreign_data_wrapper<'a>(stmt: &ast::DropForeignDataWrapper) -> Do
         (stmt.data_token(), "data"),
         (stmt.wrapper_token(), "wrapper"),
     ]);
-    if let Some(if_exists) = stmt.if_exists() {
-        doc = doc
-            .append(Doc::space())
-            .append(leading_comments(if_exists.syntax()))
-            .append(build_if_exists(if_exists));
-    }
+    doc = append_if_exists(doc, stmt.if_exists());
     if let Some(wrappers) =
         build_comma_separated_docs(stmt.foreign_data_wrapper_refs().map(|wrapper| {
             let syntax = wrapper.syntax().clone();
@@ -16973,12 +15389,7 @@ fn build_drop_foreign_table<'a>(stmt: &ast::DropForeignTable) -> Doc<'a> {
         (stmt.foreign_token(), "foreign"),
         (stmt.table_token(), "table"),
     ]);
-    if let Some(if_exists) = stmt.if_exists() {
-        doc = doc
-            .append(Doc::space())
-            .append(leading_comments(if_exists.syntax()))
-            .append(build_if_exists(if_exists));
-    }
+    doc = append_if_exists(doc, stmt.if_exists());
     if let Some(tables) = build_comma_separated_docs(stmt.table_name_refs().map(|table| {
         let syntax = table.syntax().clone();
         (build_extension_path_value(&table), syntax)
@@ -16994,26 +15405,16 @@ fn build_drop_function<'a>(stmt: &ast::DropFunction) -> Doc<'a> {
         (stmt.drop_token(), "drop"),
         (stmt.function_token(), "function"),
     ]);
-    if let Some(if_exists) = stmt.if_exists() {
-        doc = doc
-            .append(Doc::space())
-            .append(leading_comments(if_exists.syntax()))
-            .append(build_if_exists(if_exists));
-    }
+    doc = append_if_exists(doc, stmt.if_exists());
     if let Some(list) = stmt.function_sig_list() {
         if let Some(functions) = build_comma_separated_docs(list.function_sigs().map(|function| {
             let syntax = function.syntax().clone();
             (
                 leading_comments(&syntax).append(build_function_sig(function)),
-                syntax,
-            )
-        })) {
-            doc = doc.append(
-                Doc::line_or_space()
-                    .append(leading_comments(list.syntax()))
-                    .append(functions)
-                    .nest(2),
-            );
+                syntax,
+            )
+        })) {
+            doc = append_nested_clause(doc, list.syntax(), functions);
         }
     }
     doc = append_drop_behavior(doc, stmt.drop_behavior());
@@ -17023,12 +15424,7 @@ fn build_drop_function<'a>(stmt: &ast::DropFunction) -> Doc<'a> {
 fn build_drop_group<'a>(stmt: &ast::DropGroup) -> Doc<'a> {
     let mut doc =
         build_keyword_tokens([(stmt.drop_token(), "drop"), (stmt.group_token(), "group")]);
-    if let Some(if_exists) = stmt.if_exists() {
-        doc = doc
-            .append(Doc::space())
-            .append(leading_comments(if_exists.syntax()))
-            .append(build_if_exists(if_exists));
-    }
+    doc = append_if_exists(doc, stmt.if_exists());
     if let Some(groups) = build_comma_separated_docs(stmt.role_refs().map(|group| {
         let syntax = group.syntax().clone();
         (
@@ -17047,12 +15443,7 @@ fn build_drop_index<'a>(stmt: &ast::DropIndex) -> Doc<'a> {
         (stmt.index_token(), "index"),
         (stmt.concurrently_token(), "concurrently"),
     ]);
-    if let Some(if_exists) = stmt.if_exists() {
-        doc = doc
-            .append(Doc::space())
-            .append(leading_comments(if_exists.syntax()))
-            .append(build_if_exists(if_exists));
-    }
+    doc = append_if_exists(doc, stmt.if_exists());
     if let Some(indexes) = build_comma_separated_docs(stmt.index_refs().map(|index| {
         let syntax = index.syntax().clone();
         (build_extension_path_value(&index), syntax)
@@ -17069,19 +15460,9 @@ fn build_drop_language<'a>(stmt: &ast::DropLanguage) -> Doc<'a> {
         (stmt.procedural_token(), "procedural"),
         (stmt.language_token(), "language"),
     ]);
-    if let Some(if_exists) = stmt.if_exists() {
-        doc = doc
-            .append(Doc::space())
-            .append(leading_comments(if_exists.syntax()))
-            .append(build_if_exists(if_exists));
-    }
+    doc = append_if_exists(doc, stmt.if_exists());
     if let Some(language) = stmt.language_ref() {
-        doc = doc.append(
-            Doc::line_or_space()
-                .append(leading_comments(language.syntax()))
-                .append(build_name(language.syntax()))
-                .nest(2),
-        );
+        doc = append_nested_clause(doc, language.syntax(), build_name(language.syntax()));
     }
     doc = append_drop_behavior(doc, stmt.drop_behavior());
     doc.group().append(build_semicolon(stmt.semicolon_token()))
@@ -17093,12 +15474,7 @@ fn build_drop_materialized_view<'a>(stmt: &ast::DropMaterializedView) -> Doc<'a>
         (stmt.materialized_token(), "materialized"),
         (stmt.view_token(), "view"),
     ]);
-    if let Some(if_exists) = stmt.if_exists() {
-        doc = doc
-            .append(Doc::space())
-            .append(leading_comments(if_exists.syntax()))
-            .append(build_if_exists(if_exists));
-    }
+    doc = append_if_exists(doc, stmt.if_exists());
     if let Some(views) = build_comma_separated_docs(stmt.view_refs().map(|view| {
         let syntax = view.syntax().clone();
         (build_extension_path_value(&view), syntax)
@@ -17114,12 +15490,7 @@ fn build_drop_operator<'a>(stmt: &ast::DropOperator) -> Doc<'a> {
         (stmt.drop_token(), "drop"),
         (stmt.operator_token(), "operator"),
     ]);
-    if let Some(if_exists) = stmt.if_exists() {
-        doc = doc
-            .append(Doc::space())
-            .append(leading_comments(if_exists.syntax()))
-            .append(build_if_exists(if_exists));
-    }
+    doc = append_if_exists(doc, stmt.if_exists());
     if let Some(list) = stmt.op_sig_list() {
         if let Some(operators) = build_comma_separated_docs(list.op_sigs().map(|operator| {
             let syntax = operator.syntax().clone();
@@ -17128,12 +15499,7 @@ fn build_drop_operator<'a>(stmt: &ast::DropOperator) -> Doc<'a> {
                 syntax,
             )
         })) {
-            doc = doc.append(
-                Doc::line_or_space()
-                    .append(leading_comments(list.syntax()))
-                    .append(operators)
-                    .nest(2),
-            );
+            doc = append_nested_clause(doc, list.syntax(), operators);
         }
     }
     doc = append_drop_behavior(doc, stmt.drop_behavior());
@@ -17146,12 +15512,7 @@ fn build_drop_operator_class<'a>(stmt: &ast::DropOperatorClass) -> Doc<'a> {
         (stmt.operator_token(), "operator"),
         (stmt.class_token(), "class"),
     ]);
-    if let Some(if_exists) = stmt.if_exists() {
-        doc = doc
-            .append(Doc::space())
-            .append(leading_comments(if_exists.syntax()))
-            .append(build_if_exists(if_exists));
-    }
+    doc = append_if_exists(doc, stmt.if_exists());
     if let Some(class) = stmt.op_class_ref() {
         doc = doc.append(
             Doc::line_or_space()
@@ -17160,12 +15521,7 @@ fn build_drop_operator_class<'a>(stmt: &ast::DropOperatorClass) -> Doc<'a> {
         );
     }
     if let Some(using) = stmt.using_method() {
-        doc = doc.append(
-            Doc::line_or_space()
-                .append(leading_comments(using.syntax()))
-                .append(build_using_method(using))
-                .nest(2),
-        );
+        doc = append_nested_node(doc, using, build_using_method);
     }
     doc = append_drop_behavior(doc, stmt.drop_behavior());
     doc.group().append(build_semicolon(stmt.semicolon_token()))
@@ -17177,12 +15533,7 @@ fn build_drop_operator_family<'a>(stmt: &ast::DropOperatorFamily) -> Doc<'a> {
         (stmt.operator_token(), "operator"),
         (stmt.family_token(), "family"),
     ]);
-    if let Some(if_exists) = stmt.if_exists() {
-        doc = doc
-            .append(Doc::space())
-            .append(leading_comments(if_exists.syntax()))
-            .append(build_if_exists(if_exists));
-    }
+    doc = append_if_exists(doc, stmt.if_exists());
     if let Some(family) = stmt.op_family_ref() {
         doc = doc.append(
             Doc::line_or_space()
@@ -17191,12 +15542,7 @@ fn build_drop_operator_family<'a>(stmt: &ast::DropOperatorFamily) -> Doc<'a> {
         );
     }
     if let Some(using) = stmt.using_method() {
-        doc = doc.append(
-            Doc::line_or_space()
-                .append(leading_comments(using.syntax()))
-                .append(build_using_method(using))
-                .nest(2),
-        );
+        doc = append_nested_node(doc, using, build_using_method);
     }
     doc = append_drop_behavior(doc, stmt.drop_behavior());
     doc.group().append(build_semicolon(stmt.semicolon_token()))
@@ -17209,12 +15555,7 @@ fn build_drop_owned<'a>(stmt: &ast::DropOwned) -> Doc<'a> {
         (stmt.by_token(), "by"),
     ]);
     if let Some(roles) = stmt.role_ref_list() {
-        doc = doc.append(
-            Doc::line_or_space()
-                .append(leading_comments(roles.syntax()))
-                .append(build_role_ref_list(roles))
-                .nest(2),
-        );
+        doc = append_nested_node(doc, roles, build_role_ref_list);
     }
     doc = append_drop_behavior(doc, stmt.drop_behavior());
     doc.group().append(build_semicolon(stmt.semicolon_token()))
@@ -17223,19 +15564,9 @@ fn build_drop_owned<'a>(stmt: &ast::DropOwned) -> Doc<'a> {
 fn build_drop_policy<'a>(stmt: &ast::DropPolicy) -> Doc<'a> {
     let mut doc =
         build_keyword_tokens([(stmt.drop_token(), "drop"), (stmt.policy_token(), "policy")]);
-    if let Some(if_exists) = stmt.if_exists() {
-        doc = doc
-            .append(Doc::space())
-            .append(leading_comments(if_exists.syntax()))
-            .append(build_if_exists(if_exists));
-    }
+    doc = append_if_exists(doc, stmt.if_exists());
     if let Some(policy) = stmt.policy_ref() {
-        doc = doc.append(
-            Doc::line_or_space()
-                .append(leading_comments(policy.syntax()))
-                .append(build_name(policy.syntax()))
-                .nest(2),
-        );
+        doc = append_nested_clause(doc, policy.syntax(), build_name(policy.syntax()));
     }
     if let Some(on) = stmt.on_table() {
         let mut on_doc = build_keyword_tokens([(on.on_token(), "on")]);
@@ -17244,12 +15575,7 @@ fn build_drop_policy<'a>(stmt: &ast::DropPolicy) -> Doc<'a> {
                 .append(Doc::space())
                 .append(build_extension_path_value(&table));
         }
-        doc = doc.append(
-            Doc::line_or_space()
-                .append(leading_comments(on.syntax()))
-                .append(on_doc)
-                .nest(2),
-        );
+        doc = append_nested_clause(doc, on.syntax(), on_doc);
     }
     doc = append_drop_behavior(doc, stmt.drop_behavior());
     doc.group().append(build_semicolon(stmt.semicolon_token()))
@@ -17260,12 +15586,7 @@ fn build_drop_procedure<'a>(stmt: &ast::DropProcedure) -> Doc<'a> {
         (stmt.drop_token(), "drop"),
         (stmt.procedure_token(), "procedure"),
     ]);
-    if let Some(if_exists) = stmt.if_exists() {
-        doc = doc
-            .append(Doc::space())
-            .append(leading_comments(if_exists.syntax()))
-            .append(build_if_exists(if_exists));
-    }
+    doc = append_if_exists(doc, stmt.if_exists());
     if let Some(list) = stmt.procedure_sig_list() {
         if let Some(procedures) =
             build_comma_separated_docs(list.procedure_sigs().map(|procedure| {
@@ -17276,12 +15597,7 @@ fn build_drop_procedure<'a>(stmt: &ast::DropProcedure) -> Doc<'a> {
                 )
             }))
         {
-            doc = doc.append(
-                Doc::line_or_space()
-                    .append(leading_comments(list.syntax()))
-                    .append(procedures)
-                    .nest(2),
-            );
+            doc = append_nested_clause(doc, list.syntax(), procedures);
         }
     }
     doc = append_drop_behavior(doc, stmt.drop_behavior());
@@ -17294,12 +15610,7 @@ fn build_drop_property_graph<'a>(stmt: &ast::DropPropertyGraph) -> Doc<'a> {
         (stmt.property_token(), "property"),
         (stmt.graph_token(), "graph"),
     ]);
-    if let Some(if_exists) = stmt.if_exists() {
-        doc = doc
-            .append(Doc::space())
-            .append(leading_comments(if_exists.syntax()))
-            .append(build_if_exists(if_exists));
-    }
+    doc = append_if_exists(doc, stmt.if_exists());
     if let Some(graph) = stmt.property_graph_ref() {
         doc = doc.append(
             Doc::line_or_space()
@@ -17313,12 +15624,7 @@ fn build_drop_property_graph<'a>(stmt: &ast::DropPropertyGraph) -> Doc<'a> {
 
 fn build_drop_role<'a>(stmt: &ast::DropRole) -> Doc<'a> {
     let mut doc = build_keyword_tokens([(stmt.drop_token(), "drop"), (stmt.role_token(), "role")]);
-    if let Some(if_exists) = stmt.if_exists() {
-        doc = doc
-            .append(Doc::space())
-            .append(leading_comments(if_exists.syntax()))
-            .append(build_if_exists(if_exists));
-    }
+    doc = append_if_exists(doc, stmt.if_exists());
     if let Some(roles) = build_comma_separated_docs(stmt.role_refs().map(|role| {
         let syntax = role.syntax().clone();
         (
@@ -17336,12 +15642,7 @@ fn build_drop_routine<'a>(stmt: &ast::DropRoutine) -> Doc<'a> {
         (stmt.drop_token(), "drop"),
         (stmt.routine_token(), "routine"),
     ]);
-    if let Some(if_exists) = stmt.if_exists() {
-        doc = doc
-            .append(Doc::space())
-            .append(leading_comments(if_exists.syntax()))
-            .append(build_if_exists(if_exists));
-    }
+    doc = append_if_exists(doc, stmt.if_exists());
     if let Some(list) = stmt.routine_sig_list() {
         if let Some(routines) = build_comma_separated_docs(list.routine_sigs().map(|routine| {
             let syntax = routine.syntax().clone();
@@ -17350,12 +15651,7 @@ fn build_drop_routine<'a>(stmt: &ast::DropRoutine) -> Doc<'a> {
                 syntax,
             )
         })) {
-            doc = doc.append(
-                Doc::line_or_space()
-                    .append(leading_comments(list.syntax()))
-                    .append(routines)
-                    .nest(2),
-            );
+            doc = append_nested_clause(doc, list.syntax(), routines);
         }
     }
     doc = append_drop_behavior(doc, stmt.drop_behavior());
@@ -17364,19 +15660,9 @@ fn build_drop_routine<'a>(stmt: &ast::DropRoutine) -> Doc<'a> {
 
 fn build_drop_rule<'a>(stmt: &ast::DropRule) -> Doc<'a> {
     let mut doc = build_keyword_tokens([(stmt.drop_token(), "drop"), (stmt.rule_token(), "rule")]);
-    if let Some(if_exists) = stmt.if_exists() {
-        doc = doc
-            .append(Doc::space())
-            .append(leading_comments(if_exists.syntax()))
-            .append(build_if_exists(if_exists));
-    }
+    doc = append_if_exists(doc, stmt.if_exists());
     if let Some(rule) = stmt.rule_ref() {
-        doc = doc.append(
-            Doc::line_or_space()
-                .append(leading_comments(rule.syntax()))
-                .append(build_name(rule.syntax()))
-                .nest(2),
-        );
+        doc = append_nested_clause(doc, rule.syntax(), build_name(rule.syntax()));
     }
     if let Some(on) = stmt.on_relation() {
         let mut on_doc = build_keyword_tokens([(on.on_token(), "on")]);
@@ -17385,12 +15671,7 @@ fn build_drop_rule<'a>(stmt: &ast::DropRule) -> Doc<'a> {
                 .append(Doc::space())
                 .append(build_extension_path_value(&relation));
         }
-        doc = doc.append(
-            Doc::line_or_space()
-                .append(leading_comments(on.syntax()))
-                .append(on_doc)
-                .nest(2),
-        );
+        doc = append_nested_clause(doc, on.syntax(), on_doc);
     }
     doc = append_drop_behavior(doc, stmt.drop_behavior());
     doc.group().append(build_semicolon(stmt.semicolon_token()))
@@ -17399,12 +15680,7 @@ fn build_drop_rule<'a>(stmt: &ast::DropRule) -> Doc<'a> {
 fn build_drop_schema<'a>(stmt: &ast::DropSchema) -> Doc<'a> {
     let mut doc =
         build_keyword_tokens([(stmt.drop_token(), "drop"), (stmt.schema_token(), "schema")]);
-    if let Some(if_exists) = stmt.if_exists() {
-        doc = doc
-            .append(Doc::space())
-            .append(leading_comments(if_exists.syntax()))
-            .append(build_if_exists(if_exists));
-    }
+    doc = append_if_exists(doc, stmt.if_exists());
     if let Some(schemas) = build_comma_separated_docs(stmt.schema_refs().map(|schema| {
         let syntax = schema.syntax().clone();
         (
@@ -17423,12 +15699,7 @@ fn build_drop_sequence<'a>(stmt: &ast::DropSequence) -> Doc<'a> {
         (stmt.drop_token(), "drop"),
         (stmt.sequence_token(), "sequence"),
     ]);
-    if let Some(if_exists) = stmt.if_exists() {
-        doc = doc
-            .append(Doc::space())
-            .append(leading_comments(if_exists.syntax()))
-            .append(build_if_exists(if_exists));
-    }
+    doc = append_if_exists(doc, stmt.if_exists());
     if let Some(sequences) = build_comma_separated_docs(stmt.sequence_refs().map(|sequence| {
         let syntax = sequence.syntax().clone();
         (build_extension_path_value(&sequence), syntax)
@@ -17442,12 +15713,7 @@ fn build_drop_sequence<'a>(stmt: &ast::DropSequence) -> Doc<'a> {
 fn build_drop_server<'a>(stmt: &ast::DropServer) -> Doc<'a> {
     let mut doc =
         build_keyword_tokens([(stmt.drop_token(), "drop"), (stmt.server_token(), "server")]);
-    if let Some(if_exists) = stmt.if_exists() {
-        doc = doc
-            .append(Doc::space())
-            .append(leading_comments(if_exists.syntax()))
-            .append(build_if_exists(if_exists));
-    }
+    doc = append_if_exists(doc, stmt.if_exists());
     if let Some(servers) = build_comma_separated_docs(stmt.server_refs().map(|server| {
         let syntax = server.syntax().clone();
         (
@@ -17466,12 +15732,7 @@ fn build_drop_statistics<'a>(stmt: &ast::DropStatistics) -> Doc<'a> {
         (stmt.drop_token(), "drop"),
         (stmt.statistics_token(), "statistics"),
     ]);
-    if let Some(if_exists) = stmt.if_exists() {
-        doc = doc
-            .append(Doc::space())
-            .append(leading_comments(if_exists.syntax()))
-            .append(build_if_exists(if_exists));
-    }
+    doc = append_if_exists(doc, stmt.if_exists());
     if let Some(statistics) = build_comma_separated_docs(stmt.statistics_refs().map(|statistics| {
         let syntax = statistics.syntax().clone();
         (build_extension_path_value(&statistics), syntax)
@@ -17485,12 +15746,7 @@ fn build_drop_statistics<'a>(stmt: &ast::DropStatistics) -> Doc<'a> {
 fn build_drop_table<'a>(stmt: &ast::DropTable) -> Doc<'a> {
     let mut doc =
         build_keyword_tokens([(stmt.drop_token(), "drop"), (stmt.table_token(), "table")]);
-    if let Some(if_exists) = stmt.if_exists() {
-        doc = doc
-            .append(Doc::space())
-            .append(leading_comments(if_exists.syntax()))
-            .append(build_if_exists(if_exists));
-    }
+    doc = append_if_exists(doc, stmt.if_exists());
     if let Some(tables) = build_comma_separated_docs(stmt.table_name_refs().map(|table| {
         let syntax = table.syntax().clone();
         (build_extension_path_value(&table), syntax)
@@ -17503,12 +15759,7 @@ fn build_drop_table<'a>(stmt: &ast::DropTable) -> Doc<'a> {
 
 fn build_drop_view<'a>(stmt: &ast::DropView) -> Doc<'a> {
     let mut doc = build_keyword_tokens([(stmt.drop_token(), "drop"), (stmt.view_token(), "view")]);
-    if let Some(if_exists) = stmt.if_exists() {
-        doc = doc
-            .append(Doc::space())
-            .append(leading_comments(if_exists.syntax()))
-            .append(build_if_exists(if_exists));
-    }
+    doc = append_if_exists(doc, stmt.if_exists());
     if let Some(views) = build_comma_separated_docs(stmt.view_refs().map(|view| {
         let syntax = view.syntax().clone();
         (build_extension_path_value(&view), syntax)
@@ -17524,19 +15775,9 @@ fn build_drop_tablespace<'a>(stmt: &ast::DropTablespace) -> Doc<'a> {
         (stmt.drop_token(), "drop"),
         (stmt.tablespace_token(), "tablespace"),
     ]);
-    if let Some(if_exists) = stmt.if_exists() {
-        doc = doc
-            .append(Doc::space())
-            .append(leading_comments(if_exists.syntax()))
-            .append(build_if_exists(if_exists));
-    }
+    doc = append_if_exists(doc, stmt.if_exists());
     if let Some(tablespace) = stmt.tablespace_ref() {
-        doc = doc.append(
-            Doc::line_or_space()
-                .append(leading_comments(tablespace.syntax()))
-                .append(build_name(tablespace.syntax()))
-                .nest(2),
-        );
+        doc = append_nested_clause(doc, tablespace.syntax(), build_name(tablespace.syntax()));
     }
     doc.group().append(build_semicolon(stmt.semicolon_token()))
 }
@@ -17548,12 +15789,7 @@ fn build_drop_text_search_config<'a>(stmt: &ast::DropTextSearchConfig) -> Doc<'a
         (stmt.search_token(), "search"),
         (stmt.configuration_token(), "configuration"),
     ]);
-    if let Some(if_exists) = stmt.if_exists() {
-        doc = doc
-            .append(Doc::space())
-            .append(leading_comments(if_exists.syntax()))
-            .append(build_if_exists(if_exists));
-    }
+    doc = append_if_exists(doc, stmt.if_exists());
     if let Some(configuration) = stmt.text_search_configuration_ref() {
         doc = doc.append(
             Doc::line_or_space()
@@ -17572,12 +15808,7 @@ fn build_drop_text_search_dict<'a>(stmt: &ast::DropTextSearchDict) -> Doc<'a> {
         (stmt.search_token(), "search"),
         (stmt.dictionary_token(), "dictionary"),
     ]);
-    if let Some(if_exists) = stmt.if_exists() {
-        doc = doc
-            .append(Doc::space())
-            .append(leading_comments(if_exists.syntax()))
-            .append(build_if_exists(if_exists));
-    }
+    doc = append_if_exists(doc, stmt.if_exists());
     if let Some(dictionary) = stmt.text_search_dictionary_ref() {
         doc = doc.append(
             Doc::line_or_space()
@@ -17596,12 +15827,7 @@ fn build_drop_text_search_parser<'a>(stmt: &ast::DropTextSearchParser) -> Doc<'a
         (stmt.search_token(), "search"),
         (stmt.parser_token(), "parser"),
     ]);
-    if let Some(if_exists) = stmt.if_exists() {
-        doc = doc
-            .append(Doc::space())
-            .append(leading_comments(if_exists.syntax()))
-            .append(build_if_exists(if_exists));
-    }
+    doc = append_if_exists(doc, stmt.if_exists());
     if let Some(parser) = stmt.text_search_parser_ref() {
         doc = doc.append(
             Doc::line_or_space()
@@ -17620,12 +15846,7 @@ fn build_drop_text_search_template<'a>(stmt: &ast::DropTextSearchTemplate) -> Do
         (stmt.search_token(), "search"),
         (stmt.template_token(), "template"),
     ]);
-    if let Some(if_exists) = stmt.if_exists() {
-        doc = doc
-            .append(Doc::space())
-            .append(leading_comments(if_exists.syntax()))
-            .append(build_if_exists(if_exists));
-    }
+    doc = append_if_exists(doc, stmt.if_exists());
     if let Some(template) = stmt.text_search_template_ref() {
         doc = doc.append(
             Doc::line_or_space()
@@ -17642,12 +15863,7 @@ fn build_drop_transform<'a>(stmt: &ast::DropTransform) -> Doc<'a> {
         (stmt.drop_token(), "drop"),
         (stmt.transform_token(), "transform"),
     ]);
-    if let Some(if_exists) = stmt.if_exists() {
-        doc = doc
-            .append(Doc::space())
-            .append(leading_comments(if_exists.syntax()))
-            .append(build_if_exists(if_exists));
-    }
+    doc = append_if_exists(doc, stmt.if_exists());
     if let Some(for_token) = stmt.for_token() {
         doc = doc
             .append(Doc::space())
@@ -17655,12 +15871,7 @@ fn build_drop_transform<'a>(stmt: &ast::DropTransform) -> Doc<'a> {
             .append(Doc::text("for"));
     }
     if let Some(ty) = stmt.ty() {
-        doc = doc.append(
-            Doc::line_or_space()
-                .append(leading_comments(ty.syntax()))
-                .append(build_type(ty))
-                .nest(2),
-        );
+        doc = append_nested_node(doc, ty, build_type);
     }
     if let Some(language_token) = stmt.language_token() {
         doc = doc.append(
@@ -17685,19 +15896,9 @@ fn build_drop_trigger<'a>(stmt: &ast::DropTrigger) -> Doc<'a> {
         (stmt.drop_token(), "drop"),
         (stmt.trigger_token(), "trigger"),
     ]);
-    if let Some(if_exists) = stmt.if_exists() {
-        doc = doc
-            .append(Doc::space())
-            .append(leading_comments(if_exists.syntax()))
-            .append(build_if_exists(if_exists));
-    }
+    doc = append_if_exists(doc, stmt.if_exists());
     if let Some(trigger) = stmt.trigger_ref() {
-        doc = doc.append(
-            Doc::line_or_space()
-                .append(leading_comments(trigger.syntax()))
-                .append(build_name(trigger.syntax()))
-                .nest(2),
-        );
+        doc = append_nested_clause(doc, trigger.syntax(), build_name(trigger.syntax()));
     }
     if let Some(on) = stmt.on_relation() {
         let mut on_doc = build_keyword_tokens([(on.on_token(), "on")]);
@@ -17706,12 +15907,7 @@ fn build_drop_trigger<'a>(stmt: &ast::DropTrigger) -> Doc<'a> {
                 .append(Doc::space())
                 .append(build_extension_path_value(&relation));
         }
-        doc = doc.append(
-            Doc::line_or_space()
-                .append(leading_comments(on.syntax()))
-                .append(on_doc)
-                .nest(2),
-        );
+        doc = append_nested_clause(doc, on.syntax(), on_doc);
     }
     doc = append_drop_behavior(doc, stmt.drop_behavior());
     doc.group().append(build_semicolon(stmt.semicolon_token()))
@@ -17719,12 +15915,7 @@ fn build_drop_trigger<'a>(stmt: &ast::DropTrigger) -> Doc<'a> {
 
 fn build_drop_type<'a>(stmt: &ast::DropType) -> Doc<'a> {
     let mut doc = build_keyword_tokens([(stmt.drop_token(), "drop"), (stmt.type_token(), "type")]);
-    if let Some(if_exists) = stmt.if_exists() {
-        doc = doc
-            .append(Doc::space())
-            .append(leading_comments(if_exists.syntax()))
-            .append(build_if_exists(if_exists));
-    }
+    doc = append_if_exists(doc, stmt.if_exists());
     if let Some(types) = build_comma_separated_docs(stmt.type_name_refs().map(|ty| {
         let syntax = ty.syntax().clone();
         (build_extension_path_value(&ty), syntax)
@@ -17737,12 +15928,7 @@ fn build_drop_type<'a>(stmt: &ast::DropType) -> Doc<'a> {
 
 fn build_drop_user<'a>(stmt: &ast::DropUser) -> Doc<'a> {
     let mut doc = build_keyword_tokens([(stmt.drop_token(), "drop"), (stmt.user_token(), "user")]);
-    if let Some(if_exists) = stmt.if_exists() {
-        doc = doc
-            .append(Doc::space())
-            .append(leading_comments(if_exists.syntax()))
-            .append(build_if_exists(if_exists));
-    }
+    doc = append_if_exists(doc, stmt.if_exists());
     if let Some(users) = build_comma_separated_docs(stmt.role_refs().map(|user| {
         let syntax = user.syntax().clone();
         (
@@ -17761,12 +15947,7 @@ fn build_drop_user_mapping<'a>(stmt: &ast::DropUserMapping) -> Doc<'a> {
         (stmt.user_token(), "user"),
         (stmt.mapping_token(), "mapping"),
     ]);
-    if let Some(if_exists) = stmt.if_exists() {
-        doc = doc
-            .append(Doc::space())
-            .append(leading_comments(if_exists.syntax()))
-            .append(build_if_exists(if_exists));
-    }
+    doc = append_if_exists(doc, stmt.if_exists());
     if let Some(for_token) = stmt.for_token() {
         doc = doc
             .append(Doc::space())
@@ -17774,20 +15955,10 @@ fn build_drop_user_mapping<'a>(stmt: &ast::DropUserMapping) -> Doc<'a> {
             .append(Doc::text("for"));
     }
     if let Some(role) = stmt.user_mapping_role() {
-        doc = doc.append(
-            Doc::line_or_space()
-                .append(leading_comments(role.syntax()))
-                .append(build_user_mapping_role(&role))
-                .nest(2),
-        );
+        doc = append_nested_clause(doc, role.syntax(), build_user_mapping_role(&role));
     }
     if let Some(server) = stmt.server_clause() {
-        doc = doc.append(
-            Doc::line_or_space()
-                .append(leading_comments(server.syntax()))
-                .append(build_server_clause(server))
-                .nest(2),
-        );
+        doc = append_nested_node(doc, server, build_server_clause);
     }
     doc.group().append(build_semicolon(stmt.semicolon_token()))
 }
@@ -17800,12 +15971,7 @@ fn build_drop_publication<'a>(stmt: &ast::DropPublication) -> Doc<'a> {
             .append(leading_comments_token(&token))
             .append(Doc::text("publication"));
     }
-    if let Some(if_exists) = stmt.if_exists() {
-        doc = doc
-            .append(Doc::space())
-            .append(leading_comments(if_exists.syntax()))
-            .append(build_if_exists(if_exists));
-    }
+    doc = append_if_exists(doc, stmt.if_exists());
     if let Some(publications) = build_publication_refs(stmt.publication_refs()) {
         doc = doc
             .append(Doc::line_or_space())
@@ -17823,12 +15989,7 @@ fn build_drop_subscription<'a>(stmt: &ast::DropSubscription) -> Doc<'a> {
             .append(leading_comments_token(&token))
             .append(Doc::text("subscription"));
     }
-    if let Some(if_exists) = stmt.if_exists() {
-        doc = doc
-            .append(Doc::space())
-            .append(leading_comments(if_exists.syntax()))
-            .append(build_if_exists(if_exists));
-    }
+    doc = append_if_exists(doc, stmt.if_exists());
     if let Some(subscription) = stmt.subscription_ref() {
         doc = doc
             .append(Doc::line_or_space())
@@ -17839,25 +16000,31 @@ fn build_drop_subscription<'a>(stmt: &ast::DropSubscription) -> Doc<'a> {
     doc.append(build_semicolon(stmt.semicolon_token())).group()
 }
 
-fn build_if_exists<'a>(if_exists: ast::IfExists) -> Doc<'a> {
-    let mut doc = Doc::text("if");
-    if let Some(token) = if_exists.exists_token() {
+fn append_if_not_exists<'a>(mut doc: Doc<'a>, if_not_exists: Option<ast::IfNotExists>) -> Doc<'a> {
+    if let Some(if_not_exists) = if_not_exists {
+        let keywords = build_keyword_node(if_not_exists.syntax());
         doc = doc
             .append(Doc::space())
-            .append(leading_comments_token(&token))
-            .append(Doc::text("exists"));
+            .append(leading_comments(if_not_exists.syntax()))
+            .append(keywords);
+    }
+    doc
+}
+
+fn append_if_exists<'a>(mut doc: Doc<'a>, if_exists: Option<ast::IfExists>) -> Doc<'a> {
+    if let Some(if_exists) = if_exists {
+        let keywords = build_keyword_node(if_exists.syntax());
+        doc = doc
+            .append(Doc::space())
+            .append(leading_comments(if_exists.syntax()))
+            .append(keywords);
     }
     doc
 }
 
 fn append_drop_behavior<'a>(doc: Doc<'a>, behavior: Option<ast::DropBehavior>) -> Doc<'a> {
     if let Some(behavior) = behavior {
-        doc.append(
-            Doc::line_or_space()
-                .append(leading_comments(behavior.syntax()))
-                .append(build_drop_behavior(behavior))
-                .nest(2),
-        )
+        append_nested_node(doc, behavior, build_drop_behavior)
     } else {
         doc
     }
@@ -18782,7 +16949,7 @@ fn build_json_table_plan<'a>(plan: ast::JsonTablePlan) -> Doc<'a> {
             doc.group()
         }
         ast::JsonTablePlan::ParenJsonTablePlan(plan) => {
-            let mut doc = plan
+            let doc = plan
                 .l_paren_token()
                 .map(comments_before)
                 .unwrap_or_else(Doc::nil)
@@ -18794,8 +16961,7 @@ fn build_json_table_plan<'a>(plan: ast::JsonTablePlan) -> Doc<'a> {
             if let Some(r_paren) = plan.r_paren_token() {
                 body = body.append(comments_before(r_paren));
             }
-            doc = doc.append(wrap_body(body)).append(Doc::text(")")).group();
-            doc
+            doc.append(wrap_body(body)).append(Doc::text(")")).group()
         }
     }
 }
@@ -18867,7 +17033,7 @@ fn build_xml_table<'a>(xml_table: ast::XmlTable) -> Doc<'a> {
 }
 
 fn build_xml_namespace_list<'a>(list: ast::XmlNamespaceList) -> Doc<'a> {
-    let mut doc = list
+    let doc = list
         .l_paren_token()
         .map(comments_before)
         .unwrap_or_else(Doc::nil)
@@ -18882,8 +17048,7 @@ fn build_xml_namespace_list<'a>(list: ast::XmlNamespaceList) -> Doc<'a> {
     if let Some(r_paren) = list.r_paren_token() {
         body = body.append(comments_before(r_paren));
     }
-    doc = doc.append(wrap_body(body)).append(Doc::text(")")).group();
-    doc
+    doc.append(wrap_body(body)).append(Doc::text(")")).group()
 }
 
 fn build_xml_namespace<'a>(namespace: ast::XmlNamespace) -> Doc<'a> {
@@ -19721,12 +17886,7 @@ fn build_graph_table_fn<'a>(graph_table_fn: ast::GraphTableFn) -> Doc<'a> {
             .append(Doc::text("match"));
     }
     if let Some(patterns) = graph_table_fn.path_pattern_list() {
-        body = body.append(
-            Doc::line_or_space()
-                .append(leading_comments(patterns.syntax()))
-                .append(build_path_pattern_list(patterns))
-                .nest(2),
-        );
+        body = append_nested_node(body, patterns, build_path_pattern_list);
     }
     if let Some(where_clause) = graph_table_fn.where_clause() {
         body = body
@@ -19951,12 +18111,7 @@ fn build_where_clause<'a>(where_clause: ast::WhereClause) -> Doc<'a> {
             }
             _ => build_expr(expr.clone()),
         };
-        doc = doc.append(
-            Doc::line_or_space()
-                .append(leading_comments(expr.syntax()))
-                .append(expr_doc)
-                .nest(2),
-        );
+        doc = append_nested_clause(doc, expr.syntax(), expr_doc);
     }
     doc.group()
 }
@@ -21833,12 +19988,7 @@ fn build_case_expr<'a>(case_expr: ast::CaseExpr) -> Doc<'a> {
     }
 
     if let Some(else_clause) = case_expr.else_clause() {
-        doc = doc.append(
-            Doc::line_or_space()
-                .append(leading_comments(else_clause.syntax()))
-                .append(build_else_clause(else_clause))
-                .nest(2),
-        );
+        doc = append_nested_node(doc, else_clause, build_else_clause);
     }
 
     if let Some(end) = case_expr.end_token() {
@@ -21864,12 +20014,7 @@ fn build_when_clause<'a>(when_clause: ast::WhenClause) -> Doc<'a> {
             .append(Doc::text("then"));
     }
     if let Some(result) = when_clause.then() {
-        doc = doc.append(
-            Doc::line_or_space()
-                .append(leading_comments(result.syntax()))
-                .append(build_expr(result))
-                .nest(2),
-        );
+        doc = append_nested_node(doc, result, build_expr);
     }
     doc.group()
 }
@@ -21877,12 +20022,7 @@ fn build_when_clause<'a>(when_clause: ast::WhenClause) -> Doc<'a> {
 fn build_else_clause<'a>(else_clause: ast::ElseClause) -> Doc<'a> {
     let mut doc = Doc::text("else");
     if let Some(expr) = else_clause.expr() {
-        doc = doc.append(
-            Doc::line_or_space()
-                .append(leading_comments(expr.syntax()))
-                .append(build_expr(expr))
-                .nest(2),
-        );
+        doc = append_nested_node(doc, expr, build_expr);
     }
     doc
 }
@@ -21954,15 +20094,7 @@ fn build_collate_expr<'a>(collate: ast::Collate) -> Doc<'a> {
     }
     doc = doc.append(Doc::text("collate"));
 
-    if let Some(collation) = collate.collation_ref() {
-        doc = doc
-            .append(Doc::space())
-            .append(leading_comments(collation.syntax()));
-        if let Some(path) = collation.path_ref() {
-            doc = doc.append(build_path_ref(&path));
-        }
-    }
-    doc
+    append_commented_path_ref(doc, collate.collation_ref())
 }
 
 fn build_paren_expr<'a>(paren_expr: ast::ParenExpr) -> Doc<'a> {
@@ -22182,7 +20314,7 @@ fn build_normalized_postfix<'a>(
         doc = doc
             .append(Doc::space())
             .append(leading_comments(form.syntax()))
-            .append(build_unicode_normal_form(form));
+            .append(build_keyword_node(form.syntax()));
     }
     append_keyword_token(doc, normalized_token, "normalized")
 }
@@ -22550,18 +20682,6 @@ fn build_json_keys_unique_clause<'a>(clause: ast::JsonKeysUniqueClause) -> Doc<'
     doc
 }
 
-fn build_unicode_normal_form<'a>(form: ast::UnicodeNormalForm) -> Doc<'a> {
-    if form.nfc_token().is_some() {
-        Doc::text("nfc")
-    } else if form.nfd_token().is_some() {
-        Doc::text("nfd")
-    } else if form.nfkc_token().is_some() {
-        Doc::text("nfkc")
-    } else {
-        Doc::text("nfkd")
-    }
-}
-
 fn build_keyword_node<'a>(node: &SyntaxNode) -> Doc<'a> {
     let mut docs: Vec<Doc<'a>> = vec![];
     let mut after_line_comment = false;
diff --git a/crates/squawk_fmt/tests/after/alter_text_search_configuration.snap b/crates/squawk_fmt/tests/after/alter_text_search_configuration.snap
index ebff0c68..69e3c6c0 100644
--- a/crates/squawk_fmt/tests/after/alter_text_search_configuration.snap
+++ b/crates/squawk_fmt/tests/after/alter_text_search_configuration.snap
@@ -33,8 +33,7 @@ alter text search configuration public.english
   /* new */ public.new_dictionary;
 
 alter text search configuration public.english
-  drop /* mapping */ mapping
-  /* if */ if /* exists */ exists
+  drop /* mapping */ mapping /* if */ if /* exists */ exists
   /* for */ for
     /* kind */ url /* comma */,
     /* second kind */ host;
diff --git a/crates/squawk_fmt/tests/after/create_function.snap b/crates/squawk_fmt/tests/after/create_function.snap
index 156b58e8..4e9aec20 100644
--- a/crates/squawk_fmt/tests/after/create_function.snap
+++ b/crates/squawk_fmt/tests/after/create_function.snap
@@ -72,6 +72,20 @@ create function percent_type_table(
   language sql
   as $$ select 1 $$;
 
+create or replace function /* TEMPLATE: schema */ river_job_notify() returns trigger
+  as $$
+DECLARE
+  payload json;
+BEGIN
+  ...
+END;
+$$
+  language plpgsql;
+
+create function foo( /* no params */) returns t
+  as $$select 1$$
+  language sql;
+
 -- comments in every position
 create /*a*/ or /*b*/ replace /*c*/ function /*d*/ app /*e*/./*f*/ commented(
   /*g*/ in /*h*/ value /*i*/ integer /*j*/ default /*k*/ 1 /*l*/,
diff --git a/crates/squawk_fmt/tests/before/create_function.sql b/crates/squawk_fmt/tests/before/create_function.sql
index 2d9bbd5d..660b3d27 100644
--- a/crates/squawk_fmt/tests/before/create_function.sql
+++ b/crates/squawk_fmt/tests/before/create_function.sql
@@ -14,6 +14,21 @@ create function percent_type_param(value accounts.id%type) returns accounts.id%t
 
 create function percent_type_table(unused integer) returns table (value accounts /*pct1*/. id /*pct2*/% /*pct3*/type) language sql as $$ select 1 $$;
 
+CREATE OR REPLACE FUNCTION /* TEMPLATE: schema */river_job_notify()
+  RETURNS TRIGGER
+  AS $$
+DECLARE
+  payload json;
+BEGIN
+  ...
+END;
+$$
+LANGUAGE plpgsql;
+
+create function foo(/* no params */) returns t
+  as $$select 1$$
+  language sql;
+
 -- comments in every position
 create /*a*/ or /*b*/ replace /*c*/ function /*d*/ app /*e*/. /*f*/ commented
 (/*g*/ in /*h*/ value /*i*/ integer /*j*/ default /*k*/ 1 /*l*/, /*m*/ in /*n*/ result /*o*/ text /*p*/)