Skip to content

Commit

Permalink
Use enum for query files
Browse files Browse the repository at this point in the history
  • Loading branch information
@pawurb
pawurb committed Jan 23, 2024
1 parent 4b2e8c5 commit 5085e04
Showing 1 changed file with 108 additions and 69 deletions.
177 changes: 108 additions & 69 deletions src/lib.rs
View file
Original file line number Diff line number Diff line change
Expand Up @@ -52,227 +52,266 @@ pub fn render_table<T: Tabular>(items: Vec<T>) {
}

pub fn bloat() -> Result<Vec<Bloat>, PgExtrasError> {
let query = read_file(Bloat::FILE_NAME);
let query = Query::read_file(Query::Bloat);
Ok(get_rows(query)?.iter().map(Bloat::new).collect())
}

pub fn blocking(limit: Option<String>) -> Result<Vec<Blocking>, PgExtrasError> {
let limit = limit.unwrap_or("10".to_string());
let query = read_file(Blocking::FILE_NAME).replace("%{limit}", limit.as_str());
let query = Query::read_file(Query::Blocking).replace("%{limit}", limit.as_str());
Ok(get_rows(&query)?.iter().map(Blocking::new).collect())
}

pub fn calls(limit: Option<String>) -> Result<Vec<Calls>, PgExtrasError> {
let limit = limit.unwrap_or("10".to_string());
let query = read_file("calls").replace("%{limit}", limit.as_str());
let query = Query::read_file(Query::Calls).replace("%{limit}", limit.as_str());
Ok(get_rows(&query)?.iter().map(Calls::new).collect())
}

pub fn extensions() -> Result<Vec<Extensions>, PgExtrasError> {
let query = read_file(Extensions::FILE_NAME);
let query = Query::read_file(Query::Extensions);
Ok(get_rows(query)?.iter().map(Extensions::new).collect())
}

pub fn table_cache_hit() -> Result<Vec<TableCacheHit>, PgExtrasError> {
let query = read_file(TableCacheHit::FILE_NAME);
let query = Query::read_file(Query::TableCacheHit);
Ok(get_rows(query)?.iter().map(TableCacheHit::new).collect())
}

pub fn tables(schema: Option<String>) -> Result<Vec<Tables>, PgExtrasError> {
let schema_name = schema.unwrap_or(get_default_schema());
let query = read_file(Tables::FILE_NAME).replace("%{schema}", &schema_name);
let query = Query::read_file(Query::Tables).replace("%{schema}", &schema_name);
Ok(get_rows(&query)?.iter().map(Tables::new).collect())
}

pub fn index_cache_hit(schema: Option<String>) -> Result<Vec<IndexCacheHit>, PgExtrasError> {
let schema_name = schema.unwrap_or(get_default_schema());
let query = read_file(IndexCacheHit::FILE_NAME).replace("%{schema}", &schema_name);
let query = Query::read_file(Query::IndexCacheHit).replace("%{schema}", &schema_name);
Ok(get_rows(&query)?.iter().map(IndexCacheHit::new).collect())
}

pub fn indexes() -> Result<Vec<Indexes>, PgExtrasError> {
let query = read_file(Indexes::FILE_NAME);
let query = Query::read_file(Query::Indexes);
Ok(get_rows(query)?.iter().map(Indexes::new).collect())
}

pub fn index_size() -> Result<Vec<IndexSize>, PgExtrasError> {
let query = read_file(IndexSize::FILE_NAME);
let query = Query::read_file(Query::IndexSize);
Ok(get_rows(query)?.iter().map(IndexSize::new).collect())
}

pub fn index_usage(schema: Option<String>) -> Result<Vec<IndexUsage>, PgExtrasError> {
let schema_name = schema.unwrap_or(get_default_schema());
let query = read_file(IndexUsage::FILE_NAME).replace("%{schema}", &schema_name);
let query = Query::read_file(Query::IndexUsage).replace("%{schema}", &schema_name);
Ok(get_rows(&query)?.iter().map(IndexUsage::new).collect())
}

pub fn index_scans(schema: Option<String>) -> Result<Vec<IndexScans>, PgExtrasError> {
let schema_name = schema.unwrap_or(get_default_schema());
let query = read_file(IndexScans::FILE_NAME).replace("%{schema}", &schema_name);
let query = Query::read_file(Query::IndexScans).replace("%{schema}", &schema_name);
Ok(get_rows(&query)?.iter().map(IndexScans::new).collect())
}

