Skip to content

Commit 6b1dd48

Browse files
psteinroepsteinroe
committed
progress
1 parent 46011c9 commit 6b1dd48

File tree

373 files changed

+20915
-77
lines changed

Some content is hidden

Large Commits have some content hidden by default. Use the searchbox below for content that may be hidden.

373 files changed

+20915
-77
lines changed

‎agentic/pretty_printer.md‎

Lines changed: 2553 additions & 3 deletions
Large diffs are not rendered by default.

‎crates/pgt_pretty_print/src/nodes/a_array_expr.rs‎

Lines changed: 23 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,23 @@
1+
use pgt_query::protobuf::AArrayExpr;
2+
3+
use crate::{
4+
TokenKind,
5+
emitter::{EventEmitter, GroupKind},
6+
};
7+
8+
use super::node_list::emit_comma_separated_list;
9+
10+
pub(super) fn emit_a_array_expr(e: &mut EventEmitter, n: &AArrayExpr) {
11+
e.group_start(GroupKind::AArrayExpr);
12+
13+
e.token(TokenKind::ARRAY_KW);
14+
e.token(TokenKind::L_BRACK);
15+
16+
if !n.elements.is_empty() {
17+
emit_comma_separated_list(e, &n.elements, super::emit_node);
18+
}
19+
20+
e.token(TokenKind::R_BRACK);
21+
22+
e.group_end();
23+
}

‎crates/pgt_pretty_print/src/nodes/a_expr.rs‎

Lines changed: 314 additions & 3 deletions
Original file line numberDiff line numberDiff line change
@@ -1,12 +1,36 @@
11
use pgt_query::protobuf::{AExpr, AExprKind};
22

3-
use crate::emitter::{EventEmitter, GroupKind};
3+
use crate::{
4+
TokenKind,
5+
emitter::{EventEmitter, GroupKind},
6+
};
47

58
pub(super) fn emit_a_expr(e: &mut EventEmitter, n: &AExpr) {
69
e.group_start(GroupKind::AExpr);
710

8-
assert_eq!(n.kind(), AExprKind::AexprOp);
11+
match n.kind() {
12+
AExprKind::AexprOp => emit_aexpr_op(e, n),
13+
AExprKind::AexprOpAny => emit_aexpr_op_any(e, n),
14+
AExprKind::AexprOpAll => emit_aexpr_op_all(e, n),
15+
AExprKind::AexprDistinct => emit_aexpr_distinct(e, n),
16+
AExprKind::AexprNotDistinct => emit_aexpr_not_distinct(e, n),
17+
AExprKind::AexprNullif => emit_aexpr_nullif(e, n),
18+
AExprKind::AexprIn => emit_aexpr_in(e, n),
19+
AExprKind::AexprLike => emit_aexpr_like(e, n),
20+
AExprKind::AexprIlike => emit_aexpr_ilike(e, n),
21+
AExprKind::AexprSimilar => emit_aexpr_similar(e, n),
22+
AExprKind::AexprBetween => emit_aexpr_between(e, n),
23+
AExprKind::AexprNotBetween => emit_aexpr_not_between(e, n),
24+
AExprKind::AexprBetweenSym => emit_aexpr_between_sym(e, n),
25+
AExprKind::AexprNotBetweenSym => emit_aexpr_not_between_sym(e, n),
26+
AExprKind::Undefined => {}
27+
}
28+
29+
e.group_end();
30+
}
931

