Effective PostgreSQL Database Management for Hosted Applications: Unveiling Your Data with `psql show all db`

For businesses leveraging hosted applications, the database is often the beating heart of their operations. Whether it’s an e-commerce platform, a content management system, or a custom SaaS application, a robust and well-managed PostgreSQL database is non-negotiable. Yet, amidst the complexities of server configurations, network settings, and application deployments, the foundational task of simply knowing *what databases you even have* on your server can sometimes be overlooked. This oversight can lead to resource inefficiencies, security vulnerabilities, and ultimately, operational headaches that impact your bottom line.

You might be deploying new services, migrating old data, or simply trying to declutter your server, and a simple command like `psql show all db` becomes an indispensable tool. It’s not just about listing names; it’s about gaining immediate clarity on your PostgreSQL landscape within a hosted environment, enabling informed decisions about resource allocation, security posture, and future growth. Understanding the output of this command, and more importantly, its implications for your hosting strategy, is crucial for anyone managing PostgreSQL on a server, from a compact netherlands vps to a robust dedicated server environment. This article delves into how `psql show all db` serves as your first line of defense and an essential step in maintaining a healthy, performant, and secure database infrastructure for your hosted applications.

Understanding `psql show all db` in a Hosted Context

At its core, `psql show all db` is a simple yet powerful meta-command within the PostgreSQL interactive terminal, `psql`. It provides a concise list of all databases present on the PostgreSQL server you are connected to. While the command itself is straightforward, its relevance significantly amplifies when you consider it within a hosted application environment.

When you connect to your PostgreSQL instance, whether it’s running on a shared hosting plan (though less common for direct `psql` access), a virtual private server, or a dedicated machine, this command gives you an immediate inventory. This isn’t merely a technicality; it’s a critical piece of information for several reasons:

* **Visibility:** You instantly see every database. This is vital for verifying deployments, identifying forgotten test databases, or spotting unexpected database creation.
* **Resource Management:** Each database consumes disk space and can contribute to overall server load. Knowing what you have helps you monitor consumption and identify potential “storage hogs.”
* **Security Auditing:** Unused or unauthorized databases can be potential security risks. The `show all db` command is a quick check to ensure only intended databases exist.
* **Troubleshooting:** If an application isn’t connecting to its database, confirming the database’s existence and correct naming is often the first diagnostic step.

The command, `\l` or `\list`, performs the same function as `show all db` in `psql`. When executed, it typically returns a table with columns such as:

* `Name`: The name of the database.
* `Owner`: The PostgreSQL user that owns the database. This is crucial for permission management.
* `Encoding`: The character set encoding used by the database (e.g., UTF8).
* `Collate`: The collation order for string comparisons.
* `Ctype`: The character type classification.
* `Access privileges`: Who can connect and perform operations on the database.
* `Size`: The approximate size of the database.
* `Tablespace`: The tablespace where the database is stored.

Understanding these details in the context of your hosting solution is paramount. For instance, on a shared hosting environment, you might only see databases specifically provisioned for your account, and you might not have the privileges to see others. On a dedicated server or a high-end premium hosting solution, you’d likely see every database, including system ones like `template0`, `template1`, and `postgres`. This immediate visibility informs your subsequent actions, whether that’s performing cleanup, assigning permissions, or planning for capacity upgrades.

Real-World Use Case: Scaling an E-commerce Platform

Consider “BazaarHub,” a rapidly growing online marketplace built on a PostgreSQL backend hosted on a powerful VPS infrastructure. BazaarHub started with a single database for its core e-commerce operations. However, as the platform scaled, new microservices were introduced: a recommendation engine, an analytics dashboard, a separate inventory management system, and a payment gateway integration module. Each development team, often working independently, provisioned its own PostgreSQL database on the same VPS instance to maintain isolation and simplify deployments.

Over time, this organic growth led to a significant challenge. The server administrator, tasked with maintaining performance and security, noticed several pain points:

* **Resource Bloat:** The server was running a multitude of databases, some for active services, others for deprecated features, and a few for forgotten test environments. Disk space utilization was unexpectedly high, and the server was nearing its capacity, prompting premature discussions about upgrading to a dedicated server when a simple cleanup might suffice.
* **Security Blind Spots:** With numerous databases, tracking access permissions for each became a nightmare. Were all test databases properly secured? Did old user accounts still have access to production-like data in some forgotten staging database?
* **Performance Degradation:** While individual microservices might have been optimized, the sheer number of active and idle connections across all databases contributed to increased memory usage and CPU load, particularly during peak traffic hours. Identifying which databases were causing the most contention was difficult without a clear overview.
* **Migration Headaches:** BazaarHub was planning a move to a more geographically optimized offshore hosting solution to cater to its expanding international customer base. The prospect of migrating an unknown number of databases, some potentially obsolete, presented a significant operational risk and planning challenge.

The first crucial step for BazaarHub’s administrator was to get a definitive, accurate inventory of all PostgreSQL databases. This is where `psql show all db` became their immediate diagnostic tool. Connecting to the PostgreSQL server and executing this command instantly provided the complete list. They discovered over 30 databases, whereas their active services only accounted for about 15. The remaining were old development instances, forgotten staging environments, and even some experimental databases that were never cleaned up.

This clarity allowed BazaarHub to:

1. **Audit and Decommission:** They identified and systematically decommissioned 10 redundant databases, immediately freeing up significant disk space and reducing potential attack surfaces.
2. **Optimize Resource Allocation:** With a clearer picture, they could re-evaluate database sizing and consider consolidating some smaller, less critical microservice databases into a shared schema, thereby reducing overhead.
3. **Strengthen Security:** Each remaining database’s owner and access privileges were reviewed and adjusted, eliminating stale user accounts and restricting access to only necessary personnel and services.
4. **Streamline Migration Planning:** Knowing the exact number and sizes of active databases significantly simplified their migration plan to the offshore hosting provider, reducing risk and ensuring a smoother transition.

This real-world scenario underscores that `psql show all db` is not just a command for developers, but a strategic tool for system administrators and business owners alike, directly impacting operational efficiency, security posture, and hosting cost management.

Beyond the Basics: Interpreting Output and Deeper Insights

While `psql show all db` (or `\l`) provides a foundational list, truly effective database management in a hosted environment requires interpreting its output and knowing when to dig deeper.

The `Size` column is often the first indicator that catches attention. A surprisingly large database might signal uncontrolled data growth, inadequate archival strategies, or simply indicate a critical application. Conversely, a tiny database that’s expected to be large could point to data ingestion failures. For a more precise size, you can use `\l+` which includes more details, including the size in a human-readable format, or directly query:

SELECT datname, pg_size_pretty(pg_database_size(datname)) FROM pg_database ORDER BY pg_database_size(datname) DESC;

This SQL query, executed within `psql`, provides a ranked list of databases by size, which is incredibly useful for capacity planning, especially on a VPS where disk space is a finite and often premium resource.

The `Owner` column is crucial for security and accountability. If you find databases owned by deprecated users or generic `postgres` users that should be assigned to specific service accounts, this is a flag for immediate action. For instance, in a Premium Hosting setup, robust user and role management is a hallmark of good practice. You wouldn’t want a critical application database owned by an account that no longer exists or has overly broad privileges.

`Access privileges` give a high-level overview. For detailed permissions within a specific database, you’d connect to that database and use commands like `\dp` (list table/column permissions) or query `pg_roles` and `pg_grants`. This level of detail is critical for hardening security, especially when hosting sensitive data.

The `Encoding`, `Collate`, and `Ctype` columns are important for internationalized applications. Inconsistencies across databases can lead to data corruption or incorrect sorting/searching results, particularly when dealing with diverse customer bases on global hosting solutions.

The Operational Impact of Database Proliferation

Unmanaged database proliferation, even on powerful dedicated server hardware, introduces a cascade of operational challenges:

Performance Overhead:

Each database, even if idle, consumes some system resources (memory, file descriptors). A large number of databases increases the PostgreSQL server’s overall footprint.
More databases often mean more connections, active or passive, leading to increased contention for connection slots and memory.
Backup processes can become inefficient and prolonged if they have to sift through numerous unnecessary databases.

Security Vulnerabilities:

An expanding attack surface: Every database, particularly old or forgotten ones, represents a potential entry point if not properly secured.
Difficulty in auditing: It’s harder to track and enforce consistent security policies (user roles, password rotations, access restrictions) across dozens of databases.
Data leakage risks: Deprecated databases might contain sensitive data that is no longer needed but hasn’t been properly purged or secured.