pub fn null_indexes(
min_relation_size_mb: Option<String>,
) -> Result<Vec<NullIndexes>, PgExtrasError> {
let min_relation_size_mb = min_relation_size_mb.unwrap_or("0".to_string());
let query =
read_file(NullIndexes::FILE_NAME).replace("%{min_relation_size_mb}", &min_relation_size_mb);
let query = Query::read_file(Query::NullIndexes)
.replace("%{min_relation_size_mb}", &min_relation_size_mb);
Ok(get_rows(&query)?.iter().map(NullIndexes::new).collect())
}

pub fn locks() -> Result<Vec<Locks>, PgExtrasError> {
let query = read_file(Locks::FILE_NAME);
let query = Query::read_file(Query::Locks);
Ok(get_rows(query)?.iter().map(Locks::new).collect())
}

pub fn all_locks() -> Result<Vec<AllLocks>, PgExtrasError> {
let query = read_file(AllLocks::FILE_NAME);
let query = Query::read_file(Query::AllLocks);
Ok(get_rows(query)?.iter().map(AllLocks::new).collect())
}

pub fn long_running_queries() -> Result<Vec<LongRunningQueries>, PgExtrasError> {
let query = read_file(LongRunningQueries::FILE_NAME);
let query = Query::read_file(Query::LongRunningQueries);
Ok(get_rows(query)?
.iter()
.map(LongRunningQueries::new)
.collect())
}

pub fn mandelbrot() -> Result<Vec<Mandelbrot>, PgExtrasError> {
let query = read_file(Mandelbrot::FILE_NAME);
let query = Query::read_file(Query::Mandelbrot);
Ok(get_rows(query)?.iter().map(Mandelbrot::new).collect())
}

pub fn outliers() -> Result<Vec<Outliers>, PgExtrasError> {
let query = read_file(Outliers::FILE_NAME);
let query = Query::read_file(Query::Outliers);
Ok(get_rows(query)?.iter().map(Outliers::new).collect())
}

pub fn records_rank(schema: Option<String>) -> Result<Vec<RecordsRank>, PgExtrasError> {
let schema_name = schema.unwrap_or(get_default_schema());
let query = read_file(RecordsRank::FILE_NAME).replace("%{schema}", schema_name.as_str());
let query = Query::read_file(Query::RecordsRank).replace("%{schema}", schema_name.as_str());
Ok(get_rows(&query)?.iter().map(RecordsRank::new).collect())
}

pub fn seq_scans(schema: Option<String>) -> Result<Vec<SeqScans>, PgExtrasError> {
let schema_name = schema.unwrap_or(get_default_schema());
let query = read_file(SeqScans::FILE_NAME).replace("%{schema}", schema_name.as_str());
let query = Query::read_file(Query::SeqScans).replace("%{schema}", schema_name.as_str());
Ok(get_rows(&query)?.iter().map(SeqScans::new).collect())
}

pub fn table_index_scans(schema: Option<String>) -> Result<Vec<TableIndexScans>, PgExtrasError> {
let schema_name = schema.unwrap_or(get_default_schema());
let query = read_file(TableIndexScans::FILE_NAME).replace("%{schema}", schema_name.as_str());
let query = Query::read_file(Query::TableIndexScans).replace("%{schema}", schema_name.as_str());
Ok(get_rows(&query)?.iter().map(TableIndexScans::new).collect())
}

pub fn table_indexes_size(schema: Option<String>) -> Result<Vec<TableIndexesSize>, PgExtrasError> {
let schema_name = schema.unwrap_or(get_default_schema());
let query = read_file(TableIndexesSize::FILE_NAME).replace("%{schema}", schema_name.as_str());
let query =
Query::read_file(Query::TableIndexesSize).replace("%{schema}", schema_name.as_str());
Ok(get_rows(&query)?
.iter()
.map(TableIndexesSize::new)
.collect())
}

pub fn table_size() -> Result<Vec<TableSize>, PgExtrasError> {
let query = read_file(TableSize::FILE_NAME);
let query = Query::read_file(Query::TableSize);
Ok(get_rows(query)?.iter().map(TableSize::new).collect())
}

pub fn total_index_size() -> Result<Vec<TotalIndexSize>, PgExtrasError> {
let query = read_file(TotalIndexSize::FILE_NAME);
let query = Query::read_file(Query::TotalIndexSize);
Ok(get_rows(query)?.iter().map(TotalIndexSize::new).collect())
}

