From ded86f99deb72f8bc095b195a009a5681d87d0da Mon Sep 17 00:00:00 2001
From: pawurb <contact@pawelurbanek.com>
Date: Tue, 23 Jan 2024 22:28:32 +0100
Subject: [PATCH] Use enum for query files

---
 src/lib.rs                          | 177 +++++++++++++++++-----------
 src/structs/all_locks.rs            |   2 -
 src/structs/bloat.rs                |   2 -
 src/structs/blocking.rs             |   2 -
 src/structs/buffercache_stats.rs    |   2 -
 src/structs/buffercache_usage.rs    |   2 -
 src/structs/cache_hit.rs            |   2 -
 src/structs/calls.rs                |   2 -
 src/structs/connections.rs          |   2 -
 src/structs/db_settings.rs          |   2 -
 src/structs/duplicate_indexes.rs    |   2 -
 src/structs/extensions.rs           |   2 -
 src/structs/index_cache_hit.rs      |   2 -
 src/structs/index_scans.rs          |   2 -
 src/structs/index_size.rs           |   2 -
 src/structs/index_usage.rs          |   2 -
 src/structs/indexes.rs              |   2 -
 src/structs/locks.rs                |   2 -
 src/structs/long_running_queries.rs |   2 -
 src/structs/mandelbrot.rs           |   2 -
 src/structs/null_indexes.rs         |   2 -
 src/structs/outliers.rs             |   2 -
 src/structs/records_rank.rs         |   2 -
 src/structs/seq_scans.rs            |   2 -
 src/structs/shared.rs               |   1 -
 src/structs/ssl_used.rs             |   2 -
 src/structs/table_cache_hit.rs      |   2 -
 src/structs/table_index_scans.rs    |   2 -
 src/structs/table_indexes_size.rs   |   2 -
 src/structs/table_size.rs           |   2 -
 src/structs/tables.rs               |   2 -
 src/structs/total_index_size.rs     |   2 -
 src/structs/total_table_size.rs     |   2 -
 src/structs/unused_indexes.rs       |   2 -
 src/structs/vacuum_stats.rs         |   2 -
 35 files changed, 108 insertions(+), 136 deletions(-)

diff --git a/src/lib.rs b/src/lib.rs
index 17abeeb..b0fc0c0 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -52,63 +52,63 @@ 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())
 }
 
@@ -116,23 +116,23 @@ 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)
@@ -140,36 +140,37 @@ pub fn long_running_queries() -> Result<Vec<LongRunningQueries>, PgExtrasError>
 }
 
 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)
@@ -177,102 +178,140 @@ pub fn table_indexes_size(schema: Option<String>) -> Result<Vec<TableIndexesSize
 }
 
 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"),
+        }
     }
 }
 