Maintenance Complexity and Cost:

Patching and upgrades: Rolling out database server updates becomes riskier with an unknown inventory, as you might not know which legacy applications rely on which obscure database.
Increased storage costs: Paying for disk space that holds dormant, useless data.
Administrative burden: More time spent sifting through logs, checking backups, and trying to understand database relationships. This directly translates to higher operational expenditure.

Real-World Implementation Example: Consolidating Analytical Data Stores

Imagine “InsightFlow,” a data analytics startup using a PostgreSQL instance on a robust cloud hosting platform. Initially, each client onboarded received a separate PostgreSQL database for their specific analytics data, ensuring strict data isolation. Over time, as client count grew, this approach became unwieldy. Managing backups, updates, and schema migrations for hundreds of individual databases was consuming an exorbitant amount of engineering time. InsightFlow decided to consolidate many smaller clients into a multi-tenant schema within a single large database, while keeping larger, enterprise clients in dedicated databases.

Here’s how `psql show all db` became instrumental in their consolidation project:

1. Initial Inventory: The first step was to get a complete list of all client databases.

psql -U admin_user -h database.semayra.cloud -d postgres -c "\l"

Explanation: Connect as an admin user to the main `postgres` database (the default starting point) and execute the `\l` command. The `-h` flag specifies the host, which is your database server’s address provided by your hosting provider. Semayra, for example, would provide a clear endpoint for your PostgreSQL instance. This output immediately revealed 250+ databases, far more than anticipated, including many from inactive clients or test accounts.

2. Database Identification and Sizing: InsightFlow then enhanced the inventory by getting sizes and activity metrics.

psql -U admin_user -h database.semayra.cloud -d postgres -c "SELECT datname, pg_size_pretty(pg_database_size(datname)) AS total_size, pg_stat_get_db_numbackends(oid) AS num_connections, pg_stat_get_db_xact_commit(oid) AS transactions_committed FROM pg_database WHERE datname NOT IN ('template0', 'template1', 'postgres') ORDER BY total_size DESC;"

Explanation: This query provided a clear ranking by size, along with current connections and committed transactions, helping identify truly active and large databases versus dormant ones. They found that 80% of their databases were very small (<1GB) and suitable for multi-tenant consolidation, while a few large ones needed to remain separate.

3. Client Mapping and Categorization: The team correlated the database names with their client IDs and categorized them into “Consolidate,” “Keep Separate,” or “Decommission.” This crucial step involved cross-referencing with their internal CRM and billing systems.

4. Consolidation Planning: For databases marked for consolidation, they developed a migration plan:
* Create new schemas within the target multi-tenant database.
* Migrate data from the old client database into the new schema, adapting the schema as needed.
* Update application configuration to point clients to their new schema in the consolidated database.

5. Decommissioning and Cleanup: For databases marked for decommissioning (inactive clients, old tests), they performed careful backups, then dropped the databases.

DROP DATABASE old_client_db_name;

Explanation: This command requires caution. Always ensure backups and confirm the database is truly no longer needed.

By systematically using `psql show all db` and subsequent targeted queries, InsightFlow successfully reduced its database count from over 250 to less than 50 (a few large client databases and one large multi-tenant database). This dramatically streamlined their operations, reduced maintenance overhead, improved backup efficiency, and freed up valuable engineering time, making their cloud hosting solution even more cost-effective.

Database Organization Strategies: A Crucial Comparison for Hosted Environments

When architecting database solutions on hosting platforms, a fundamental decision revolves around how you organize your data: dedicate a database per application/service or consolidate multiple applications/tenants into a single database. The choice significantly impacts resource management, security, and scalability, and `psql show all db` is your lens into this structure.

Single Database Per Application/Service

In this model, each distinct application, microservice, or even client (in a dedicated single-tenant setup) gets its own PostgreSQL database.