pub fn total_table_size() -> Result<Vec<TotalTableSize>, PgExtrasError> {
let query = read_file(TotalTableSize::FILE_NAME);
let query = Query::read_file(Query::TotalTableSize);
Ok(get_rows(query)?.iter().map(TotalTableSize::new).collect())
}

pub fn unused_indexes(schema: Option<String>) -> Result<Vec<UnusedIndexes>, PgExtrasError> {
let schema_name = schema.unwrap_or(get_default_schema());
let query = read_file(UnusedIndexes::FILE_NAME).replace("%{schema}", schema_name.as_str());
let query = Query::read_file(Query::UnusedIndexes).replace("%{schema}", schema_name.as_str());
Ok(get_rows(&query)?.iter().map(UnusedIndexes::new).collect())
}

pub fn duplicate_indexes() -> Result<Vec<DuplicateIndexes>, PgExtrasError> {
let query = read_file(DuplicateIndexes::FILE_NAME);
let query = Query::read_file(Query::DuplicateIndexes);
Ok(get_rows(query)?.iter().map(DuplicateIndexes::new).collect())
}

pub fn vacuum_stats() -> Result<Vec<VacuumStats>, PgExtrasError> {
let query = read_file(VacuumStats::FILE_NAME);
let query = Query::read_file(Query::VacuumStats);
Ok(get_rows(query)?.iter().map(VacuumStats::new).collect())
}

pub fn buffercache_stats() -> Result<Vec<BuffercacheStats>, PgExtrasError> {
let query = read_file(BuffercacheStats::FILE_NAME);
let query = Query::read_file(Query::BuffercacheStats);
Ok(get_rows(query)?.iter().map(BuffercacheStats::new).collect())
}

pub fn buffercache_usage() -> Result<Vec<BuffercacheUsage>, PgExtrasError> {
let query = read_file(BuffercacheUsage::FILE_NAME);
let query = Query::read_file(Query::BuffercacheUsage);
Ok(get_rows(query)?.iter().map(BuffercacheUsage::new).collect())
}

pub fn ssl_used() -> Result<Vec<SslUsed>, PgExtrasError> {
let query = read_file(SslUsed::FILE_NAME);
let query = Query::read_file(Query::SslUsed);
Ok(get_rows(query)?.iter().map(SslUsed::new).collect())
}

pub fn connections() -> Result<Vec<Connections>, PgExtrasError> {
let query = read_file(Connections::FILE_NAME);
let query = Query::read_file(Query::Connections);
Ok(get_rows(query)?.iter().map(Connections::new).collect())
}

pub fn cache_hit(schema: Option<String>) -> Result<Vec<CacheHit>, PgExtrasError> {
let schema_name = schema.unwrap_or(get_default_schema());
let query = read_file(CacheHit::FILE_NAME).replace("%{schema}", schema_name.as_str());
let query = Query::read_file(Query::CacheHit).replace("%{schema}", schema_name.as_str());
Ok(get_rows(&query)?.iter().map(CacheHit::new).collect())
}

pub fn db_settings() -> Result<Vec<DbSetting>, PgExtrasError> {
let query = read_file("db_settings");
let query = Query::read_file(Query::DbSettings);
Ok(get_rows(query)?.iter().map(DbSetting::new).collect())
}

