Skip to main content

uqa_sql/compiler/
types.rs

1//
2// Unified Query Algebra
3//
4// Copyright (c) 2023-2026 Cognica, Inc.
5//
6
7//! Column type and foreign-key constraint lowering helpers.
8
9use std::collections::HashMap;
10use std::sync::{LazyLock, RwLock};
11
12use pg_query::protobuf::Node;
13use pg_query::NodeEnum;
14
15use crate::ast::{ColumnType, IntervalFields, RangeSubtype};
16use crate::error::{Result, SQLError};
17use uqa_core::memory::{Produced, ProductionControl, ProductionVec};
18
19use super::tree::extract_string;
20
21mod declarations;
22mod object_names;
23mod routine_names;
24pub(crate) use declarations::compile_retained_type_declaration;
25pub(crate) use declarations::compile_retained_type_reference;
26pub(super) use declarations::preserve_alter_type_declaration;
27pub use object_names::parse_regobject_name;
28pub use object_names::parse_regobject_name_with_control;
29pub use routine_names::parse_regprocedure_name_with_control;
30
31/// Parser-normalized type identity used by `PostgreSQL`'s `regtype` and `regprocedure` input functions. Components retain the parser's distinction between aliases such as unquoted `integer` (normalized to `pg_catalog.int4`) and a quoted type named `"integer"`. Modifier values do not participate in OID lookup; their presence is retained for declaration validation.
32#[derive(Debug, Clone, PartialEq, Eq)]
33pub struct ParsedRegtypeName {
34    pub names: Vec<String>,
35    pub array_dimensions: usize,
36    pub has_type_modifiers: bool,
37}
38
39/// Parser-normalized routine name and optional exact input-type signature used by `PostgreSQL`'s `regproc` and `regprocedure` input functions.
40#[derive(Debug, Clone, PartialEq, Eq)]
41pub struct ParsedRegprocedureName {
42    pub names: Vec<String>,
43    pub argument_types: Option<Vec<ParsedRegtypeName>>,
44}
45
46const POSTGRES_FUNCTION_MAX_ARGUMENTS: usize = 100;
47
48fn scanner_isspace(byte: u8) -> bool {
49    matches!(byte, b' ' | b'\t' | b'\n' | b'\r' | 0x0b | 0x0c)
50}
51
52/// A parsed type name is a function of its spelling alone, so each distinct spelling is parsed once per process. Reaching the bound discards the retained spellings instead of growing.
53static PARSED_TYPE_NAMES: LazyLock<RwLock<HashMap<Box<str>, Option<ParsedRegtypeName>>>> =
54    LazyLock::new(|| RwLock::new(HashMap::new()));
55const RETAINED_TYPE_NAMES: usize = 4096;
56
57/// Parse exactly one `PostgreSQL` type-name string without accepting adjacent SQL expressions. `None` is the soft-failure shape used for inputs such as an empty string or `SETOF integer`; lexical and type-name syntax errors are retained for the caller.
58pub fn parse_regtype_name(input: &str) -> Result<Option<ParsedRegtypeName>> {
59    let retained = PARSED_TYPE_NAMES
60        .read()
61        .ok()
62        .and_then(|names| names.get(input).cloned());
63    if let Some(parsed) = retained {
64        return Ok(parsed);
65    }
66    let parsed = parse_regtype_name_text(input)?;
67    if let Ok(mut names) = PARSED_TYPE_NAMES.write() {
68        if names.len() >= RETAINED_TYPE_NAMES {
69            names.clear();
70        }
71        names.insert(input.into(), parsed.clone());
72    }
73    Ok(parsed)
74}
75
76fn parse_regtype_name_text(input: &str) -> Result<Option<ParsedRegtypeName>> {
77    parse_regtype_name_text_with_control(input, &ProductionControl::uncontrolled()).map(|parsed| {
78        parsed.map(|parsed| {
79            parsed
80                .into_uncontrolled()
81                .expect("ordinary type-name parsing")
82        })
83    })
84}
85
86/// Copy a previously parsed name or project a parser-owned result into admitted SQL metadata. The process cache keeps its existing independent ownership; a new request-owned projection is not retained in that global cache.
87pub fn parse_regtype_name_with_control(
88    input: &str,
89    control: &ProductionControl<'_>,
90) -> Result<Option<Produced<ParsedRegtypeName>>> {
91    control.check()?;
92    if let Ok(names) = PARSED_TYPE_NAMES.read() {
93        if let Some(parsed) = names.get(input) {
94            return parsed
95                .as_ref()
96                .map(|parsed| {
97                    let mut names = ProductionVec::new(*control);
98                    names.reserve(parsed.names.len())?;
99                    for name in &parsed.names {
100                        names.push_produced(control.copy_text(name)?)?;
101                    }
102                    let (names, memory) = names.finish()?.into_parts();
103                    Ok(control.finish(
104                        ParsedRegtypeName {
105                            names,
106                            array_dimensions: parsed.array_dimensions,
107                            has_type_modifiers: parsed.has_type_modifiers,
108                        },
109                        memory,
110                    )?)
111                })
112                .transpose();
113        }
114    }
115    parse_regtype_name_text_with_control(input, control)
116}
117
118fn parse_regtype_name_text_with_control(
119    input: &str,
120    control: &ProductionControl<'_>,
121) -> Result<Option<Produced<ParsedRegtypeName>>> {
122    control.check()?;
123    if input.bytes().all(scanner_isspace) {
124        return Ok(None);
125    }
126    let parsed = crate::parser::parse_with_mode(input, pg_query::ParseMode::TypeName)?;
127    let [raw] = parsed.protobuf.stmts.as_slice() else {
128        return Ok(None);
129    };
130    let Some(NodeEnum::List(names)) = raw.stmt.as_ref().and_then(|node| node.node.as_ref()) else {
131        return Ok(None);
132    };
133    let mut projected_names = ProductionVec::new(*control);
134    projected_names.reserve(names.items.len())?;
135    for name in &names.items {
136        let Some(NodeEnum::String(name)) = name.node.as_ref() else {
137            return Err(SQLError::Internal("expected type-name string node".into()));
138        };
139        projected_names.push_produced(control.copy_text(&name.sval)?)?;
140    }
141    if projected_names.is_empty() {
142        return Ok(None);
143    }
144    let scanned = crate::parser::scan(input)?;
145    let mut bracket_dimensions = 0;
146    let mut array = false;
147    let mut has_type_modifiers = false;
148    for token in &scanned.tokens {
149        control.check()?;
150        match pg_query::protobuf::Token::try_from(token.token).ok() {
151            Some(pg_query::protobuf::Token::Setof) => return Ok(None),
152            Some(pg_query::protobuf::Token::Ascii91) => bracket_dimensions += 1,
153            Some(pg_query::protobuf::Token::Array) => array = true,
154            Some(pg_query::protobuf::Token::Ascii40) => has_type_modifiers = true,
155            _ => {}
156        }
157    }
158    let array_dimensions = bracket_dimensions.max(usize::from(array));
159    let (names, memory) = projected_names.finish()?.into_parts();
160    Ok(Some(control.finish(
161        ParsedRegtypeName {
162            names,
163            array_dimensions,
164            has_type_modifiers,
165        },
166        memory,
167    )?))
168}
169
170/// Parse one routine-name string with either an omitted signature (`regproc`) or an exact signature (`regprocedure`). The caller owns the soft-error and cross-database policy because the two SQL input functions intentionally differ from ordinary DDL.
171pub fn parse_regprocedure_name(input: &str) -> Result<Option<ParsedRegprocedureName>> {
172    parse_regprocedure_name_with_control(input, &ProductionControl::uncontrolled()).map(|parsed| {
173        parsed.map(|parsed| {
174            parsed
175                .into_uncontrolled()
176                .expect("ordinary routine identity parsing")
177        })
178    })
179}
180
181pub(super) fn compile_foreign_key_action(raw: &str) -> Result<crate::ast::ForeignKeyAction> {
182    use crate::ast::ForeignKeyAction;
183    match raw.as_bytes().first().copied() {
184        None | Some(0) | Some(b'a') => Ok(ForeignKeyAction::NoAction),
185        Some(b'r') => Ok(ForeignKeyAction::Restrict),
186        Some(b'c') => Ok(ForeignKeyAction::Cascade),
187        Some(b'n') => Ok(ForeignKeyAction::SetNull),
188        Some(b'd') => Ok(ForeignKeyAction::SetDefault),
189        Some(other) => Err(SQLError::Unsupported(format!(
190            "unsupported FOREIGN KEY action byte {other:?}"
191        ))),
192    }
193}
194
195pub(super) fn compile_foreign_key_match(raw: &str) -> Result<crate::ast::ForeignKeyMatch> {
196    use crate::ast::ForeignKeyMatch;
197    match raw.as_bytes().first().copied() {
198        None | Some(0) | Some(b's') => Ok(ForeignKeyMatch::Simple),
199        Some(b'f') => Ok(ForeignKeyMatch::Full),
200        Some(b'p') => Err(SQLError::Unsupported(
201            "FOREIGN KEY MATCH PARTIAL is not implemented by PostgreSQL".into(),
202        )),
203        Some(other) => Err(SQLError::Unsupported(format!(
204            "unsupported FOREIGN KEY match byte {other:?}"
205        ))),
206    }
207}
208
209pub(super) fn validate_foreign_key_set_columns(
210    local_columns: &[String],
211    set_columns: &[String],
212    raw_delete_action: &str,
213) -> Result<()> {
214    if set_columns.is_empty() {
215        return Ok(());
216    }
217    let action = compile_foreign_key_action(raw_delete_action)?;
218    if !matches!(
219        action,
220        crate::ast::ForeignKeyAction::SetNull | crate::ast::ForeignKeyAction::SetDefault
221    ) {
222        return Err(SQLError::Unsupported(
223            "FOREIGN KEY column lists are only valid for ON DELETE SET NULL/DEFAULT".into(),
224        ));
225    }
226    for col in set_columns {
227        if !local_columns.iter().any(|local| local == col) {
228            return Err(SQLError::Unsupported(format!(
229                "FOREIGN KEY SET column `{col}` is not part of the local key"
230            )));
231        }
232    }
233    Ok(())
234}
235
236pub(super) fn raw_type_name(col: &pg_query::protobuf::ColumnDef) -> Result<Option<String>> {
237    let Some(type_name) = col.type_name.as_ref() else {
238        return Ok(None);
239    };
240    let names = type_name
241        .names
242        .iter()
243        .map(extract_string)
244        .collect::<Result<Vec<_>>>()?;
245    Ok(names.last().map(|name| name.to_lowercase()))
246}
247
248pub(super) fn compile_type_name(col: &pg_query::protobuf::ColumnDef) -> Result<ColumnType> {
249    let Some(type_name) = col.type_name.as_ref() else {
250        return Err(SQLError::Internal(format!(
251            "column `{}` has no type",
252            col.colname
253        )));
254    };
255    compile_pg_type_name(type_name, &col.colname)
256}
257
258#[expect(
259    clippy::too_many_lines,
260    reason = "ordered PostgreSQL lowering preserves syntax and error precedence"
261)]
262pub(super) fn compile_pg_type_name(
263    type_name: &pg_query::protobuf::TypeName,
264    column_name: &str,
265) -> Result<ColumnType> {
266    let names = type_name
267        .names
268        .iter()
269        .map(extract_string)
270        .collect::<Result<Vec<_>>>()?;
271    let raw = names
272        .last()
273        .ok_or_else(|| {
274            SQLError::Internal(format!(
275                "type name for `{column_name}` has no name components"
276            ))
277        })?
278        .to_lowercase();
279    let bind_named = names
280        .first()
281        .is_some_and(|schema| names.len() > 1 && schema != "pg_catalog")
282        || names.last().is_some_and(|name| *name != raw)
283        || matches!(raw.as_str(), "integer" | "smallint" | "bigint" | "boolean");
284    let base = if bind_named {
285        compile_named_type(&names, type_name)
286    } else {
287        match raw.as_str() {
288            "smallint" | "int2" | "smallserial" | "serial2" => Ok(ColumnType::SmallInteger),
289            "int" | "int4" | "integer" | "serial" | "serial4" => Ok(ColumnType::Integer),
290            "bigint" | "int8" | "bigserial" | "serial8" => Ok(ColumnType::BigInteger),
291            "oid" => Ok(ColumnType::Oid),
292            "xid" => Ok(ColumnType::Xid),
293            "void" => Ok(ColumnType::Void),
294            "text" => Ok(ColumnType::Text),
295            "refcursor" => Ok(ColumnType::RefCursor),
296            "name" => Ok(ColumnType::Name),
297            "uuid" => Ok(ColumnType::Uuid),
298            "bit" | "varbit" => {
299                use crate::expr::bit_string::BitStringKind;
300                let kind = if raw == "bit" {
301                    BitStringKind::Fixed
302                } else {
303                    BitStringKind::Varying
304                };
305                if type_name.typmods.len() > 1 {
306                    return Err(SQLError::Routine {
307                        sqlstate: "22023".into(),
308                        message: "invalid type modifier".into(),
309                    });
310                }
311                let length = type_name
312                    .typmods
313                    .first()
314                    .map(|node| kind.validate_length(expect_integer_const(node)?))
315                    .transpose()?;
316                // The BIT keyword supplies length one in the parser; quoted/catalog bit retains the absent modifier.
317                Ok(if raw == "bit" {
318                    ColumnType::Bit(length)
319                } else {
320                    ColumnType::VarBit(length)
321                })
322            }
323            "varchar" | "character varying" => {
324                if type_name.typmods.len() > 1 {
325                    return Err(SQLError::TypeMismatch(format!(
326                        "CHARACTER VARYING accepts at most one length modifier, got {}",
327                        type_name.typmods.len()
328                    )));
329                }
330                let length = type_name
331                    .typmods
332                    .first()
333                    .map(|node| expect_positive_character_length(node, "varchar"))
334                    .transpose()?;
335                Ok(ColumnType::Varchar(length))
336            }
337            "char" => Ok(ColumnType::InternalChar),
338            "character" | "bpchar" => {
339                if type_name.typmods.len() > 1 {
340                    return Err(SQLError::TypeMismatch(format!(
341                        "CHARACTER accepts at most one length modifier, got {}",
342                        type_name.typmods.len()
343                    )));
344                }
345                let length = type_name
346                    .typmods
347                    .first()
348                    .map(|node| expect_positive_character_length(node, "bpchar"))
349                    .transpose()?;
350                // The parser supplies length one for CHAR/CHARACTER; the catalog name without a modifier is unconstrained.
351                Ok(match length {
352                    Some(length) => ColumnType::Character(length),
353                    None if raw == "bpchar" => ColumnType::Bpchar,
354                    None => ColumnType::Character(1),
355                })
356            }
357            "bool" | "boolean" => Ok(ColumnType::Boolean),
358            "real" | "float4" => Ok(ColumnType::Real),
359            "float8" | "double" | "double precision" => Ok(ColumnType::DoublePrecision),
360            "numeric" | "decimal" => {
361                if type_name.typmods.len() > 2 {
362                    return Err(SQLError::Routine {
363                        sqlstate: "22023".into(),
364                        message: "invalid NUMERIC type modifier".into(),
365                    });
366                }
367                let mut typmods_iter = type_name.typmods.iter();
368                let precision = typmods_iter
369                    .next()
370                    .map(|n| {
371                        let value = expect_integer_const(n)?;
372                        if !(1..=1000).contains(&value) {
373                            return Err(SQLError::Routine {
374                                sqlstate: "22023".into(),
375                                message: format!(
376                                    "NUMERIC precision {value} must be between 1 and 1000"
377                                ),
378                            });
379                        }
380                        Ok(value as u32)
381                    })
382                    .transpose()?;
383                let scale = typmods_iter
384                    .next()
385                    .map(|n| {
386                        let value = expect_integer_const(n)?;
387                        if !(-1000..=1000).contains(&value) {
388                            return Err(SQLError::Routine {
389                                sqlstate: "22023".into(),
390                                message: format!(
391                                    "NUMERIC scale {value} must be between -1000 and 1000"
392                                ),
393                            });
394                        }
395                        Ok(value as i32)
396                    })
397                    .transpose()?;
398                // PostgreSQL semantics: NUMERIC(precision) without an
399                // explicit scale defaults to scale=0, rounding to integers.
400                let scale = scale.or(precision.map(|_| 0));
401                Ok(ColumnType::Numeric { precision, scale })
402            }
403            "date" => Ok(ColumnType::Date),
404            "time" | "time without time zone" => Ok(ColumnType::Time),
405            "timetz" | "time with time zone" => Ok(ColumnType::TimeTz),
406            "timestamp" | "datetime" | "timestamp without time zone" => Ok(ColumnType::Timestamp),
407            "timestamptz" | "timestamp with time zone" => Ok(ColumnType::TimestampTz),
408            "interval" => {
409                let fields = type_name
410                    .typmods
411                    .first()
412                    .map(expect_integer_const)
413                    .transpose()?
414                    .unwrap_or(32767);
415                let fields = IntervalFields::from_modifier_mask(fields)
416                    .ok_or_else(|| SQLError::TypeMismatch("invalid interval fields".into()))?;
417                let precision = type_name
418                    .typmods
419                    .get(1)
420                    .map(expect_integer_const)
421                    .transpose()?;
422                ColumnType::with_interval_modifiers(fields, precision)
423            }
424            "int4range" => Ok(ColumnType::Range(RangeSubtype::Integer)),
425            "int8range" => Ok(ColumnType::Range(RangeSubtype::BigInteger)),
426            "numrange" => Ok(ColumnType::Range(RangeSubtype::Numeric)),
427            "daterange" => Ok(ColumnType::Range(RangeSubtype::Date)),
428            "tsrange" => Ok(ColumnType::Range(RangeSubtype::Timestamp)),
429            "tstzrange" => Ok(ColumnType::Range(RangeSubtype::TimestampTz)),
430            "int4multirange" => Ok(ColumnType::Multirange(RangeSubtype::Integer)),
431            "int8multirange" => Ok(ColumnType::Multirange(RangeSubtype::BigInteger)),
432            "nummultirange" => Ok(ColumnType::Multirange(RangeSubtype::Numeric)),
433            "datemultirange" => Ok(ColumnType::Multirange(RangeSubtype::Date)),
434            "tsmultirange" => Ok(ColumnType::Multirange(RangeSubtype::Timestamp)),
435            "tstzmultirange" => Ok(ColumnType::Multirange(RangeSubtype::TimestampTz)),
436            "json" => Ok(ColumnType::Json),
437            "jsonb" => Ok(ColumnType::JsonB),
438            "bytea" => Ok(ColumnType::Bytea),
439            "regproc" => Ok(ColumnType::Regproc),
440            "regprocedure" => Ok(ColumnType::Regprocedure),
441            "regclass" => Ok(ColumnType::Regclass),
442            "regcollation" => Ok(ColumnType::Regcollation),
443            "regnamespace" => Ok(ColumnType::Regnamespace),
444            "regrole" => Ok(ColumnType::Regrole),
445            "regtype" => Ok(ColumnType::Regtype),
446            "pg_node_tree" => Ok(ColumnType::PgNodeTree),
447            "aclitem" => Ok(ColumnType::AclItem),
448            "int2vector" => Ok(ColumnType::Int2Vector),
449            "oidvector" => Ok(ColumnType::OidVector),
450            "anyarray" => Ok(ColumnType::AnyArray),
451            "record" => Ok(ColumnType::Record),
452            "vector" => {
453                // VECTOR(N): the dimension is the only typmod argument.
454                let [arg] = type_name.typmods.as_slice() else {
455                    return Err(SQLError::Unsupported(
456                        "VECTOR requires exactly one dimension".into(),
457                    ));
458                };
459                let raw_dim = expect_integer_const(arg)?;
460                let dim = u32::try_from(raw_dim).map_err(|_| {
461                    SQLError::TypeMismatch(format!(
462                        "VECTOR dimension must be between 1 and {}, got {raw_dim}",
463                        u32::MAX
464                    ))
465                })?;
466                if dim == 0 {
467                    return Err(SQLError::TypeMismatch(
468                        "VECTOR dimension must be greater than zero".into(),
469                    ));
470                }
471                Ok(ColumnType::Vector(dim))
472            }
473            "tensor" => {
474                // TENSOR(N): an array of N-dimensional vectors.
475                let [arg] = type_name.typmods.as_slice() else {
476                    return Err(SQLError::Unsupported(
477                        "TENSOR requires exactly one dimension".into(),
478                    ));
479                };
480                let raw_dim = expect_integer_const(arg)?;
481                let dim = u32::try_from(raw_dim).map_err(|_| {
482                    SQLError::TypeMismatch(format!(
483                        "TENSOR dimension must be between 1 and {}, got {raw_dim}",
484                        u32::MAX
485                    ))
486                })?;
487                if dim == 0 {
488                    return Err(SQLError::TypeMismatch(
489                        "TENSOR dimension must be greater than zero".into(),
490                    ));
491                }
492                Ok(ColumnType::Tensor(dim))
493            }
494            _ => compile_named_type(&names, type_name),
495        }
496    }?;
497    let base = if matches!(
498        base,
499        ColumnType::Time | ColumnType::TimeTz | ColumnType::Timestamp | ColumnType::TimestampTz
500    ) {
501        if type_name.typmods.len() > 1 {
502            return Err(SQLError::TypeMismatch(
503                "invalid temporal type modifier".into(),
504            ));
505        }
506        base.with_temporal_precision(
507            type_name
508                .typmods
509                .first()
510                .map(expect_integer_const)
511                .transpose()?,
512        )?
513    } else {
514        base
515    };
516    if matches!(base, ColumnType::Void | ColumnType::PgNodeTree)
517        && !type_name.array_bounds.is_empty()
518    {
519        return Err(SQLError::Routine {
520            sqlstate: "42704".into(),
521            message: format!("type \"{}[]\" does not exist", base.sql_name()),
522        });
523    }
524    Ok(type_name
525        .array_bounds
526        .iter()
527        .fold(base, |element, _| ColumnType::Array(Box::new(element))))
528}
529
530/// Resolve a type reference without interpreting column-only serial pseudo-types.
531pub(super) fn compile_pg_type_reference(
532    type_name: &pg_query::protobuf::TypeName,
533    context: &str,
534) -> Result<ColumnType> {
535    let names = type_name
536        .names
537        .iter()
538        .map(extract_string)
539        .collect::<Result<Vec<_>>>()?;
540    if names.last().is_some_and(|name| {
541        matches!(
542            name.as_str(),
543            "serial" | "serial2" | "serial4" | "serial8" | "smallserial" | "bigserial"
544        )
545    }) {
546        let base = compile_named_type(&names, type_name)?;
547        return Ok(type_name
548            .array_bounds
549            .iter()
550            .fold(base, |element, _| ColumnType::Array(Box::new(element))));
551    }
552    compile_pg_type_name(type_name, context)
553}
554
555fn compile_named_type(
556    names: &[String],
557    type_name: &pg_query::protobuf::TypeName,
558) -> Result<ColumnType> {
559    let mut name = names
560        .iter()
561        .map(|name| format!("\"{}\"", name.replace('"', "\"\"")))
562        .collect::<Vec<_>>()
563        .join(".");
564    if !type_name.typmods.is_empty() {
565        let modifiers = type_name
566            .typmods
567            .iter()
568            .map(expect_integer_const)
569            .collect::<Result<Vec<_>>>()?;
570        name.push('(');
571        name.push_str(
572            &modifiers
573                .iter()
574                .map(ToString::to_string)
575                .collect::<Vec<_>>()
576                .join(","),
577        );
578        name.push(')');
579    }
580    Ok(ColumnType::Named(name))
581}
582
583fn expect_positive_character_length(node: &Node, type_name: &str) -> Result<u32> {
584    let length = expect_integer_const(node)?;
585    u32::try_from(length)
586        .ok()
587        .filter(|length| *length > 0)
588        .ok_or_else(|| SQLError::Routine {
589            sqlstate: "22023".into(),
590            message: format!("length for type {type_name} must be at least 1"),
591        })
592}
593
594fn expect_integer_const(node: &Node) -> Result<i64> {
595    let Some(inner) = node.node.as_ref() else {
596        return Err(SQLError::Internal("missing const node".into()));
597    };
598    match inner {
599        NodeEnum::AConst(c) => match &c.val {
600            Some(pg_query::protobuf::a_const::Val::Ival(i)) => Ok(i64::from(i.ival)),
601            Some(pg_query::protobuf::a_const::Val::Fval(f)) => {
602                f.fval.parse::<i64>().map_err(|_| {
603                    SQLError::TypeMismatch(format!(
604                        "type modifier must be an integer, got `{}`",
605                        f.fval
606                    ))
607                })
608            }
609            other => Err(SQLError::Internal(format!(
610                "expected integer constant, got {other:?}"
611            ))),
612        },
613        _ => Err(SQLError::Internal(format!(
614            "expected A_Const, got {inner:?}"
615        ))),
616    }
617}
618
619#[cfg(test)]
620mod tests;