* Performance
* Advantage: Resource isolation at the database level. Performance issues in one application are less likely to directly impact others, as their operations are distinct. Easier to tune specific database parameters for a single application’s needs.
* Disadvantage: Increased overhead from running many separate database instances/processes, potentially consuming more memory and CPU overall, especially on a single VPS or dedicated server. Context switching between many databases can incur a slight penalty.
* Security
* Advantage: Strongest isolation. A compromise of one database does not automatically expose data from others. Easier to manage user permissions specific to each database.
* Disadvantage: More individual attack surfaces to secure. Requires meticulous management of connection strings and user credentials for each application.
* Cost
* Advantage: Potentially simpler to attribute database costs to specific projects if using a DBaaS where databases are billed individually.
* Disadvantage: Can lead to over-provisioning if many small databases each require a minimum resource allocation. More databases can consume more disk space, impacting overall hosting costs on a fixed-resource plan.
* Scalability
* Advantage: Ideal for horizontal scaling where individual databases can be moved to separate servers or sharded independently as an application grows.
* Disadvantage: Managing scaling for a large number of independent databases adds administrative complexity.
* Ease of Management
* Advantage: Clear separation for development, testing, and deployment. Easier to restore a single application’s database from a backup without affecting others.
* Disadvantage: Requires managing credentials and configurations for many database connections. Bulk operations (e.g., server-wide schema changes) become more complex.
* Recommended Use Cases
* High-security applications requiring strict data isolation.
* Microservices architectures where services should be entirely decoupled.
* Multi-tenant SaaS platforms where each major client demands dedicated database resources and isolation.
* Applications with highly divergent performance profiles or compliance requirements.

Consolidated Multi-Tenant Database (Single Database, Multiple Schemas/Tables)

Here, a single PostgreSQL database hosts multiple applications or tenants, typically separated by schemas or a tenant_id column within tables.

* Performance
* Advantage: Reduced overhead, as fewer database instances/processes are running. Efficient use of connection pools.
* Disadvantage: Noisy neighbor problem: a poorly performing query or high load from one tenant can impact all others in the same database. Requires careful indexing and query optimization to avoid contention.
* Security
* Advantage: Fewer connection points to secure. Centralized access control.
* Disadvantage: Requires robust application-level or schema-level security to prevent data leakage between tenants. A single SQL injection vulnerability could potentially expose data from multiple tenants.
* Cost
* Advantage: Highly cost-efficient for many small tenants or applications, as they share resources and don’t require individual minimum allocations. Maximizes utilization of your hosting resources (e.g., a Netherlands VPS).
* Disadvantage: Upgrading the single database server to handle increased load can be more expensive than scaling individual smaller databases.
* Scalability
* Advantage: Simpler to manage backups and routine maintenance for a single large database.
* Disadvantage: Harder to scale horizontally for individual tenants without complex sharding or partitioning strategies at the application level.
* Ease of Management
* Advantage: Fewer databases to monitor, backup, and manage credentials for. Centralized administration.
* Disadvantage: Schema changes must be carefully managed to avoid breaking multiple applications simultaneously. Data migration within the database requires more planning.
* Recommended Use Cases
* Small-to-medium multi-tenant SaaS platforms where cost-efficiency and ease of management for numerous clients are priorities.
* Applications with shared data structures or analytics across many users.
* Development and staging environments where strict isolation is less critical.
* When hosting resources are limited (e.g., starting on a modest VPS), and maximizing resource utilization is key.

The choice often isn’t black and white; many organizations adopt a hybrid approach. For instance, critical, high-volume services might get dedicated databases, while smaller, internal tools or analytics dashboards share a consolidated database. Regularly using `psql show all db` keeps this entire landscape visible, allowing administrators to verify their chosen strategy and adapt as business needs evolve.

Common Deployment Mistakes When Managing PostgreSQL Databases

Even with the simplicity of `psql show all db` for visibility, several common mistakes can undermine effective database management, particularly in dynamic hosted environments.