pub fn read_file(filename: &str) -> &'static str {
match filename {
"cache_hit" => include_str!("queries/cache_hit.sql"),
"bloat" => include_str!("queries/bloat.sql"),
"blocking" => include_str!("queries/blocking.sql"),
"calls" => include_str!("queries/calls.sql"),
"extensions" => include_str!("queries/extensions.sql"),
"table_cache_hit" => include_str!("queries/table_cache_hit.sql"),
"tables" => include_str!("queries/tables.sql"),
"index_cache_hit" => include_str!("queries/index_cache_hit.sql"),
"indexes" => include_str!("queries/indexes.sql"),
"index_size" => include_str!("queries/index_size.sql"),
"index_usage" => include_str!("queries/index_usage.sql"),
"index_scans" => include_str!("queries/index_scans.sql"),
"null_indexes" => include_str!("queries/null_indexes.sql"),
"locks" => include_str!("queries/locks.sql"),
"all_locks" => include_str!("queries/all_locks.sql"),
"long_running_queries" => include_str!("queries/long_running_queries.sql"),
"mandelbrot" => include_str!("queries/mandelbrot.sql"),
"outliers" => include_str!("queries/outliers.sql"),
"records_rank" => include_str!("queries/records_rank.sql"),
"seq_scans" => include_str!("queries/seq_scans.sql"),
"table_index_scans" => include_str!("queries/table_index_scans.sql"),
"table_indexes_size" => include_str!("queries/table_indexes_size.sql"),
"table_size" => include_str!("queries/table_size.sql"),
"total_index_size" => include_str!("queries/total_index_size.sql"),
"total_table_size" => include_str!("queries/total_table_size.sql"),
"unused_indexes" => include_str!("queries/unused_indexes.sql"),
"duplicate_indexes" => include_str!("queries/duplicate_indexes.sql"),
"vacuum_stats" => include_str!("queries/vacuum_stats.sql"),
"buffercache_stats" => include_str!("queries/buffercache_stats.sql"),
"buffercache_usage" => include_str!("queries/buffercache_usage.sql"),
"ssl_used" => include_str!("queries/ssl_used.sql"),
"connections" => include_str!("queries/connections.sql"),
_ => panic!("Unknown file: {}", filename),
enum Query {
CacheHit,
Bloat,
Blocking,
Calls,
Extensions,
TableCacheHit,
Tables,
IndexCacheHit,
DbSettings,
Indexes,
IndexSize,
IndexUsage,
IndexScans,
NullIndexes,
Locks,
AllLocks,
LongRunningQueries,
Mandelbrot,
Outliers,
RecordsRank,
SeqScans,
TableIndexScans,
TableIndexesSize,
TableSize,
TotalIndexSize,
TotalTableSize,
UnusedIndexes,
DuplicateIndexes,
VacuumStats,
BuffercacheStats,
BuffercacheUsage,
SslUsed,
Connections,
}

impl Query {
pub fn read_file(query: Query) -> &'static str {
match query {
Query::CacheHit => include_str!("queries/cache_hit.sql"),
Query::DbSettings => include_str!("queries/db_settings.sql"),
Query::BuffercacheStats => include_str!("queries/buffercache_stats.sql"),
Query::BuffercacheUsage => include_str!("queries/buffercache_usage.sql"),
Query::SslUsed => include_str!("queries/ssl_used.sql"),
Query::Connections => include_str!("queries/connections.sql"),
Query::Bloat => include_str!("queries/bloat.sql"),
Query::Blocking => include_str!("queries/blocking.sql"),
Query::Calls => include_str!("queries/calls.sql"),
Query::Extensions => include_str!("queries/extensions.sql"),
Query::TableCacheHit => include_str!("queries/table_cache_hit.sql"),
Query::Tables => include_str!("queries/tables.sql"),
Query::IndexCacheHit => include_str!("queries/index_cache_hit.sql"),
Query::Indexes => include_str!("queries/indexes.sql"),
Query::IndexSize => include_str!("queries/index_size.sql"),
Query::IndexUsage => include_str!("queries/index_usage.sql"),
Query::IndexScans => include_str!("queries/index_scans.sql"),
Query::NullIndexes => include_str!("queries/null_indexes.sql"),
Query::Locks => include_str!("queries/locks.sql"),
Query::AllLocks => include_str!("queries/all_locks.sql"),
Query::LongRunningQueries => include_str!("queries/long_running_queries.sql"),
Query::Mandelbrot => include_str!("queries/mandelbrot.sql"),
Query::Outliers => include_str!("queries/outliers.sql"),
Query::RecordsRank => include_str!("queries/records_rank.sql"),
Query::SeqScans => include_str!("queries/seq_scans.sql"),
Query::TableIndexScans => include_str!("queries/table_index_scans.sql"),
Query::TableIndexesSize => include_str!("queries/table_indexes_size.sql"),
Query::TableSize => include_str!("queries/table_size.sql"),
Query::TotalIndexSize => include_str!("queries/total_index_size.sql"),
Query::TotalTableSize => include_str!("queries/total_table_size.sql"),
Query::UnusedIndexes => include_str!("queries/unused_indexes.sql"),
Query::DuplicateIndexes => include_str!("queries/duplicate_indexes.sql"),
Query::VacuumStats => include_str!("queries/vacuum_stats.sql"),
}
}
}

Expand Down

0 comments on commit 5085e04

Please sign in to comment.