Skip to main content

uqa_sql/plan/memory/
source.rs

1//
2// Unified Query Algebra
3//
4// Copyright (c) 2023-2026 Cognica, Inc.
5//
6
7use uqa_core::memory::{AllocationObserver, ObserveAllocations};
8use uqa_core::ValueRetentionError;
9
10use crate::plan::{SourcePlan, TableFunctionPlan};
11
12impl ObserveAllocations for TableFunctionPlan {
13    fn observe_allocations<'a>(
14        &'a self,
15        observer: &mut AllocationObserver<'a, '_>,
16    ) -> Result<(), ValueRetentionError> {
17        let Self {
18            name,
19            binding,
20            output_name,
21            relations,
22            args,
23            column_aliases,
24            column_types,
25        } = self;
26        observer.child(name)?;
27        observer.child(binding)?;
28        observer.child(output_name)?;
29        observer.child(relations)?;
30        observer.child(args)?;
31        observer.child(column_aliases)?;
32        observer.child(column_types)?;
33        Ok(())
34    }
35}
36
37impl ObserveAllocations for SourcePlan {
38    fn observe_allocations<'a>(
39        &'a self,
40        observer: &mut AllocationObserver<'a, '_>,
41    ) -> Result<(), ValueRetentionError> {
42        match self {
43            Self::RetainedRows(_) => {}
44            Self::Table {
45                name,
46                executable_query,
47                qualifier,
48                alias,
49                column_aliases,
50                bound_columns,
51                include_descendants: _,
52            } => {
53                observer.child(name)?;
54                observer.child(executable_query)?;
55                observer.child(qualifier)?;
56                observer.child(alias)?;
57                observer.child(column_aliases)?;
58                observer.child(bound_columns)?;
59            }
60            Self::Join {
61                comma: _,
62                left,
63                right,
64                kind: _,
65                on,
66                using,
67                natural: _,
68                alias,
69                column_aliases,
70                lateral: _,
71                strategy: _,
72            } => {
73                observer.child(left)?;
74                observer.child(right)?;
75                observer.child(on)?;
76                observer.child(using)?;
77                observer.child(alias)?;
78                observer.child(column_aliases)?;
79            }
80            Self::Values {
81                lateral: _,
82                rows,
83                alias,
84                column_aliases,
85                internal_relation,
86                internal_column_types,
87                internal_column_collations,
88            } => {
89                observer.child(rows)?;
90                observer.child(alias)?;
91                observer.child(column_aliases)?;
92                observer.child(internal_relation)?;
93                observer.child(internal_column_types)?;
94                observer.child(internal_column_collations)?;
95            }
96            Self::Function {
97                name,
98                binding,
99                output_name,
100                relations,
101                args,
102                alias,
103                column_aliases,
104                ordinality: _,
105                column_types,
106            } => {
107                observer.child(name)?;
108                observer.child(binding)?;
109                observer.child(output_name)?;
110                observer.child(relations)?;
111                observer.child(args)?;
112                observer.child(alias)?;
113                observer.child(column_aliases)?;
114                observer.child(column_types)?;
115            }
116            Self::FunctionGroup {
117                functions,
118                alias,
119                column_aliases,
120                ordinality: _,
121            } => {
122                observer.child(functions)?;
123                observer.child(alias)?;
124                observer.child(column_aliases)?;
125            }
126            Self::Subquery {
127                captured_output,
128                lateral: _,
129                body,
130                alias,
131                column_aliases,
132            } => {
133                observer.child(captured_output)?;
134                observer.child(body)?;
135                observer.child(alias)?;
136                observer.child(column_aliases)?;
137            }
138        }
139        Ok(())
140    }
141}