* Ignoring Unknown Databases: Perhaps the most common oversight. Developers might spin up temporary databases for testing, forget them, and move on. These databases consume resources, often have weak security settings, and contribute to clutter. `psql show all db` will show them, but if administrators don’t regularly review the output and act on it, the problem persists.
* Prevention: Implement a clear database lifecycle policy. Regularly audit the output of `psql show all db` and investigate any databases that are not officially documented or expected.
* Generic Database Naming: Naming databases `test_db`, `new_project_db`, or `my_app_temp` makes it impossible to distinguish their purpose, owner, or lifecycle stage later.
* Prevention: Enforce strict naming conventions that include project, environment (dev, staging, prod), and possibly owner or creation date. E.g., `bazaarhub_prod_main`, `insightflow_staging_client_a`.
* Over-reliance on Default Permissions: Creating databases using the default `postgres` user or accounts with excessively broad permissions. This simplifies initial setup but creates significant security vulnerabilities.
* Prevention: Always create specific roles for database owners and application users, granting only the necessary privileges. Never run production applications with superuser credentials.
* Lack of Database Documentation: Without a central registry of what each database is for, who owns it, and which application connects to it, the output of `psql show all db` becomes just a list of names with little practical meaning.
* Prevention: Maintain a database inventory alongside your server documentation. This should include purpose, associated applications, owner contact, and a retention policy.
* Neglecting Database Sizing and Growth Monitoring: Not actively tracking the size of databases means you’re flying blind regarding disk space utilization. A sudden spike in an unknown database’s size could indicate a runaway log, an unoptimized query, or malicious activity.
* Prevention: Incorporate `pg_database_size()` into your monitoring scripts and set alerts for unusual growth. Review `psql show all db` output with an eye on the `Size` column regularly.

When This Hosting Solution Is Not the Right Choice

The utility of `psql show all db` is primarily for direct management of a PostgreSQL instance you control, whether on a VPS, dedicated server, or even certain IaaS cloud offerings. However, relying solely on insights from this command might not be the “right choice” or sufficient in specific hosting scenarios or for certain management tasks:

* **Managed Database Services (DBaaS):** When using a fully managed service like Amazon RDS, Google Cloud SQL, or Azure Database for PostgreSQL, you often don’t have direct operating system access or superuser privileges needed to run `psql` in the traditional sense, or the command might be restricted. These services typically abstract away the underlying server, providing their own management consoles and APIs to list, create, and manage databases. While you *can* connect with `psql` as a regular user, the command `\l` might show only the databases you own, and the platform handles the underlying provisioning. In such cases, the hosting provider’s dashboard is your primary tool, not `psql show all db`.
* **Object-Level Management Within a Single Database:** If your challenge is managing tables, functions, or permissions *within* a specific database (e.g., dealing with schema sprawl in a multi-tenant setup or optimizing a single application’s database), `psql show all db` merely points you to the database. It doesn’t offer insights into the internal structure. For these tasks, you’d use `\dt` (list tables), `\df` (list functions), `\dn` (list schemas), and more specific SQL queries on `pg_catalog` views.
* **High-Level Application Orchestration:** For complex application environments managed by container orchestration tools (like Kubernetes) where databases are dynamically provisioned and de-provisioned, `psql show all db` is a low-level check. The higher-level orchestrator’s state (e.g., `kubectl get deployments`) or a service mesh’s view might be more relevant for understanding the overall application landscape, even if `psql show all db` could verify individual database instances.
* **Performance Bottlenecks Beyond Database Count:** While too many databases can impact performance, `psql show all db` won’t tell you *why* your single, critical database is slow. This command isn’t a performance tuning tool. For that, you need `pg_stat_statements`, `EXPLAIN ANALYZE`, monitoring tools for CPU/IOPS, and careful query optimization.

In essence, `psql show all db` is an excellent diagnostic and inventory tool for direct database instance management. It’s a foundational step. However, it’s not a silver bullet for all database challenges, especially when you’re working with highly abstracted services or need deeper internal database insights.

Practical Recommendations for Optimal Database Management

Effective management of PostgreSQL databases on any hosting solution, from a cost-effective VPS to a high-performance Dedicated Server, hinges on proactive measures and clear policies.

