Skip to main content

nz_rust/
metadata.rs

1// Copyright 2026 Krzysztof Duśko.
2//
3// Licensed under the Apache License, Version 2.0 (the "License");
4// you may not use this file except in compliance with the License.
5// You may obtain a copy of the License at
6//
7//     http://www.apache.org/licenses/LICENSE-2.0
8//
9// Unless required by applicable law or agreed to in writing, software
10// distributed under the License is distributed on an "AS IS" BASIS,
11// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12// See the License for the specific language governing permissions and
13// limitations under the License.
14
15//! Netezza catalog helpers used by SQL clients and the editor.
16
17mod extended;
18mod native;
19pub use extended::{
20    NzDdlBatchResult, NzDetailedColumnInfo, NzGroupInfo, NzQueryHistoryInfo, NzSequenceInfo,
21    NzTableKeyInfo, NzUserInfo,
22};
23pub use native::{AsyncMetadata, CatalogSnapshot};
24
25use crate::connection::NzConnection;
26use crate::error::{NzError, NzResult};
27use crate::params::escape_literal;
28use crate::types::value::NzValue;
29
30#[derive(Debug, Clone, PartialEq)]
31pub struct NzTableInfo {
32    pub schema: String,
33    pub name: String,
34    pub owner: Option<String>,
35    pub object_type: Option<String>,
36    pub object_id: Option<i64>,
37    pub row_count: Option<i64>,
38}
39
40#[derive(Debug, Clone, PartialEq)]
41pub struct NzColumnInfo {
42    pub name: String,
43    pub ordinal: i32,
44    pub type_name: String,
45    pub nullable: bool,
46    pub object_id: Option<i64>,
47    pub description: Option<String>,
48    pub default_value: Option<String>,
49}
50
51#[derive(Debug, Clone, PartialEq)]
52pub struct NzDatabaseInfo {
53    pub name: String,
54    pub owner: Option<String>,
55    pub default_schema: Option<String>,
56}
57
58#[derive(Debug, Clone, PartialEq)]
59pub struct NzViewInfo {
60    pub schema: String,
61    pub name: String,
62    pub owner: Option<String>,
63    pub object_id: Option<i64>,
64    pub definition: Option<String>,
65}
66
67#[derive(Debug, Clone, PartialEq)]
68pub struct NzProcedureInfo {
69    pub schema: String,
70    pub name: String,
71    pub owner: Option<String>,
72    pub object_id: Option<i64>,
73    pub signature: Option<String>,
74    pub returns: Option<String>,
75    pub is_builtin: Option<bool>,
76    pub source: Option<String>,
77    pub executed_as_owner: Option<bool>,
78    pub arguments: Option<String>,
79    pub description: Option<String>,
80}
81
82#[derive(Debug, Clone, PartialEq)]
83pub struct NzTableSizeInfo {
84    pub schema: String,
85    pub table: String,
86    pub used_bytes: Option<i64>,
87    pub allocated_bytes: Option<i64>,
88    pub size_mb: Option<i64>,
89    pub skew: Option<f64>,
90}
91
92#[derive(Debug, Clone, PartialEq)]
93pub struct NzSessionInfo {
94    pub session_id: i64,
95    pub username: Option<String>,
96    pub database: Option<String>,
97    /// Kept as the driver's canonical server text because the crate does not
98    /// impose a chrono dependency on callers.
99    pub connect_time: Option<String>,
100    pub priority: Option<String>,
101    pub status: Option<String>,
102    pub client_type: Option<String>,
103    pub client_os_user: Option<String>,
104}
105
106#[derive(Debug, Clone, PartialEq)]
107pub struct NzFunctionInfo {
108    pub schema: String,
109    pub name: String,
110    pub owner: Option<String>,
111    pub object_id: Option<i64>,
112    pub signature: Option<String>,
113    pub returns: Option<String>,
114    pub language: Option<String>,
115    pub is_fluid: Option<bool>,
116}
117
118#[derive(Debug, Clone, PartialEq)]
119pub struct NzSynonymInfo {
120    pub schema: String,
121    pub name: String,
122    pub referenced_object: Option<String>,
123    pub referenced_database: Option<String>,
124    pub referenced_schema: Option<String>,
125    pub description: Option<String>,
126}
127
128#[derive(Debug, Clone, PartialEq)]
129pub struct NzConstraintInfo {
130    pub schema: String,
131    pub table: String,
132    pub name: String,
133    pub constraint_type: char,
134    pub column: String,
135    pub primary_key_database: Option<String>,
136    pub primary_key_schema: Option<String>,
137    pub primary_key_table: Option<String>,
138    pub primary_key_column: Option<String>,
139    pub update_type: Option<String>,
140    pub delete_type: Option<String>,
141}
142
143#[derive(Debug, Clone, PartialEq)]
144pub struct NzDistributionKeyInfo {
145    pub schema: String,
146    pub table: String,
147    pub column: String,
148    pub distribution_attribute: i32,
149}
150
151#[derive(Debug, Clone, PartialEq)]
152pub struct NzOrganizeKeyInfo {
153    pub schema: String,
154    pub table: String,
155    pub column: String,
156    pub attribute: i32,
157}
158
159#[derive(Debug, Clone, PartialEq)]
160pub struct NzObjectDetailInfo {
161    pub schema: String,
162    pub name: String,
163    pub object_type: String,
164    pub owner: Option<String>,
165    pub object_id: Option<i64>,
166    pub description: Option<String>,
167    pub created_date: Option<String>,
168}
169
170#[derive(Debug, Clone, PartialEq)]
171pub struct NzObjectInfo {
172    pub schema: String,
173    pub name: String,
174    pub object_type: String,
175    pub owner: Option<String>,
176    pub object_id: Option<i64>,
177}
178
179/// Catalog operations borrowing a connection for their duration.
180pub struct NzMetadata<'a> {
181    connection: &'a mut NzConnection,
182}
183
184impl<'a> NzMetadata<'a> {
185    pub(crate) fn new(connection: &'a mut NzConnection) -> Self {
186        Self { connection }
187    }
188
189    pub fn schemas(&mut self) -> NzResult<Vec<String>> {
190        let result = self
191            .connection
192            .query("SELECT schema FROM _v_schema ORDER BY schema", &[])?;
193        result.rows().iter().map(|r| r.try_get(0)).collect()
194    }
195
196    pub fn databases(&mut self) -> NzResult<Vec<NzDatabaseInfo>> {
197        let result = self.connection.query(
198            "SELECT database, owner, defschema FROM _v_database ORDER BY database",
199            &[],
200        )?;
201        result.rows().iter().map(database_from_row).collect()
202    }
203
204    pub fn tables(
205        &mut self,
206        schema: Option<&str>,
207        pattern: Option<&str>,
208    ) -> NzResult<Vec<NzTableInfo>> {
209        let sql = tables_sql(schema, pattern)?;
210        let result = self.connection.query(&sql, &[])?;
211        result.rows().iter().map(table_from_row).collect()
212    }
213
214    pub fn columns(&mut self, table: &str, schema: Option<&str>) -> NzResult<Vec<NzColumnInfo>> {
215        let sql = columns_sql(table, schema)?;
216        let result = self.connection.query(&sql, &[])?;
217        result.rows().iter().map(column_from_row).collect()
218    }
219
220    pub fn views(&mut self, schema: Option<&str>) -> NzResult<Vec<NzViewInfo>> {
221        let sql = views_sql(schema)?;
222        let result = self.connection.query(&sql, &[])?;
223        result.rows().iter().map(view_from_row).collect()
224    }
225
226    pub fn procedures(&mut self, schema: Option<&str>) -> NzResult<Vec<NzProcedureInfo>> {
227        let sql = procedures_sql(schema)?;
228        let result = self.connection.query(&sql, &[])?;
229        result.rows().iter().map(procedure_from_row).collect()
230    }
231
232    pub fn distribution_key(&mut self, table: &str, schema: Option<&str>) -> NzResult<Vec<String>> {
233        let mut sql = format!(
234            "SELECT attname FROM _v_table_dist_map WHERE tablename = {}",
235            literal(table)?,
236        );
237        if let Some(schema) = schema {
238            sql.push_str(" AND schema = ");
239            sql.push_str(&literal(schema)?);
240        }
241        sql.push_str(" ORDER BY distattnum");
242        let result = self.connection.query(&sql, &[])?;
243        result.rows().iter().map(|r| text(r, 0)).collect()
244    }
245
246    pub fn table_sizes(&mut self, schema: Option<&str>) -> NzResult<Vec<NzTableSizeInfo>> {
247        let mut sql = String::from(
248            "SELECT schema, tablename, used_bytes, allocated_bytes, (used_bytes / 1048576)::BIGINT AS size_mb, skew FROM _v_table_storage_stat WHERE tablename IS NOT NULL",
249        );
250        if let Some(schema) = schema {
251            sql.push_str(" AND schema = ");
252            sql.push_str(&literal(schema)?);
253        }
254        sql.push_str(" ORDER BY used_bytes DESC");
255        let result = self.connection.query(&sql, &[])?;
256        result.rows().iter().map(table_size_from_row).collect()
257    }
258
259    pub fn sessions(&mut self) -> NzResult<Vec<NzSessionInfo>> {
260        let result = self.connection.query(
261            "SELECT id, username, dbname, conntime, priority, status, type, client_os_username FROM _v_session ORDER BY conntime DESC",
262            &[],
263        )?;
264        result.rows().iter().map(session_from_row).collect()
265    }
266
267    pub fn functions(&mut self, schema: Option<&str>) -> NzResult<Vec<NzFunctionInfo>> {
268        let mut sql = String::from(
269            "SELECT schema, function, owner, objid, functionsignature, returns, env FROM _v_function WHERE function IS NOT NULL",
270        );
271        if let Some(schema) = schema {
272            sql.push_str(" AND schema = ");
273            sql.push_str(&literal(schema)?);
274        }
275        sql.push_str(" ORDER BY schema, function");
276        let result = self.connection.query(&sql, &[])?;
277        result.rows().iter().map(function_from_row).collect()
278    }
279
280    pub fn synonyms(&mut self, schema: Option<&str>) -> NzResult<Vec<NzSynonymInfo>> {
281        let mut sql = String::from(
282            "SELECT schema, synonym_name, refobjname, refdatabase, refschema, description FROM _v_synonym WHERE synonym_name IS NOT NULL",
283        );
284        if let Some(schema) = schema {
285            sql.push_str(" AND schema = ");
286            sql.push_str(&literal(schema)?);
287        }
288        sql.push_str(" ORDER BY schema, synonym_name");
289        let result = self.connection.query(&sql, &[])?;
290        result.rows().iter().map(synonym_from_row).collect()
291    }
292
293    pub fn constraints(&mut self, schema: Option<&str>) -> NzResult<Vec<NzConstraintInfo>> {
294        let mut sql = String::from(
295            "SELECT schema, relation, constraintname, contype, attname, pkdatabase, pkschema, pkrelation, pkattname, updt_type, del_type FROM _v_relation_keydata WHERE relation IS NOT NULL",
296        );
297        if let Some(schema) = schema {
298            sql.push_str(" AND schema = ");
299            sql.push_str(&literal(schema)?);
300        }
301        sql.push_str(" ORDER BY schema, relation, conseq");
302        let result = self.connection.query(&sql, &[])?;
303        result.rows().iter().map(constraint_from_row).collect()
304    }
305
306    pub fn all_distribution_keys(
307        &mut self,
308        schema: Option<&str>,
309    ) -> NzResult<Vec<NzDistributionKeyInfo>> {
310        let mut sql = String::from(
311            "SELECT schema, tablename, attname, distattnum FROM _v_table_dist_map WHERE tablename IS NOT NULL",
312        );
313        if let Some(schema) = schema {
314            sql.push_str(" AND schema = ");
315            sql.push_str(&literal(schema)?);
316        }
317        sql.push_str(" ORDER BY schema, tablename, distseqno");
318        let result = self.connection.query(&sql, &[])?;
319        result.rows().iter().map(distribution_from_row).collect()
320    }
321
322    pub fn organize_keys(&mut self, schema: Option<&str>) -> NzResult<Vec<NzOrganizeKeyInfo>> {
323        let mut sql = String::from(
324            "SELECT schema, tablename, attname, attnum FROM _v_table_organize_column WHERE tablename IS NOT NULL",
325        );
326        if let Some(schema) = schema {
327            sql.push_str(" AND schema = ");
328            sql.push_str(&literal(schema)?);
329        }
330        sql.push_str(" ORDER BY schema, tablename, orgseqno");
331        let result = self.connection.query(&sql, &[])?;
332        result.rows().iter().map(organize_from_row).collect()
333    }
334
335    pub fn object_details(&mut self, schema: Option<&str>) -> NzResult<Vec<NzObjectDetailInfo>> {
336        let mut sql = String::from(
337            "SELECT schema, objname, objtype, owner, objid, description, createdate FROM _v_object_data WHERE objname IS NOT NULL",
338        );
339        if let Some(schema) = schema {
340            sql.push_str(" AND schema = ");
341            sql.push_str(&literal(schema)?);
342        }
343        sql.push_str(" AND objtype NOT IN ('AGGREGATE','CONSTRAINT','DATABASE','DATATYPE','GROUP','MANAGEMENT INDEX','MANAGEMENT SEQ','MANAGEMENT TABLE','MANAGEMENT VIEW','SCHEDULER RULE','SCHEMA','SYSTEM INDEX','SYSTEM SEQ','SYSTEM TABLE','SYSTEM VIEW','USER') ORDER BY schema, objtype, objname");
344        let result = self.connection.query(&sql, &[])?;
345        result.rows().iter().map(object_detail_from_row).collect()
346    }
347
348    pub fn search_objects_detailed(
349        &mut self,
350        pattern: &str,
351        schema: Option<&str>,
352    ) -> NzResult<Vec<NzObjectDetailInfo>> {
353        let mut sql = format!(
354            "SELECT schema, objname, objtype, owner, objid, description, createdate FROM _v_object_data WHERE UPPER(objname) LIKE UPPER({})",
355            like_contains_literal(pattern)?,
356        );
357        if let Some(schema) = schema {
358            sql.push_str(" AND schema = ");
359            sql.push_str(&literal(schema)?);
360        }
361        sql.push_str(" AND objtype NOT IN ('AGGREGATE','CONSTRAINT','DATABASE','DATATYPE','GROUP','MANAGEMENT INDEX','MANAGEMENT SEQ','MANAGEMENT TABLE','MANAGEMENT VIEW','SCHEDULER RULE','SCHEMA','SYSTEM INDEX','SYSTEM SEQ','SYSTEM TABLE','SYSTEM VIEW','USER') ORDER BY schema, objtype, objname");
362        let result = self.connection.query(&sql, &[])?;
363        let folded_pattern = pattern.to_ascii_lowercase();
364        result
365            .rows()
366            .iter()
367            .map(object_detail_from_row)
368            .filter(|detail| {
369                detail
370                    .as_ref()
371                    .map(|detail| detail.name.to_ascii_lowercase().contains(&folded_pattern))
372                    .unwrap_or(true)
373            })
374            .collect()
375    }
376
377    pub fn objects(&mut self, pattern: &str, schema: Option<&str>) -> NzResult<Vec<NzObjectInfo>> {
378        let like = format!("%{pattern}%");
379        let folded_pattern = pattern.to_ascii_lowercase();
380        // Match the C# `SearchObjectsAsync` surface: tables use the catalog
381        // LIKE predicate, while views and procedures are filtered in memory
382        // with ordinal case-insensitive matching. This intentionally excludes
383        // functions/synonyms; callers needing every catalog object can use
384        // `search_objects_detailed`.
385        let mut objects = Vec::new();
386        for table in self.tables(schema, Some(&like))? {
387            objects.push(NzObjectInfo {
388                schema: table.schema,
389                name: table.name,
390                object_type: "TABLE".into(),
391                owner: table.owner,
392                object_id: table.object_id,
393            });
394        }
395        for view in self.views(schema)? {
396            if view.name.to_ascii_lowercase().contains(&folded_pattern) {
397                objects.push(NzObjectInfo {
398                    schema: view.schema,
399                    name: view.name,
400                    object_type: "VIEW".into(),
401                    owner: view.owner,
402                    object_id: view.object_id,
403                });
404            }
405        }
406        for procedure in self.procedures(schema)? {
407            if procedure
408                .name
409                .to_ascii_lowercase()
410                .contains(&folded_pattern)
411            {
412                objects.push(NzObjectInfo {
413                    schema: procedure.schema,
414                    name: procedure.name,
415                    object_type: "PROCEDURE".into(),
416                    owner: procedure.owner,
417                    object_id: procedure.object_id,
418                });
419            }
420        }
421        Ok(objects)
422    }
423}
424
425impl NzConnection {
426    /// Borrow this connection for catalog/metadata queries.
427    pub fn metadata(&mut self) -> NzMetadata<'_> {
428        NzMetadata::new(self)
429    }
430}
431
432fn text(row: &crate::connection::Row, ix: usize) -> NzResult<String> {
433    row.try_get(ix)
434}
435
436fn literal(value: &str) -> NzResult<String> {
437    escape_literal(&NzValue::Text(value.into())).map_err(NzError::Config)
438}
439
440fn like_contains_literal(value: &str) -> NzResult<String> {
441    // Netezza accepts LIKE but rejects PostgreSQL's optional ESCAPE clause on
442    // some appliance versions. Use a SQL-safe superset and let the caller
443    // apply the exact case-insensitive literal match after decoding rows.
444    literal(&format!("%{value}%"))
445}
446
447fn optional_text(row: &crate::connection::Row, ix: usize) -> NzResult<Option<String>> {
448    match row.try_get_value(ix)? {
449        NzValue::Null => Ok(None),
450        value => Ok(Some(value.to_display_string())),
451    }
452}
453
454fn optional_i64(row: &crate::connection::Row, ix: usize) -> NzResult<Option<i64>> {
455    row.try_get(ix)
456}
457
458fn table_from_row(row: &crate::connection::Row) -> NzResult<NzTableInfo> {
459    Ok(NzTableInfo {
460        schema: text(row, 0)?,
461        name: text(row, 1)?,
462        owner: optional_text(row, 2)?,
463        object_type: optional_text(row, 3)?,
464        object_id: optional_i64(row, 4)?,
465        row_count: optional_i64(row, 5)?,
466    })
467}
468
469fn column_from_row(row: &crate::connection::Row) -> NzResult<NzColumnInfo> {
470    Ok(NzColumnInfo {
471        name: text(row, 0)?,
472        ordinal: row.try_get(1)?,
473        type_name: text(row, 2)?,
474        nullable: text(row, 3)? == "Y",
475        object_id: optional_i64(row, 4)?,
476        description: optional_text(row, 5)?,
477        // Netezza versions differ on whether `_v_relation_column` exposes a
478        // default column; keep the stable C# API shape and leave it absent
479        // until a version-specific query is selected.
480        default_value: None,
481    })
482}
483
484fn database_from_row(row: &crate::connection::Row) -> NzResult<NzDatabaseInfo> {
485    Ok(NzDatabaseInfo {
486        name: text(row, 0)?,
487        owner: optional_text(row, 1)?,
488        default_schema: optional_text(row, 2)?,
489    })
490}
491
492fn view_from_row(row: &crate::connection::Row) -> NzResult<NzViewInfo> {
493    Ok(NzViewInfo {
494        schema: text(row, 0)?,
495        name: text(row, 1)?,
496        owner: optional_text(row, 2)?,
497        object_id: optional_i64(row, 3)?,
498        definition: optional_text(row, 4)?,
499    })
500}
501
502fn procedure_from_row(row: &crate::connection::Row) -> NzResult<NzProcedureInfo> {
503    Ok(NzProcedureInfo {
504        schema: text(row, 0)?,
505        name: text(row, 1)?,
506        owner: optional_text(row, 2)?,
507        object_id: optional_i64(row, 3)?,
508        signature: optional_text(row, 4)?,
509        returns: optional_text(row, 5)?,
510        is_builtin: optional_bool(row, 6)?,
511        source: optional_text(row, 7)?,
512        executed_as_owner: optional_bool(row, 8)?,
513        arguments: optional_text(row, 9)?,
514        description: optional_text(row, 10)?,
515    })
516}
517
518fn table_size_from_row(row: &crate::connection::Row) -> NzResult<NzTableSizeInfo> {
519    Ok(NzTableSizeInfo {
520        schema: text(row, 0)?,
521        table: text(row, 1)?,
522        used_bytes: optional_i64(row, 2)?,
523        allocated_bytes: optional_i64(row, 3)?,
524        size_mb: optional_i64(row, 4)?,
525        skew: row.try_get(5)?,
526    })
527}
528
529fn session_from_row(row: &crate::connection::Row) -> NzResult<NzSessionInfo> {
530    Ok(NzSessionInfo {
531        session_id: row.try_get(0)?,
532        username: optional_text(row, 1)?,
533        database: optional_text(row, 2)?,
534        connect_time: optional_text(row, 3)?,
535        priority: optional_text(row, 4)?,
536        status: optional_text(row, 5)?,
537        client_type: optional_text(row, 6)?,
538        client_os_user: optional_text(row, 7)?,
539    })
540}
541
542fn function_from_row(row: &crate::connection::Row) -> NzResult<NzFunctionInfo> {
543    let env = optional_text(row, 6)?;
544    Ok(NzFunctionInfo {
545        schema: text(row, 0)?,
546        name: text(row, 1)?,
547        owner: optional_text(row, 2)?,
548        object_id: optional_i64(row, 3)?,
549        signature: optional_text(row, 4)?,
550        returns: optional_text(row, 5)?,
551        is_fluid: env.as_deref().map(|v| {
552            v.to_ascii_lowercase()
553                .contains("com.ibm.nz.fq.sqlreadlauncher")
554        }),
555        language: env,
556    })
557}
558
559fn synonym_from_row(row: &crate::connection::Row) -> NzResult<NzSynonymInfo> {
560    Ok(NzSynonymInfo {
561        schema: text(row, 0)?,
562        name: text(row, 1)?,
563        referenced_object: optional_text(row, 2)?,
564        referenced_database: optional_text(row, 3)?,
565        referenced_schema: optional_text(row, 4)?,
566        description: optional_text(row, 5)?,
567    })
568}
569
570fn constraint_from_row(row: &crate::connection::Row) -> NzResult<NzConstraintInfo> {
571    let kind = text(row, 3)?.chars().next().unwrap_or('\0');
572    Ok(NzConstraintInfo {
573        schema: text(row, 0)?,
574        table: text(row, 1)?,
575        name: text(row, 2)?,
576        constraint_type: kind,
577        column: optional_text(row, 4)?.unwrap_or_default(),
578        primary_key_database: optional_text(row, 5)?,
579        primary_key_schema: optional_text(row, 6)?,
580        primary_key_table: optional_text(row, 7)?,
581        primary_key_column: optional_text(row, 8)?,
582        update_type: optional_text(row, 9)?,
583        delete_type: optional_text(row, 10)?,
584    })
585}
586
587fn distribution_from_row(row: &crate::connection::Row) -> NzResult<NzDistributionKeyInfo> {
588    Ok(NzDistributionKeyInfo {
589        schema: text(row, 0)?,
590        table: text(row, 1)?,
591        column: text(row, 2)?,
592        distribution_attribute: row.try_get(3)?,
593    })
594}
595
596fn organize_from_row(row: &crate::connection::Row) -> NzResult<NzOrganizeKeyInfo> {
597    Ok(NzOrganizeKeyInfo {
598        schema: text(row, 0)?,
599        table: text(row, 1)?,
600        column: text(row, 2)?,
601        attribute: row.try_get(3)?,
602    })
603}
604
605fn object_detail_from_row(row: &crate::connection::Row) -> NzResult<NzObjectDetailInfo> {
606    Ok(NzObjectDetailInfo {
607        schema: optional_text(row, 0)?.unwrap_or_else(|| "ADMIN".into()),
608        name: text(row, 1)?,
609        object_type: text(row, 2)?,
610        owner: optional_text(row, 3)?,
611        object_id: optional_i64(row, 4)?,
612        description: optional_text(row, 5)?,
613        created_date: optional_text(row, 6)?,
614    })
615}
616
617fn optional_bool(row: &crate::connection::Row, ix: usize) -> NzResult<Option<bool>> {
618    match row.try_get_value(ix)? {
619        NzValue::Null => Ok(None),
620        NzValue::Bool(v) => Ok(Some(*v)),
621        NzValue::Text(v) => Ok(Some(matches!(
622            v.trim().to_ascii_lowercase().as_str(),
623            "t" | "true" | "1" | "y"
624        ))),
625        NzValue::Int2(v) => Ok(Some(*v != 0)),
626        NzValue::Int4(v) => Ok(Some(*v != 0)),
627        NzValue::Int8(v) => Ok(Some(*v != 0)),
628        NzValue::Decimal(v) => Ok(Some(!v.is_zero())),
629        other => Err(NzError::Config(format!(
630            "expected boolean metadata value, got {other:?}"
631        ))),
632    }
633}
634
635fn tables_sql(schema: Option<&str>, pattern: Option<&str>) -> NzResult<String> {
636    let mut sql = String::from(
637            "SELECT schema, tablename, owner, objtype, objid, reltuples FROM _v_table WHERE tablename IS NOT NULL",
638        );
639    if let Some(schema) = schema {
640        sql.push_str(" AND schema = ");
641        sql.push_str(&escape_literal(&NzValue::Text(schema.into())).map_err(NzError::Config)?);
642    }
643    if let Some(pattern) = pattern {
644        sql.push_str(" AND tablename LIKE ");
645        sql.push_str(&escape_literal(&NzValue::Text(pattern.into())).map_err(NzError::Config)?);
646    }
647    sql.push_str(" AND schema NOT IN ('DEFINITION_SCHEMA', 'INZA', 'NZ_QUERY_HISTORY') AND objtype <> 'SYSTEM_TABLE' ORDER BY schema, tablename");
648    Ok(sql)
649}
650
651fn columns_sql(table: &str, schema: Option<&str>) -> NzResult<String> {
652    let mut sql = format!(
653            "SELECT attname, attnum, format_type, CASE WHEN attnotnull THEN 'N' ELSE 'Y' END, objid, description FROM _v_relation_column WHERE name = {}",
654            escape_literal(&NzValue::Text(table.into())).map_err(NzError::Config)?
655        );
656    if let Some(schema) = schema {
657        sql.push_str(" AND schema = ");
658        sql.push_str(&escape_literal(&NzValue::Text(schema.into())).map_err(NzError::Config)?);
659    }
660    sql.push_str(" ORDER BY attnum");
661    Ok(sql)
662}
663
664fn views_sql(schema: Option<&str>) -> NzResult<String> {
665    let mut sql = String::from(
666        "SELECT schema, viewname, owner, objid, definition FROM _v_view WHERE viewname IS NOT NULL",
667    );
668    if let Some(schema) = schema {
669        sql.push_str(" AND schema = ");
670        sql.push_str(&escape_literal(&NzValue::Text(schema.into())).map_err(NzError::Config)?);
671    }
672    sql.push_str(" ORDER BY schema, viewname");
673    Ok(sql)
674}
675
676fn procedures_sql(schema: Option<&str>) -> NzResult<String> {
677    let mut sql = String::from(
678            "SELECT schema, procedure, owner, objid, proceduresignature, returns, builtin, proceduresource, executedasowner, arguments, description FROM _v_procedure WHERE procedure IS NOT NULL",
679        );
680    if let Some(schema) = schema {
681        sql.push_str(" AND schema = ");
682        sql.push_str(&escape_literal(&NzValue::Text(schema.into())).map_err(NzError::Config)?);
683    }
684    sql.push_str(" ORDER BY schema, procedure");
685    Ok(sql)
686}