32+
// Basic binary operator: left op right
33+
fn emit_aexpr_op(e: &mut EventEmitter, n: &AExpr) {
1034
if let Some(ref lexpr) = n.lexpr {
1135
super::emit_node(lexpr, e);
1236
}
@@ -22,6 +46,293 @@ pub(super) fn emit_a_expr(e: &mut EventEmitter, n: &AExpr) {
2246
if let Some(ref rexpr) = n.rexpr {
2347
super::emit_node(rexpr, e);
2448
}
49+
}
2550

26-
e.group_end();
51+
// expr op ANY (subquery)
52+
fn emit_aexpr_op_any(e: &mut EventEmitter, n: &AExpr) {
53+
if let Some(ref lexpr) = n.lexpr {
54+
super::emit_node(lexpr, e);
55+
e.space();
56+
}
57+
58+
if !n.name.is_empty() {
59+
for name in &n.name {
60+
super::emit_node(name, e);
61+
}
62+
e.space();
63+
}
64+
65+
e.token(TokenKind::ANY_KW);
66+
e.space();
67+
68+
if let Some(ref rexpr) = n.rexpr {
69+
super::emit_node(rexpr, e);
70+
}
71+
}
72+
73+
// expr op ALL (subquery)
74+
fn emit_aexpr_op_all(e: &mut EventEmitter, n: &AExpr) {
75+
if let Some(ref lexpr) = n.lexpr {
76+
super::emit_node(lexpr, e);
77+
e.space();
78+
}
79+
80+
if !n.name.is_empty() {
81+
for name in &n.name {
82+
super::emit_node(name, e);
83+
}
84+
e.space();
85+
}
86+
87+
e.token(TokenKind::ALL_KW);
88+
e.space();
89+
90+
if let Some(ref rexpr) = n.rexpr {
91+
super::emit_node(rexpr, e);
92+
}
93+
}
94+
95+
// expr IS DISTINCT FROM expr2
96+
fn emit_aexpr_distinct(e: &mut EventEmitter, n: &AExpr) {
97+
if let Some(ref lexpr) = n.lexpr {
98+
super::emit_node(lexpr, e);
99+
e.space();
100+
}
101+
102+
e.token(TokenKind::IS_KW);
103+
e.space();
104+
e.token(TokenKind::DISTINCT_KW);
105+
e.space();
106+
e.token(TokenKind::FROM_KW);
107+
e.space();
108+
109+
if let Some(ref rexpr) = n.rexpr {
110+
super::emit_node(rexpr, e);
111+
}
112+
}
113+
114+
// expr IS NOT DISTINCT FROM expr2
115+
fn emit_aexpr_not_distinct(e: &mut EventEmitter, n: &AExpr) {
116+
if let Some(ref lexpr) = n.lexpr {
117+
super::emit_node(lexpr, e);
118+
e.space();
119+
}
120+
121+
e.token(TokenKind::IS_KW);
122+
e.space();
123+
e.token(TokenKind::NOT_KW);
124+
e.space();
125+
e.token(TokenKind::DISTINCT_KW);
126+
e.space();
127+
e.token(TokenKind::FROM_KW);
128+
e.space();
129+
130+
if let Some(ref rexpr) = n.rexpr {
131+
super::emit_node(rexpr, e);
132+
}
133+
}
134+
135+
// NULLIF(expr, expr2)
136+
fn emit_aexpr_nullif(e: &mut EventEmitter, n: &AExpr) {
137+
e.token(TokenKind::NULLIF_KW);
138+
e.token(TokenKind::L_PAREN);
139+
140+
if let Some(ref lexpr) = n.lexpr {
141+
super::emit_node(lexpr, e);
142+
}
143+
144+
e.token(TokenKind::COMMA);
145+
e.space();
146+
147+
if let Some(ref rexpr) = n.rexpr {
148+
super::emit_node(rexpr, e);
149+
}
150+
151+
e.token(TokenKind::R_PAREN);
152+
}
153+
154+
// expr IN (values)
155+
fn emit_aexpr_in(e: &mut EventEmitter, n: &AExpr) {
156+
if let Some(ref lexpr) = n.lexpr {
157+
super::emit_node(lexpr, e);
158+
e.space();
159+
}
160+
161+
e.token(TokenKind::IN_KW);
162+
e.space();
163+
164+
// The rexpr is typically a List node, which emits comma-separated items
165+
// We need to wrap it in parentheses for IN clause
166+
e.token(TokenKind::L_PAREN);
167+
if let Some(ref rexpr) = n.rexpr {
168+
super::emit_node(rexpr, e);
169+
}
170+
e.token(TokenKind::R_PAREN);
171+
}
172+
173+
// expr LIKE pattern [ESCAPE escape]
174+
fn emit_aexpr_like(e: &mut EventEmitter, n: &AExpr) {
175+
if let Some(ref lexpr) = n.lexpr {
176+
super::emit_node(lexpr, e);
177+
e.space();
178+
}
179+
180+
e.token(TokenKind::LIKE_KW);
181+
e.space();
182+
183+
if let Some(ref rexpr) = n.rexpr {
184+
super::emit_node(rexpr, e);
185+
}
186+
}
187+
188+
// expr ILIKE pattern [ESCAPE escape]
189+
fn emit_aexpr_ilike(e: &mut EventEmitter, n: &AExpr) {
190+
if let Some(ref lexpr) = n.lexpr {
191+
super::emit_node(lexpr, e);
192+
e.space();
193+
}
194+
195+
e.token(TokenKind::ILIKE_KW);
196+
e.space();
197+
198+
if let Some(ref rexpr) = n.rexpr {
199+
super::emit_node(rexpr, e);
200+
}
201+
}
202+
203+
// expr SIMILAR TO pattern [ESCAPE escape]
204+
fn emit_aexpr_similar(e: &mut EventEmitter, n: &AExpr) {
205+
if let Some(ref lexpr) = n.lexpr {
206+
super::emit_node(lexpr, e);
207+
e.space();
208+
}
209+
210+
e.token(TokenKind::SIMILAR_KW);
211+
e.space();
212+
e.token(TokenKind::TO_KW);
213+
e.space();
214+
215+
if let Some(ref rexpr) = n.rexpr {
216+
super::emit_node(rexpr, e);
217+
}
218+
}
219+
220+
// expr BETWEEN expr2 AND expr3
221+
fn emit_aexpr_between(e: &mut EventEmitter, n: &AExpr) {
222+
if let Some(ref lexpr) = n.lexpr {
223+
super::emit_node(lexpr, e);
224+
e.space();
225+
}
226+
227+
e.token(TokenKind::BETWEEN_KW);
228+
e.space();
229+
230+
// rexpr is a List node with two elements, but we need "expr AND expr" not "expr, expr"
231+
if let Some(ref rexpr) = n.rexpr {
232+
if let Some(pgt_query::NodeEnum::List(list)) = rexpr.node.as_ref() {
233+
if list.items.len() >= 1 {
234+
super::emit_node(&list.items[0], e);
235+
}
236+
if list.items.len() >= 2 {
237+
e.space();
238+
e.token(TokenKind::AND_KW);
239+
e.space();
240+
super::emit_node(&list.items[1], e);
241+
}
242+
} else {
243+
super::emit_node(rexpr, e);
244+
}
245+
}
246+
}
247+
248+
// expr NOT BETWEEN expr2 AND expr3
249+
fn emit_aexpr_not_between(e: &mut EventEmitter, n: &AExpr) {
250+
if let Some(ref lexpr) = n.lexpr {
251+
super::emit_node(lexpr, e);
252+
e.space();
253+
}
254+
255+
e.token(TokenKind::NOT_KW);
256+
e.space();
257+
e.token(TokenKind::BETWEEN_KW);
258+
e.space();
259+
260+
// rexpr is a List node with two elements, but we need "expr AND expr" not "expr, expr"
261+
if let Some(ref rexpr) = n.rexpr {
262+
if let Some(pgt_query::NodeEnum::List(list)) = rexpr.node.as_ref() {
263+
if list.items.len() >= 1 {
264+
super::emit_node(&list.items[0], e);
265+
}
266+
if list.items.len() >= 2 {
267+
e.space();
268+
e.token(TokenKind::AND_KW);
269+
e.space();
270+
super::emit_node(&list.items[1], e);
271+
}
272+
} else {
273+
super::emit_node(rexpr, e);
274+
}
275+
}
276+
}
277+
278+
// expr BETWEEN SYMMETRIC expr2 AND expr3
279+
fn emit_aexpr_between_sym(e: &mut EventEmitter, n: &AExpr) {
280+
if let Some(ref lexpr) = n.lexpr {
281+
super::emit_node(lexpr, e);
282+
e.space();
283+
}
284+
285+
e.token(TokenKind::BETWEEN_KW);
286+
e.space();
287+
e.token(TokenKind::SYMMETRIC_KW);
288+
e.space();
289+
290+
// rexpr is a List node with two elements, but we need "expr AND expr" not "expr, expr"
291+
if let Some(ref rexpr) = n.rexpr {
292+
if let Some(pgt_query::NodeEnum::List(list)) = rexpr.node.as_ref() {
293+
if list.items.len() >= 1 {
294+
super::emit_node(&list.items[0], e);
295+
}
296+
if list.items.len() >= 2 {
297+
e.space();
298+
e.token(TokenKind::AND_KW);
299+
e.space();
300+
super::emit_node(&list.items[1], e);
301+
}
302+
} else {
303+
super::emit_node(rexpr, e);
304+
}
305+
}
306+
}
307+
308+
// expr NOT BETWEEN SYMMETRIC expr2 AND expr3
309+
fn emit_aexpr_not_between_sym(e: &mut EventEmitter, n: &AExpr) {
310+
if let Some(ref lexpr) = n.lexpr {
311+
super::emit_node(lexpr, e);
312+
e.space();
313+
}
314+
315+
e.token(TokenKind::NOT_KW);
316+
e.space();
317+
e.token(TokenKind::BETWEEN_KW);
318+
e.space();
319+
e.token(TokenKind::SYMMETRIC_KW);
320+
e.space();
321+
322+
// rexpr is a List node with two elements, but we need "expr AND expr" not "expr, expr"
323+
if let Some(ref rexpr) = n.rexpr {
324+
if let Some(pgt_query::NodeEnum::List(list)) = rexpr.node.as_ref() {
325+
if list.items.len() >= 1 {
326+
super::emit_node(&list.items[0], e);
327+
}
328+
if list.items.len() >= 2 {
329+
e.space();
330+
e.token(TokenKind::AND_KW);
331+
e.space();
332+
super::emit_node(&list.items[1], e);
333+
}
334+
} else {
335+
super::emit_node(rexpr, e);
336+
}
337+
}
27338
}

‎crates/pgt_pretty_print/src/nodes/a_indices.rs‎

Lines changed: 31 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,31 @@
1+
use pgt_query::protobuf::AIndices;
2+
3+
use crate::{
4+
TokenKind,
5+
emitter::{EventEmitter, GroupKind},
6+
};
7+
8+
pub(super) fn emit_a_indices(e: &mut EventEmitter, n: &AIndices) {
9+
e.group_start(GroupKind::AIndices);
10+
11+
e.token(TokenKind::L_BRACK);
12+
13+
// Lower bound (if slice)
14+
if let Some(ref lidx) = n.lidx {
15+
super::emit_node(lidx, e);
16+
}
17+
18+
// If upper bound exists, this is a slice [lower:upper]
19+
if n.uidx.is_some() {
20+
e.token(TokenKind::IDENT(":".to_string()));
21+
}
22+
23+
// Upper bound
24+
if let Some(ref uidx) = n.uidx {
25+
super::emit_node(uidx, e);
26+
}
27+
28+
e.token(TokenKind::R_BRACK);
29+
30+
e.group_end();
31+
}

0 commit comments

Comments
 (0)