diff --git a/src/structs/all_locks.rs b/src/structs/all_locks.rs
index bdc1841..4c582bb 100644
--- a/src/structs/all_locks.rs
+++ b/src/structs/all_locks.rs
@@ -15,8 +15,6 @@ pub struct AllLocks {
 }
 
 impl Tabular for AllLocks {
-    const FILE_NAME: &'static str = "all_locks";
-
     fn new(row: &Row) -> Self {
         Self {
             pid: row.get::<_, Option<i32>>(0).unwrap_or_default().to_string(),
diff --git a/src/structs/bloat.rs b/src/structs/bloat.rs
index 9d20db4..96bd2ed 100644
--- a/src/structs/bloat.rs
+++ b/src/structs/bloat.rs
@@ -13,8 +13,6 @@ pub struct Bloat {
 }
 
 impl Tabular for Bloat {
-    const FILE_NAME: &'static str = "bloat";
-
     fn new(row: &Row) -> Self {
         Self {
             typefield: row.get::<_, Option<String>>(0).unwrap_or_default(),
diff --git a/src/structs/blocking.rs b/src/structs/blocking.rs
index d645c34..f53127c 100644
--- a/src/structs/blocking.rs
+++ b/src/structs/blocking.rs
@@ -15,8 +15,6 @@ pub struct Blocking {
 }
 
 impl Tabular for Blocking {
-    const FILE_NAME: &'static str = "blocking";
-
     fn new(row: &Row) -> Self {
         Self {
             blocked_pid: row.get::<_, Option<i32>>(0).unwrap_or_default(),
diff --git a/src/structs/buffercache_stats.rs b/src/structs/buffercache_stats.rs
index cb28013..7d4e53e 100644
--- a/src/structs/buffercache_stats.rs
+++ b/src/structs/buffercache_stats.rs
@@ -12,8 +12,6 @@ pub struct BuffercacheStats {
 }
 
 impl Tabular for BuffercacheStats {
-    const FILE_NAME: &'static str = "buffercache_stats";
-
     fn new(row: &Row) -> Self {
         Self {
             relname: row.get::<_, Option<String>>(0).unwrap_or_default(),
diff --git a/src/structs/buffercache_usage.rs b/src/structs/buffercache_usage.rs
index 527e9eb..27c246f 100644
--- a/src/structs/buffercache_usage.rs
+++ b/src/structs/buffercache_usage.rs
@@ -8,8 +8,6 @@ pub struct BuffercacheUsage {
 }
 
 impl Tabular for BuffercacheUsage {
-    const FILE_NAME: &'static str = "buffercache_usage";
-
     fn new(row: &Row) -> Self {
         Self {
             relname: row.get::<_, Option<String>>(0).unwrap_or_default(),
diff --git a/src/structs/cache_hit.rs b/src/structs/cache_hit.rs
index 1c8ef0a..579a707 100644
--- a/src/structs/cache_hit.rs
+++ b/src/structs/cache_hit.rs
@@ -10,8 +10,6 @@ pub struct CacheHit {
 }
 
 impl Tabular for CacheHit {
-    const FILE_NAME: &'static str = "cache_hit";
-
     fn new(row: &Row) -> Self {
         Self {
             name: row.get::<_, Option<String>>(0).unwrap_or_default(),
diff --git a/src/structs/calls.rs b/src/structs/calls.rs
index 750184e..58befa5 100644
--- a/src/structs/calls.rs
+++ b/src/structs/calls.rs
@@ -12,8 +12,6 @@ pub struct Calls {
 }
 
 impl Tabular for Calls {
-    const FILE_NAME: &'static str = "calls";
-
     fn new(row: &Row) -> Self {
         Self {
             qry: row.get::<_, Option<String>>(0).unwrap_or_default(),
diff --git a/src/structs/connections.rs b/src/structs/connections.rs
index 31f3ed1..bdc9aee 100644
--- a/src/structs/connections.rs
+++ b/src/structs/connections.rs
@@ -9,8 +9,6 @@ pub struct Connections {
 }
 
 impl Tabular for Connections {
-    const FILE_NAME: &'static str = "connections";
-
     fn new(row: &Row) -> Self {
         Self {
             username: row.get::<_, Option<String>>(0).unwrap_or_default(),
diff --git a/src/structs/db_settings.rs b/src/structs/db_settings.rs
index d2d407b..4d86266 100644
--- a/src/structs/db_settings.rs
+++ b/src/structs/db_settings.rs
@@ -10,8 +10,6 @@ pub struct DbSetting {
 }
 
 impl Tabular for DbSetting {
-    const FILE_NAME: &'static str = "db_settings";
-
     fn new(row: &Row) -> Self {
         Self {
             name: row.get::<_, Option<String>>(0).unwrap_or_default(),
diff --git a/src/structs/duplicate_indexes.rs b/src/structs/duplicate_indexes.rs
index 56ca930..8775b86 100644
--- a/src/structs/duplicate_indexes.rs
+++ b/src/structs/duplicate_indexes.rs
@@ -11,8 +11,6 @@ pub struct DuplicateIndexes {
 }
 
 impl Tabular for DuplicateIndexes {
-    const FILE_NAME: &'static str = "duplicate_indexes";
-
     fn new(row: &Row) -> Self {
         Self {
             size: row.get::<_, Option<String>>(0).unwrap_or_default(),
diff --git a/src/structs/extensions.rs b/src/structs/extensions.rs
index d545007..55d4fa6 100644
--- a/src/structs/extensions.rs
+++ b/src/structs/extensions.rs
@@ -10,8 +10,6 @@ pub struct Extensions {
 }
 
 impl Tabular for Extensions {
-    const FILE_NAME: &'static str = "extensions";
-
     fn new(row: &Row) -> Self {
         Self {
             name: row.get::<_, Option<String>>(0).unwrap_or_default(),
diff --git a/src/structs/index_cache_hit.rs b/src/structs/index_cache_hit.rs
index 57e02e9..e110635 100644
--- a/src/structs/index_cache_hit.rs
+++ b/src/structs/index_cache_hit.rs
@@ -11,8 +11,6 @@ pub struct IndexCacheHit {
 }
 
 impl Tabular for IndexCacheHit {
-    const FILE_NAME: &'static str = "index_cache_hit";
-
     fn new(row: &Row) -> Self {
         Self {
             name: row.get::<_, Option<String>>(0).unwrap_or_default(),
diff --git a/src/structs/index_scans.rs b/src/structs/index_scans.rs
index 4f9c112..521a24a 100644
--- a/src/structs/index_scans.rs
+++ b/src/structs/index_scans.rs
@@ -11,8 +11,6 @@ pub struct IndexScans {
 }
 
 impl Tabular for IndexScans {
-    const FILE_NAME: &'static str = "index_scans";
-
     fn new(row: &Row) -> Self {
         Self {
             schemaname: row.get::<_, Option<String>>(0).unwrap_or_default(),
diff --git a/src/structs/index_size.rs b/src/structs/index_size.rs
index b576b0f..8ec3fd0 100644
--- a/src/structs/index_size.rs
+++ b/src/structs/index_size.rs
@@ -9,8 +9,6 @@ pub struct IndexSize {
 }
 
 impl Tabular for IndexSize {
-    const FILE_NAME: &'static str = "index_size";
-
     fn new(row: &Row) -> Self {
         Self {
             name: row.get::<_, Option<String>>(0).unwrap_or_default(),
diff --git a/src/structs/index_usage.rs b/src/structs/index_usage.rs
index 1b9d812..d43b68e 100644
--- a/src/structs/index_usage.rs
+++ b/src/structs/index_usage.rs
@@ -9,8 +9,6 @@ pub struct IndexUsage {
 }
 
 impl Tabular for IndexUsage {
-    const FILE_NAME: &'static str = "index_usage";
-
     fn new(row: &Row) -> Self {
         Self {
             relname: row.get::<_, Option<String>>(0).unwrap_or_default(),
diff --git a/src/structs/indexes.rs b/src/structs/indexes.rs
index 7589a30..1f5c7a2 100644
--- a/src/structs/indexes.rs
+++ b/src/structs/indexes.rs
@@ -10,8 +10,6 @@ pub struct Indexes {
 }
 
 impl Tabular for Indexes {
-    const FILE_NAME: &'static str = "indexes";
-
     fn new(row: &Row) -> Self {
         Self {
             schemaname: row.get::<_, Option<String>>(0).unwrap_or_default(),
diff --git a/src/structs/locks.rs b/src/structs/locks.rs
index ffb8258..b5e9995 100644
--- a/src/structs/locks.rs
+++ b/src/structs/locks.rs
@@ -15,8 +15,6 @@ pub struct Locks {
 }
 
 impl Tabular for Locks {
-    const FILE_NAME: &'static str = "locks";
-
     fn new(row: &Row) -> Self {
         Self {
             pid: row.get::<_, Option<i32>>(0).unwrap_or_default().to_string(),
diff --git a/src/structs/long_running_queries.rs b/src/structs/long_running_queries.rs
index fef0034..2270c16 100644
--- a/src/structs/long_running_queries.rs
+++ b/src/structs/long_running_queries.rs
@@ -10,8 +10,6 @@ pub struct LongRunningQueries {
 }
 
 impl Tabular for LongRunningQueries {
-    const FILE_NAME: &'static str = "long_running_queries";
-
     fn new(row: &Row) -> Self {
         Self {
             pid: row.get::<_, Option<i32>>(0).unwrap_or_default().to_string(),
diff --git a/src/structs/mandelbrot.rs b/src/structs/mandelbrot.rs
index 82b14e8..61f7259 100644
--- a/src/structs/mandelbrot.rs
+++ b/src/structs/mandelbrot.rs
@@ -7,8 +7,6 @@ pub struct Mandelbrot {
 }
 
 impl Tabular for Mandelbrot {
-    const FILE_NAME: &'static str = "mandelbrot";
-
     fn new(row: &Row) -> Self {
         Self {
             array_to_string: row.get::<_, Option<String>>(0).unwrap_or_default(),
diff --git a/src/structs/null_indexes.rs b/src/structs/null_indexes.rs
index f8cc49f..dde2d92 100644
--- a/src/structs/null_indexes.rs
+++ b/src/structs/null_indexes.rs
@@ -15,8 +15,6 @@ pub struct NullIndexes {
 }
 
 impl Tabular for NullIndexes {
-    const FILE_NAME: &'static str = "null_indexes";
-
     fn new(row: &Row) -> Self {
         Self {
             oid: row.get::<_, Option<u32>>(0).unwrap_or_default().to_string(),
diff --git a/src/structs/outliers.rs b/src/structs/outliers.rs
index 01b8f08..ae539f8 100644
--- a/src/structs/outliers.rs
+++ b/src/structs/outliers.rs
@@ -12,8 +12,6 @@ pub struct Outliers {
 }
 
 impl Tabular for Outliers {
-    const FILE_NAME: &'static str = "outliers";
-
     fn new(row: &Row) -> Self {
         Self {
             total_exec_time: row
diff --git a/src/structs/records_rank.rs b/src/structs/records_rank.rs
index 0d5828c..e75876a 100644
--- a/src/structs/records_rank.rs
+++ b/src/structs/records_rank.rs
@@ -8,8 +8,6 @@ pub struct RecordsRank {
 }
 
 impl Tabular for RecordsRank {
-    const FILE_NAME: &'static str = "records_rank";
-
     fn new(row: &Row) -> Self {
         Self {
             name: row.get::<_, Option<String>>(0).unwrap_or_default(),
diff --git a/src/structs/seq_scans.rs b/src/structs/seq_scans.rs
index 01c6e8d..67aa3dc 100644
--- a/src/structs/seq_scans.rs
+++ b/src/structs/seq_scans.rs
@@ -8,8 +8,6 @@ pub struct SeqScans {
 }
 
 impl Tabular for SeqScans {
-    const FILE_NAME: &'static str = "seq_scans";
-
     fn new(row: &Row) -> Self {
         Self {
             name: row.get::<_, Option<String>>(0).unwrap_or_default(),
diff --git a/src/structs/shared.rs b/src/structs/shared.rs
index dd75caf..5822f91 100644
--- a/src/structs/shared.rs
+++ b/src/structs/shared.rs
@@ -4,7 +4,6 @@ use std::env;
 
 pub trait Tabular {
     fn new(row: &Row) -> Self;
-    const FILE_NAME: &'static str;
     fn to_row(&self) -> prettytable::Row;
     fn headers() -> prettytable::Row;
 }
diff --git a/src/structs/ssl_used.rs b/src/structs/ssl_used.rs
index 7822f3c..f962634 100644
--- a/src/structs/ssl_used.rs
+++ b/src/structs/ssl_used.rs
@@ -7,8 +7,6 @@ pub struct SslUsed {
 }
 
 impl Tabular for SslUsed {
-    const FILE_NAME: &'static str = "ssl_used";
-
     fn new(row: &Row) -> Self {
         Self {
             ssl_used: row.get::<_, Option<bool>>(0).unwrap_or_default(),
diff --git a/src/structs/table_cache_hit.rs b/src/structs/table_cache_hit.rs
index 57b8569..9ad3e19 100644
--- a/src/structs/table_cache_hit.rs
+++ b/src/structs/table_cache_hit.rs
@@ -11,8 +11,6 @@ pub struct TableCacheHit {
 }
 
 impl Tabular for TableCacheHit {
-    const FILE_NAME: &'static str = "table_cache_hit";
-
     fn new(row: &Row) -> Self {
         Self {
             name: row.get::<_, Option<String>>(0).unwrap_or_default(),
diff --git a/src/structs/table_index_scans.rs b/src/structs/table_index_scans.rs
index b9ae801..6fe7c8b 100644
--- a/src/structs/table_index_scans.rs
+++ b/src/structs/table_index_scans.rs
@@ -8,8 +8,6 @@ pub struct TableIndexScans {
 }
 
 impl Tabular for TableIndexScans {
-    const FILE_NAME: &'static str = "table_index_scans";
-
     fn new(row: &Row) -> Self {
         Self {
             name: row.get::<_, Option<String>>(0).unwrap_or_default(),
diff --git a/src/structs/table_indexes_size.rs b/src/structs/table_indexes_size.rs
index f2c2270..372faa2 100644
--- a/src/structs/table_indexes_size.rs
+++ b/src/structs/table_indexes_size.rs
@@ -8,8 +8,6 @@ pub struct TableIndexesSize {
 }
 
 impl Tabular for TableIndexesSize {
-    const FILE_NAME: &'static str = "table_indexes_size";
-
     fn new(row: &Row) -> Self {
         Self {
             table: row.get::<_, Option<String>>(0).unwrap_or_default(),
diff --git a/src/structs/table_size.rs b/src/structs/table_size.rs
index fca08fe..bd4a13c 100644
--- a/src/structs/table_size.rs
+++ b/src/structs/table_size.rs
@@ -9,8 +9,6 @@ pub struct TableSize {
 }
 
 impl Tabular for TableSize {
-    const FILE_NAME: &'static str = "table_size";
-
     fn new(row: &Row) -> Self {
         Self {
             name: row.get::<_, Option<String>>(0).unwrap_or_default(),
diff --git a/src/structs/tables.rs b/src/structs/tables.rs
index c9d81f7..3e8d5b0 100644
--- a/src/structs/tables.rs
+++ b/src/structs/tables.rs
@@ -8,8 +8,6 @@ pub struct Tables {
 }
 
 impl Tabular for Tables {
-    const FILE_NAME: &'static str = "tables";
-
     fn new(row: &Row) -> Self {
         Self {
             tablename: row.get::<_, Option<String>>(0).unwrap_or_default(),
diff --git a/src/structs/total_index_size.rs b/src/structs/total_index_size.rs
index 105b6e5..3528097 100644
--- a/src/structs/total_index_size.rs
+++ b/src/structs/total_index_size.rs
@@ -7,8 +7,6 @@ pub struct TotalIndexSize {
 }
 
 impl Tabular for TotalIndexSize {
-    const FILE_NAME: &'static str = "total_index_size";
-
     fn new(row: &Row) -> Self {
         Self {
             size: row.get::<_, Option<String>>(0).unwrap_or_default(),
diff --git a/src/structs/total_table_size.rs b/src/structs/total_table_size.rs
index 21d6ee2..6bf4fcc 100644
--- a/src/structs/total_table_size.rs
+++ b/src/structs/total_table_size.rs
@@ -8,8 +8,6 @@ pub struct TotalTableSize {
 }
 
 impl Tabular for TotalTableSize {
-    const FILE_NAME: &'static str = "total_table_size";
-
     fn new(row: &Row) -> Self {
         Self {
             name: row.get::<_, Option<String>>(0).unwrap_or_default(),
diff --git a/src/structs/unused_indexes.rs b/src/structs/unused_indexes.rs
index f2a4ea0..0757af6 100644
--- a/src/structs/unused_indexes.rs
+++ b/src/structs/unused_indexes.rs
@@ -10,8 +10,6 @@ pub struct UnusedIndexes {
 }
 
 impl Tabular for UnusedIndexes {
-    const FILE_NAME: &'static str = "unused_indexes";
-
     fn new(row: &Row) -> Self {
         Self {
             table: row.get::<_, Option<String>>(0).unwrap_or_default(),
diff --git a/src/structs/vacuum_stats.rs b/src/structs/vacuum_stats.rs
index 915c783..76e3891 100644
--- a/src/structs/vacuum_stats.rs
+++ b/src/structs/vacuum_stats.rs
@@ -14,8 +14,6 @@ pub struct VacuumStats {
 }
 
 impl Tabular for VacuumStats {
-    const FILE_NAME: &'static str = "vacuum_stats";
-
     fn new(row: &Row) -> Self {
         Self {
             schema: row.get::<_, Option<String>>(0).unwrap_or_default(),