use super::kinds::{field, Descriptor, Field, Kind, PLAIN};
impl Kind {
#[must_use]
pub const fn descriptor(self) -> &'static Descriptor {
match self {
Self::Database => &DATABASE,
Self::Table => &TABLE,
Self::Column => &COLUMN,
Self::ForeignKey => &FOREIGN_KEY,
Self::Index => &INDEX,
Self::Check => &CHECK,
Self::View => &VIEW,
Self::Routine => &ROUTINE,
Self::Trigger => &TRIGGER,
Self::Event => &EVENT,
Self::Sequence => &SEQUENCE,
Self::Partition => &PARTITION,
Self::Statistic => &STATISTIC,
Self::DatabaseSpace => &DATABASE_SPACE,
Self::ObjectSpace => &OBJECT_SPACE,
}
}
}
const REAL_TABLES: &str = "TABLE_TYPE IN ('BASE TABLE', 'SYSTEM VERSIONED')";
const fn comment_or_absent(expression: &'static str) -> Field {
field(expression, "comment")
}
const TABLE_COMMENT_OR_ABSENT: &str = "NULLIF(TABLE_COMMENT, '')";
const INDEX_COMMENT_OR_ABSENT: &str = "NULLIF(INDEX_COMMENT, '')";
const ROUTINE_COMMENT_OR_ABSENT: &str = "NULLIF(ROUTINE_COMMENT, '')";
const VIEW_COMMENT_OR_ABSENT: &str = "(SELECT NULLIF(NULLIF(t.TABLE_COMMENT, ''), 'VIEW') \
FROM information_schema.TABLES t \
WHERE t.TABLE_SCHEMA = information_schema.VIEWS.TABLE_SCHEMA \
AND t.TABLE_NAME = information_schema.VIEWS.TABLE_NAME)";
static DATABASE: Descriptor = Descriptor {
kind: Kind::Database,
source: "information_schema.SCHEMATA",
short: &[field("SCHEMA_NAME", "name")],
extra: &[
field("DEFAULT_CHARACTER_SET_NAME", "character_set"),
field("DEFAULT_COLLATION_NAME", "collation"),
],
database_column: Some("SCHEMA_NAME"),
name_column: "SCHEMA_NAME",
order_by: "SCHEMA_NAME",
..PLAIN
};
static TABLE: Descriptor = Descriptor {
kind: Kind::Table,
source: "information_schema.TABLES",
short: &[
field("TABLE_SCHEMA", "database"),
field("TABLE_NAME", "name"),
field("TABLE_TYPE", "type"),
],
extra: &[
field("TABLE_TYPE = 'SYSTEM VERSIONED'", "keeps_history"),
field("ENGINE", "engine"),
field("ROW_FORMAT", "row_format"),
field("TABLE_COLLATION", "collation"),
field("TABLE_ROWS", "estimated_rows"),
field("DATA_LENGTH", "data_bytes"),
field("INDEX_LENGTH", "index_bytes"),
field("AUTO_INCREMENT", "next_auto_value"),
comment_or_absent(TABLE_COMMENT_OR_ABSENT),
field("CREATE_TIME", "created_at"),
field("UPDATE_TIME", "updated_at"),
],
database_column: Some("TABLE_SCHEMA"),
table_column: Some("TABLE_NAME"),
name_column: "TABLE_NAME",
predicate: Some(REAL_TABLES),
order_by: "TABLE_SCHEMA, TABLE_NAME",
..PLAIN
};
static COLUMN: Descriptor = Descriptor {
kind: Kind::Column,
source: "information_schema.COLUMNS",
short: &[
field("TABLE_SCHEMA", "database"),
field("TABLE_NAME", "table"),
field("COLUMN_NAME", "name"),
field("ORDINAL_POSITION", "position"),
field("COLUMN_TYPE", "type"),
field("IS_NULLABLE = 'YES'", "nullable"),
field("COLUMN_DEFAULT", "default_value"),
field("COLUMN_KEY", "key"),
],
extra: &[
field("DATA_TYPE", "base_type"),
field("CHARACTER_SET_NAME", "character_set"),
field("COLLATION_NAME", "collation"),
field("GENERATION_EXPRESSION", "generated_from"),
field("EXTRA LIKE '%INVISIBLE%'", "invisible"),
field(SERVER_FILLED, "server_filled"),
field("IS_GENERATED = 'ALWAYS'", "derived"),
field("COLUMN_COMMENT", "comment"),
],
database_column: Some("TABLE_SCHEMA"),
table_column: Some("TABLE_NAME"),
name_column: "COLUMN_NAME",
order_by: "TABLE_SCHEMA, TABLE_NAME, ORDINAL_POSITION",
..PLAIN
};
const SERVER_FILLED: &str = "EXTRA LIKE '%auto_increment%' \
OR EXTRA LIKE '%DEFAULT_GENERATED%' OR EXTRA LIKE '%on update%'";
static FOREIGN_KEY: Descriptor = Descriptor {
kind: Kind::ForeignKey,
source: "information_schema.KEY_COLUMN_USAGE k \
JOIN information_schema.REFERENTIAL_CONSTRAINTS r \
ON r.CONSTRAINT_SCHEMA = k.CONSTRAINT_SCHEMA \
AND r.CONSTRAINT_NAME = k.CONSTRAINT_NAME \
AND r.TABLE_NAME = k.TABLE_NAME",
short: &[
field("k.CONSTRAINT_SCHEMA", "database"),
field("k.TABLE_NAME", "table"),
field("k.CONSTRAINT_NAME", "name"),
field("k.ORDINAL_POSITION", "position"),
field("k.COLUMN_NAME", "column"),
field("k.REFERENCED_TABLE_SCHEMA", "referenced_database"),
field("k.REFERENCED_TABLE_NAME", "referenced_table"),
field("k.REFERENCED_COLUMN_NAME", "referenced_column"),
field("r.UPDATE_RULE", "on_update"),
field("r.DELETE_RULE", "on_delete"),
],
extra: &[field("r.MATCH_OPTION", "match_option")],
database_column: Some("k.CONSTRAINT_SCHEMA"),
table_column: Some("k.TABLE_NAME"),
name_column: "k.CONSTRAINT_NAME",
predicate: Some("k.REFERENCED_TABLE_NAME IS NOT NULL"),
order_by: "k.CONSTRAINT_SCHEMA, k.TABLE_NAME, k.CONSTRAINT_NAME, k.ORDINAL_POSITION",
..PLAIN
};
static INDEX: Descriptor = Descriptor {
kind: Kind::Index,
source: "information_schema.STATISTICS",
short: &[
field("TABLE_SCHEMA", "database"),
field("TABLE_NAME", "table"),
field("INDEX_NAME", "name"),
field("SEQ_IN_INDEX", "position"),
field("COLUMN_NAME", "column"),
field("NON_UNIQUE = 0", "unique"),
field("INDEX_NAME = 'PRIMARY'", "primary"),
],
extra: &[
field("INDEX_TYPE", "method"),
field("CARDINALITY", "distinct_values"),
field("SUB_PART", "prefix_length"),
field("NULLABLE = 'YES'", "nullable"),
comment_or_absent(INDEX_COMMENT_OR_ABSENT),
],
database_column: Some("TABLE_SCHEMA"),
table_column: Some("TABLE_NAME"),
name_column: "INDEX_NAME",
order_by: "TABLE_SCHEMA, TABLE_NAME, INDEX_NAME, SEQ_IN_INDEX",
..PLAIN
};
static CHECK: Descriptor = Descriptor {
kind: Kind::Check,
source: "information_schema.CHECK_CONSTRAINTS",
short: &[
field("CONSTRAINT_SCHEMA", "database"),
field("TABLE_NAME", "table"),
field("CONSTRAINT_NAME", "name"),
field("CHECK_CLAUSE", "condition"),
],
extra: &[field("`LEVEL`", "level")],
database_column: Some("CONSTRAINT_SCHEMA"),
table_column: Some("TABLE_NAME"),
name_column: "CONSTRAINT_NAME",
order_by: "CONSTRAINT_SCHEMA, TABLE_NAME, CONSTRAINT_NAME",
..PLAIN
};
static VIEW: Descriptor = Descriptor {
kind: Kind::View,
source: "information_schema.VIEWS",
short: &[
field("TABLE_SCHEMA", "database"),
field("TABLE_NAME", "name"),
field("IS_UPDATABLE = 'YES'", "updatable"),
],
extra: &[
field("DEFINER", "definer"),
field("SECURITY_TYPE", "runs_as"),
field("CHECK_OPTION", "check_option"),
field("CHARACTER_SET_CLIENT", "character_set"),
field("COLLATION_CONNECTION", "collation"),
comment_or_absent(VIEW_COMMENT_OR_ABSENT),
field("VIEW_DEFINITION", "definition"),
],
database_column: Some("TABLE_SCHEMA"),
table_column: Some("TABLE_NAME"),
name_column: "TABLE_NAME",
order_by: "TABLE_SCHEMA, TABLE_NAME",
..PLAIN
};
static ROUTINE: Descriptor = Descriptor {
kind: Kind::Routine,
source: "information_schema.ROUTINES",
short: &[
field("ROUTINE_SCHEMA", "database"),
field("ROUTINE_NAME", "name"),
field("ROUTINE_TYPE", "type"),
field("DTD_IDENTIFIER", "returns"),
field(PARAMETER_LIST, "parameters"),
],
extra: &[
field("DEFINER", "definer"),
field("SECURITY_TYPE", "runs_as"),
field("IS_DETERMINISTIC = 'YES'", "deterministic"),
field("SQL_DATA_ACCESS", "data_access"),
comment_or_absent(ROUTINE_COMMENT_OR_ABSENT),
field("CREATED", "created_at"),
field("LAST_ALTERED", "updated_at"),
field("ROUTINE_DEFINITION", "body"),
],
database_column: Some("ROUTINE_SCHEMA"),
name_column: "ROUTINE_NAME",
order_by: "ROUTINE_SCHEMA, ROUTINE_NAME, ROUTINE_TYPE",
..PLAIN
};
const PARAMETER_LIST: &str = "(SELECT GROUP_CONCAT(\
CONCAT_WS(' ', p.PARAMETER_MODE, p.PARAMETER_NAME, p.DTD_IDENTIFIER) \
ORDER BY p.ORDINAL_POSITION SEPARATOR ', ') \
FROM information_schema.PARAMETERS p \
WHERE p.SPECIFIC_SCHEMA = information_schema.ROUTINES.ROUTINE_SCHEMA \
AND p.SPECIFIC_NAME = information_schema.ROUTINES.SPECIFIC_NAME \
AND p.ORDINAL_POSITION > 0)";
static TRIGGER: Descriptor = Descriptor {
kind: Kind::Trigger,
source: "information_schema.TRIGGERS",
short: &[
field("TRIGGER_SCHEMA", "database"),
field("TRIGGER_NAME", "name"),
field("ACTION_TIMING", "timing"),
field("EVENT_MANIPULATION", "event"),
field("EVENT_OBJECT_TABLE", "table"),
],
extra: &[
field("ACTION_ORIENTATION", "granularity"),
field("ACTION_ORDER", "order"),
field("DEFINER", "definer"),
field("CREATED", "created_at"),
field("ACTION_STATEMENT", "body"),
],
database_column: Some("TRIGGER_SCHEMA"),
table_column: Some("EVENT_OBJECT_TABLE"),
name_column: "TRIGGER_NAME",
order_by: "TRIGGER_SCHEMA, EVENT_OBJECT_TABLE, ACTION_TIMING, TRIGGER_NAME",
..PLAIN
};
static EVENT: Descriptor = Descriptor {
kind: Kind::Event,
source: "information_schema.EVENTS",
short: &[
field("EVENT_SCHEMA", "database"),
field("EVENT_NAME", "name"),
field("STATUS", "status"),
field("EVENT_TYPE", "type"),
field("EXECUTE_AT", "executes_at"),
field("CONCAT_WS(' ', INTERVAL_VALUE, INTERVAL_FIELD)", "every"),
field("LAST_EXECUTED", "last_executed"),
],
extra: &[
field("STARTS", "starts_at"),
field("ENDS", "ends_at"),
field("ON_COMPLETION", "on_completion"),
field("DEFINER", "definer"),
field("TIME_ZONE", "time_zone"),
field("EVENT_COMMENT", "comment"),
field("EVENT_DEFINITION", "body"),
],
database_column: Some("EVENT_SCHEMA"),
name_column: "EVENT_NAME",
order_by: "EVENT_SCHEMA, EVENT_NAME",
..PLAIN
};
static SEQUENCE: Descriptor = Descriptor {
kind: Kind::Sequence,
source: "information_schema.TABLES",
short: &[
field("TABLE_SCHEMA", "database"),
field("TABLE_NAME", "name"),
],
extra: &[
field("ENGINE", "engine"),
field("TABLE_COMMENT", "comment"),
field("CREATE_TIME", "created_at"),
],
database_column: Some("TABLE_SCHEMA"),
table_column: Some("TABLE_NAME"),
name_column: "TABLE_NAME",
predicate: Some("TABLE_TYPE = 'SEQUENCE'"),
order_by: "TABLE_SCHEMA, TABLE_NAME",
..PLAIN
};
static PARTITION: Descriptor = Descriptor {
kind: Kind::Partition,
source: "information_schema.PARTITIONS",
short: &[
field("TABLE_SCHEMA", "database"),
field("TABLE_NAME", "table"),
field("PARTITION_NAME", "name"),
field("SUBPARTITION_NAME", "subpartition"),
field("PARTITION_ORDINAL_POSITION", "position"),
field("PARTITION_METHOD", "method"),
field("PARTITION_EXPRESSION", "expression"),
field("PARTITION_DESCRIPTION", "criterion"),
field("TABLE_ROWS", "estimated_rows"),
field("DATA_LENGTH", "data_bytes"),
field("INDEX_LENGTH", "index_bytes"),
],
extra: &[
field("DATA_FREE", "free_bytes"),
field("PARTITION_COMMENT", "comment"),
],
database_column: Some("TABLE_SCHEMA"),
table_column: Some("TABLE_NAME"),
name_column: "PARTITION_NAME",
predicate: Some("PARTITION_NAME IS NOT NULL"),
order_by: "TABLE_SCHEMA, TABLE_NAME, PARTITION_ORDINAL_POSITION, SUBPARTITION_NAME",
..PLAIN
};
static STATISTIC: Descriptor = Descriptor {
kind: Kind::Statistic,
source: "information_schema.TABLES",
short: &[
field("TABLE_SCHEMA", "database"),
field("TABLE_NAME", "name"),
field("TABLE_ROWS", "estimated_rows"),
field("DATA_LENGTH", "data_bytes"),
field("INDEX_LENGTH", "index_bytes"),
],
extra: &[
field("ENGINE", "engine"),
field("AVG_ROW_LENGTH", "average_row_bytes"),
field("DATA_FREE", "free_bytes"),
field("AUTO_INCREMENT", "next_auto_value"),
field("CHECK_TIME", "checked_at"),
field("UPDATE_TIME", "updated_at"),
],
database_column: Some("TABLE_SCHEMA"),
table_column: Some("TABLE_NAME"),
name_column: "TABLE_NAME",
predicate: Some(REAL_TABLES),
order_by: "TABLE_SCHEMA, TABLE_NAME",
..PLAIN
};
static DATABASE_SPACE: Descriptor = Descriptor {
kind: Kind::DatabaseSpace,
source: "information_schema.TABLES",
short: &[
field("TABLE_SCHEMA", "name"),
field("COUNT(*)", "objects"),
field("SUM(DATA_LENGTH)", "data_bytes"),
field("SUM(INDEX_LENGTH)", "index_bytes"),
field("SUM(DATA_LENGTH + INDEX_LENGTH)", "total_bytes"),
],
extra: &[
field("SUM(DATA_FREE)", "free_bytes"),
field("SUM(TABLE_ROWS)", "estimated_rows"),
],
database_column: Some("TABLE_SCHEMA"),
name_column: "TABLE_SCHEMA",
predicate: Some(REAL_TABLES),
group_by: Some("TABLE_SCHEMA"),
order_by: "SUM(DATA_LENGTH + INDEX_LENGTH) DESC, TABLE_SCHEMA",
..PLAIN
};
static OBJECT_SPACE: Descriptor = Descriptor {
kind: Kind::ObjectSpace,
source: "information_schema.TABLES",
short: &[
field("TABLE_SCHEMA", "database"),
field("TABLE_NAME", "name"),
field("DATA_LENGTH", "data_bytes"),
field("INDEX_LENGTH", "index_bytes"),
field("DATA_LENGTH + INDEX_LENGTH", "total_bytes"),
],
extra: &[
field("ENGINE", "engine"),
field("TABLE_ROWS", "estimated_rows"),
field("DATA_FREE", "free_bytes"),
],
database_column: Some("TABLE_SCHEMA"),
table_column: Some("TABLE_NAME"),
name_column: "TABLE_NAME",
predicate: Some(REAL_TABLES),
order_by: "DATA_LENGTH + INDEX_LENGTH DESC, TABLE_SCHEMA, TABLE_NAME",
..PLAIN
};
#[cfg(test)]
mod tests {
use super::super::kinds::{fields, ALL};
use super::*;
#[test]
fn every_kind_carries_its_own_descriptor_and_name() {
for kind in ALL.iter().copied() {
assert_eq!(kind.descriptor().kind, kind, "{}", kind.as_str());
assert_eq!(Kind::parse(kind.as_str()), Some(kind));
let descriptor = kind.descriptor();
assert!(!descriptor.short.is_empty(), "{}", kind.as_str());
assert!(!descriptor.source.is_empty(), "{}", kind.as_str());
assert!(!descriptor.name_column.is_empty(), "{}", kind.as_str());
assert!(!descriptor.order_by.is_empty(), "{}", kind.as_str());
}
assert_eq!(Kind::parse("not_a_kind"), None);
}
#[test]
fn the_detailed_form_never_returns_less_than_the_short_one() {
for kind in ALL.iter().copied() {
let short = fields(kind.descriptor(), false);
let detailed = fields(kind.descriptor(), true);
assert!(detailed.len() >= short.len(), "{}", kind.as_str());
for (position, field) in short.iter().enumerate() {
assert_eq!(field.alias, detailed[position].alias, "{}", kind.as_str());
}
}
}
#[test]
fn no_kind_publishes_the_same_alias_twice() {
for kind in ALL.iter().copied() {
let mut aliases: Vec<&str> = fields(kind.descriptor(), true)
.iter()
.map(|field| field.alias)
.collect();
aliases.sort_unstable();
let before = aliases.len();
aliases.dedup();
assert_eq!(aliases.len(), before, "{} repeats an alias", kind.as_str());
}
}
#[test]
fn a_sequence_and_a_table_are_told_apart_by_their_condition() {
assert_eq!(SEQUENCE.source, TABLE.source);
assert_ne!(SEQUENCE.predicate, TABLE.predicate);
}
#[test]
fn every_kind_that_publishes_a_comment_marks_its_absence() {
for kind in [Kind::Table, Kind::View, Kind::Index, Kind::Routine] {
let carried = fields(kind.descriptor(), true);
let comment = carried
.iter()
.find(|field| field.alias == "comment")
.unwrap_or_else(|| panic!("{} publishes no comment", kind.as_str()));
assert!(
comment.source.contains("NULLIF"),
"{} hands back the empty text the catalogue keeps: {}",
kind.as_str(),
comment.source
);
}
}
#[test]
fn a_column_publishes_every_mark_an_insertion_depends_on() {
let aliases: Vec<&str> = fields(&COLUMN, true)
.iter()
.map(|field| field.alias)
.collect();
for wanted in [
"invisible",
"server_filled",
"derived",
"collation",
"comment",
] {
assert!(
aliases.contains(&wanted),
"a column never publishes {wanted}"
);
}
}
}