1mod 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 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
179pub 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 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 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 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 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}