1. Regular Database Inventory Audits: Make `psql show all db` a routine command in your operational playbook. Schedule quarterly or monthly audits where you review the output against your documented database inventory. Identify any undocumented databases, investigate their purpose, and either document them or decommission them. This is crucial for maintaining a clean and secure environment.
2. Implement Strict Naming Conventions: From the outset, establish a clear, descriptive naming convention for all new databases. This should ideally include project identifiers, environment indicators (e.g., `prod`, `dev`, `staging`), and perhaps a version or owner. For instance, instead of `my_app_db`, use `projectx_prod_main_db`. This clarity is invaluable for operations, especially when managing many databases.
3. Enforce Principle of Least Privilege (PoLP): Never use a superuser account for application connections. Create specific database roles for each application or service and grant only the absolute minimum permissions required. This significantly limits the blast radius in case of a security compromise. Regularly review these permissions.
4. Integrate Database Monitoring: Beyond just listing databases, monitor their performance and growth. Use tools like `pg_stat_statements` to identify slow queries, and track disk usage (`pg_database_size`) to anticipate capacity needs. Many Premium Hosting solutions offer integrated monitoring dashboards that can help visualize these metrics over time, making it easier to spot anomalies.
5. Automate Backup and Recovery Procedures: Ensure all active databases have robust, tested backup and recovery strategies. Regularly verify that backups are actually working and can be restored. Consider different backup types (e.g., full, incremental, point-in-time recovery) based on your data criticality and recovery point objectives (RPO).
6. Define Database Lifecycle Policies: Establish clear guidelines for when databases are created, when they are moved between environments (dev to staging to prod), and when they are decommissioned. This prevents the accumulation of stale, unsecured databases.
7. Leverage Schemas for Multi-Tenancy (If Applicable): If adopting a consolidated database strategy, use PostgreSQL schemas to logically separate data for different applications or tenants within a single database. This offers a good balance between isolation and resource efficiency, which is particularly beneficial for high-density environments on a Netherlands VPS.
8. Educate Development Teams: Ensure your developers understand the operational implications of database creation and management. Foster a culture of clean-up and responsible resource use, helping them understand why `psql show all db` is a critical administrative tool.

These recommendations, when consistently applied, transform `psql show all db` from a simple command into a cornerstone of a robust, secure, and efficient PostgreSQL management strategy within any hosted environment.

Frequently Asked Questions

What is the difference between `\l` and `psql show all db`?

There is no practical difference in functionality. `\l` is a shorthand meta-command within the `psql` interactive terminal that performs the exact same action as typing out `\list` or mentally equating it to a `show all db` concept. Both display a list of all databases on the connected PostgreSQL server.

Can `psql show all db` tell me if a database is currently in use?

The standard `\l` output itself doesn’t directly show real-time activity. However, you can use `psql show all db` as a first step, then combine it with a query to the `pg_stat_activity` view to see current connections to each database. For example, `SELECT datname, COUNT(*) FROM pg_stat_activity GROUP BY datname;` would show you how many active connections each database has.

How can I find the owner of a specific database listed by `psql show all db`?

The output of `\l` already includes an “Owner” column, which directly shows the PostgreSQL role that owns each database. If you need more details about that role, you can then use `\du` (list roles) or query `pg_roles`.

I see databases like `template0` and `template1` when I use `psql show all db`. What are these?

These are special PostgreSQL system databases. `template1` is the default template from which new databases are created, and `template0` is a “clean” template that should never be modified. They are essential for PostgreSQL’s internal operations and should not be deleted or modified by users. Their presence is normal and expected.

Can I use `psql show all db` to identify databases that are taking up the most disk space?

Yes. The basic `\l` command shows a “Size” column, which gives an approximate size. For more precise and human-readable sizes, use `\l+`. For the most accurate and sortable results, run the SQL query: `SELECT datname, pg_size_pretty(pg_database_size(datname)) FROM pg_database ORDER BY pg_database_size(datname) DESC;` directly in your `psql` session after connecting.

What if I don’t have permission to use `psql show all db`?

If you connect to a PostgreSQL instance and receive a permission denied error when trying to use `\l` or `\list`, it means your connected user role does not have the necessary privileges to view all databases. Typically, only superusers or roles with `CREATEDB` privilege can see all databases. You would need to contact your database administrator or hosting provider to either grant your user appropriate permissions or provide you with credentials for a privileged user.

Next Steps for Better Database Visibility

Gaining clarity on your PostgreSQL database landscape with `psql show all db` is just the beginning. The real value comes from leveraging that visibility to take informed action. Start by running this command on your hosted PostgreSQL instance today. Compare the output against your known applications and services. Identify any discrepancies, forgotten test environments, or databases with unclear ownership.

Once you have this inventory, prioritize. Clean up unused databases, enforce stricter naming conventions for new ones, and audit user permissions. Consider integrating your findings into a broader database management strategy that includes regular monitoring and lifecycle policies. This proactive approach will not only enhance the performance and security of your applications but also optimize your hosting resources, whether you’re on a flexible VPS or a powerful dedicated server. Take control of your data infrastructure – your operations and your bottom line will thank you for it.

Effective PostgreSQL Database Management for Hosted Applications: Unveiling Your Data with `psql show all db`