diff --git a/.github/postgres/docker-compose.yaml b/.github/postgres/docker-compose.yaml
index ed6dcb2631..cc08edbe4d 100644
--- a/.github/postgres/docker-compose.yaml
+++ b/.github/postgres/docker-compose.yaml
@@ -21,3 +21,15 @@ services:
       - autovacuum_vacuum_cost_delay=10
       - -c
       - max_locks_per_transaction=72
+      - -c
+      - shared_preload_libraries=pg_stat_statements
+      - -c
+      - pg_stat_statements.max=2000
+      - -c
+      - pg_stat_statements.save=off
+      - -c
+      - pg_stat_statements.track_utility=off
+      - -c
+      - track_activity_query_size=2048
+      - -c
+      - track_functions=pl
diff --git a/koku/masu/api/db_performance/db_performance.py b/koku/masu/api/db_performance/db_performance.py
index f68da2f6c9..cc644596b5 100644
--- a/koku/masu/api/db_performance/db_performance.py
+++ b/koku/masu/api/db_performance/db_performance.py
@@ -27,13 +27,13 @@
 
 
 class DBPerformanceStats:
-    def __init__(self, username, configurator, application_name="database_performance_stats", database_ranking=[]):
+    def __init__(self, username, configurator, application_name="database_performance_stats"):
         self.conn = None
         self.username = username
         self.config = configurator
+        self.app_db_name = configurator.get_database_name()
         self.application_name = application_name
         self.read_only = True
-        self.database_ranking = database_ranking
         self._connect()
 
     def __enter__(self):
@@ -90,24 +90,17 @@ def _execute(self, sql, params=None):
     def _prep_log_message(self, message):
         return f"USER:{self.username} {message}"
 
-    def _case_db_ordering_clause(self, database_name_col):
-        if not self.database_ranking:
-            return ("", {})
-
-        params = {}
-        case = [f"case {database_name_col}"]
-        for ix, dbname in enumerate(self.database_ranking):
-            ix_str = str(ix)
-            dbval_key = f"db_val_{ix_str}"
-            dbrank_key = f"db_rank_{ix_str}"
-            params[dbval_key] = dbname
-            params[dbrank_key] = ix_str
-            case.append(f"     when %({dbval_key})s then %({dbrank_key})s")
-        case.append("     else %(def_case_val)s")
-        params["def_case_val"] = str(len(self.database_ranking))
-        case.append(f"end::text || {database_name_col}")
-
-        return (" ".join(case), params)
+    def get_databases(self):
+        sql = """
+select oid,
+       datname
+  from pg_database
+ where datname !~ '^template'
+ order
+    by datname
+;
+"""
+        return self._execute(sql).fetchall()
 
     def get_pg_settings(self, setting_names=None):
         params = {}
@@ -201,7 +194,7 @@ def _validate_pg_stat_statements(self):
         ext_version = extn["extversion"] if ext_exists else None
         return (ext_exists, ext_version)
 
-    def get_statement_stats(self, limit=500, offset=None, records_per_db=100):
+    def get_statement_stats(self, dbname, limit=100, offset=None):
         params = {}
 
         has_pss, pss_ver = self._validate_pg_stat_statements()
@@ -211,51 +204,30 @@ def get_statement_stats(self, limit=500, offset=None, records_per_db=100):
         limit_clause = self._handle_limit(limit, params)
         offset_clause = self._handle_offset(offset, params)
         col_name_sep = "_" if Decimal(pss_ver) < Decimal("1.8") else "_exec_"
-        rank_case, rank_params = self._case_db_ordering_clause("d.datname")
-        partition = f"partition by {rank_case}" if rank_case else ""
-        params.update(rank_params)
-        params["records_per_db"] = records_per_db
+        params["dbname"] = dbname
         sql = f"""
 -- STATEMENT STATISTICS
-select "dbname",
-       "user",
-       calls,
-       rows,
-       min_exec_time,
-       mean_exec_time,
-       max_exec_time,
-       shared_blks_hit,
-       shared_blks_read,
-       local_blks_hit,
-       local_blks_read,
-       temp_blks_read,
-       temp_blks_written,
-       query
-  from (
-         select row_number() over ({partition}) as "rec_by_db",
-                d.datname as "dbname",
-                r.rolname as "user",
-                s.calls,
-                s.rows,
-                s.min{col_name_sep}time as min_exec_time,
-                s.mean{col_name_sep}time as mean_exec_time,
-                s.max{col_name_sep}time as max_exec_time,
-                s.shared_blks_hit,
-                s.shared_blks_read,
-                s.local_blks_hit,
-                s.local_blks_read,
-                s.temp_blks_read,
-                s.temp_blks_written,
-                s.query
-            from public.pg_stat_statements s
-            join pg_database d
-              on d.oid = s.dbid
-            join pg_roles r
-              on r.oid = s.userid
-          where s.dbid is not null
-            and s.userid is not null
-       ) enumerated_query_stats
-where "rec_by_db" <= %(records_per_db)s
+select d.datname as "dbname",
+       r.rolname as "user",
+       s.calls,
+       s.rows,
+       s.min{col_name_sep}time as min_exec_time,
+       s.mean{col_name_sep}time as mean_exec_time,
+       s.max{col_name_sep}time as max_exec_time,
+       s.shared_blks_hit,
+       s.shared_blks_read,
+       s.local_blks_hit,
+       s.local_blks_read,
+       s.temp_blks_read,
+       s.temp_blks_written,
+       s.query
+  from public.pg_stat_statements s
+  join pg_database d
+    on d.oid = s.dbid
+  join pg_roles r
+    on r.oid = s.userid
+ where d.datname = %(dbname)s
+   and s.userid is not null
  {limit_clause}
  {offset_clause}
 ;
@@ -263,13 +235,15 @@ def get_statement_stats(self, limit=500, offset=None, records_per_db=100):
         LOG.info(self._prep_log_message("requesting data from pg_stat_statements"))
         return self._execute(sql, params).fetchall()
 
-    def get_lock_info(self, limit=500, offset=None):
+    def get_lock_info(self, dbname, limit=25, offset=None):
         params = {}
         limit_clause = self._handle_limit(limit, params)
         offset_clause = self._handle_offset(offset, params)
+        params["dbname"] = dbname
         sql = f"""
 -- LOCK INFO QUERY
-SELECT blocking_locks.pid::int     AS blocking_pid,
+SELECT count(blocking_locks.pid) over (partition by blocking_locks.pid) as blocking_pid_weight,
+       blocking_locks.pid::int     AS blocking_pid,
        blocking_activity.usename::text AS blocking_user,
        blocked_locks.pid::int     AS blocked_pid,
        blocked_activity.usename::text  AS blocked_user,
@@ -293,6 +267,10 @@ def get_lock_info(self, limit=500, offset=None):
   JOIN pg_catalog.pg_stat_activity blocking_activity
     ON blocking_activity.pid = blocking_locks.pid
  WHERE NOT blocked_locks.granted
+   AND blocking_activity.datname = %(dbname)s
+ ORDER
+    BY "blocking_pid_weight" desc,
+       blocking_locks.pid
 {limit_clause}
 {offset_clause}
 ;
@@ -302,63 +280,41 @@ def get_lock_info(self, limit=500, offset=None):
 
         return res
 
-    def get_activity(self, pid=[], state=[], include_self=False, limit=500, offset=None, records_per_db=100):
+    def get_activity(self, dbname, pid=[], state=[], limit=100, offset=None):
         params = {}
 
-        conditions = ["datname is not null", "usename is not null"]
+        params["dbname"] = dbname
+        conditions = ["datname = %(dbname)s", "usename is not null"]
         if pid:
-            include_self = True
+            if not isinstance(pid, list):
+                pid = [pid]
             conditions.append("pid = any(%(pid)s::oid[]) ")
             params["pid"] = pid
         if state:
+            if not isinstance(state, list):
+                state = [state]
             conditions.append("state = any(%(state)s::text[]) ")
             params["state"] = state
-        if not include_self:
-            conditions.append("pid != %(mypid)s ")
-            params["mypid"] = self.conn.get_backend_pid()
-        where_clause = f"          where {f'{os.linesep}            and '.join(conditions)}"
+        where_clause = f" where {f'{os.linesep}   and '.join(conditions)}"
         limit_clause = self._handle_limit(limit, params)
         offset_clause = self._handle_offset(offset, params)
-        rank_case, rank_params = self._case_db_ordering_clause("datname")
-        rank_sep = "," if rank_case else ""
-        params.update(rank_params)
-        params["records_per_db"] = records_per_db
         sql = f"""
 -- CONNECTION ACTIVITY QUERY
-select "dbname",
-       "user",
-       "backend_pid",
-       "app_name",
-       "client_ip",
+select datname as "dbname",
+       usename as "user",
+       pid as "backend_pid",
+       application_name as "app_name",
+       client_addr as "client_ip",
        backend_start,
        xact_start,
        query_start,
        state_change,
-       "wait_type_event",
+       '('::text || wait_event_type || ') '::text || wait_event as "wait_type_event",
        state,
-       "active_time",
+       case when state = 'active' then now() - query_start else null end::text as "active_time",
        query
-  from (
-         select row_number() over (partition by case state when 'active' then '0' when 'idle in transaction' then '1' else '2' end::text || state{rank_sep}
-                                                {rank_case}
-                                   order by coalesce(extract(epoch from now() - query_start), 0) desc) as "rec_by_db",
-             datname as "dbname",
-             usename as "user",
-             pid as "backend_pid",
-             application_name as "app_name",
-             client_addr as "client_ip",
-             backend_start,
-             xact_start,
-             query_start,
-             state_change,
-             '('::text || wait_event_type || ') '::text || wait_event as "wait_type_event",
-             state,
-             case when state = 'active' then now() - query_start else null end::text as "active_time",
-             query
-         from pg_stat_activity
-         {where_clause}
-       ) enumerated_stats
- where rec_by_db <= %(records_per_db)s
+  from pg_stat_activity
+{where_clause}
 {limit_clause}
 {offset_clause}
 ;
@@ -392,6 +348,65 @@ def explain_sql(self, raw_sql):
 
         return res
 
+    def get_schema_sizes(self, top=0, limit=100, offset=None):
+        # This will ONLY run against the primary app database at this time.
+        params = {"db_gb": Decimal(1024**3), "top": top}
+        limit_clause = self._handle_limit(limit, params)
+        offset_clause = self._handle_offset(offset, params)
+        if top > 0:
+            LOG.debug(f"Getting schema size and top {top} tables")
+            sql = f"""
+select schema_name,
+       table_name,
+       round(table_size::numeric / %(db_gb)s::numeric, 10) as "table_size_gb",
+       round(schema_size::numeric / %(db_gb)s::numeric, 10) as "schema_size_gb"
+  from (
+           select row_number() over (partition by n.oid order by pg_total_relation_size(t.oid) desc) as rownum,
+                  n.nspname as "schema_name",
+                  t.relname as "table_name",
+                  pg_total_relation_size(t.oid) as "table_size",
+                  sum(pg_total_relation_size(t.oid)) over (partition by n.nspname) as "schema_size"
+             from pg_namespace n
+             join pg_class t
+               on t.relnamespace = n.oid
+              and t.relkind in ('r', 'p')
+            where n.nspname not in ('pg_catalog','information_schema')
+       ) as raw_object_sizes
+ where "rownum" <= %(top)s
+ order
+    by "schema_size_gb" desc,
+       schema_name,
+       "table_size_gb" desc,
+       table_name
+{limit_clause}
+{offset_clause}
+;
+"""
+        else:
+            LOG.debug("Getting schema size only")
+            sql = f"""
+select schema_name,
+       round(schema_size::numeric / %(db_gb)s::numeric, 10) as "schema_size_gb"
+  from (
+           select n.nspname as "schema_name",
+                  sum(pg_total_relation_size(t.oid)) as schema_size
+             from pg_namespace n
+             join pg_class t
+               on t.relnamespace = n.oid
+              and t.relkind in ('r', 'p')
+            where n.nspname not in ('pg_catalog','information_schema')
+            group
+               by n.nspname
+       ) as raw_object_sizes
+ order
+    by "schema_size_gb" desc,
+       schema_name
+{limit_clause}
+{offset_clause}
+;
+"""
+        return self._execute(sql, params).fetchall()
+
     #     def terminate_cancel_backends(self, backends=[], action_type=None):
     #         if not backends:
     #             return None
diff --git a/koku/masu/api/db_performance/dbp_views.py b/koku/masu/api/db_performance/dbp_views.py
index 7b45cdad9b..37e209194a 100644
--- a/koku/masu/api/db_performance/dbp_views.py
+++ b/koku/masu/api/db_performance/dbp_views.py
@@ -5,7 +5,9 @@
 import json
 import logging
 import os
+import threading
 from decimal import Decimal
+from urllib.parse import urlencode
 
 from django.http import HttpResponse
 from django.shortcuts import redirect
@@ -29,17 +31,30 @@
 MY_PATH = os.path.dirname(os.path.abspath(__file__))
 TEMPLATE_PATH = os.path.join(MY_PATH, "templates")
 
-DATABASE_RANKING = [CONFIGURATOR.get_database_name()]
+DBNAME_LOCK = threading.Lock()
+APPLICATION_DBNAME = CONFIGURATOR.get_database_name()
+ALL_DATABASES = []
 
 # CANCEL_URL = 0
 # TERMINATE_URL = 1
 
 
+def get_database_list(dbps):
+    with DBNAME_LOCK:
+        if not ALL_DATABASES:
+            ALL_DATABASES.append(APPLICATION_DBNAME)
+            for rec in dbps.get_databases():
+                if rec["datname"] != APPLICATION_DBNAME:
+                    ALL_DATABASES.append(rec["datname"])
+
+    return ALL_DATABASES
+
+
 def get_limit_offset(request):
     try:
-        limit = int(request.query_params.get("limit", "500"))
+        limit = int(request.query_params.get("limit", "100"))
     except (TypeError, ValueError):
-        limit = 500
+        limit = 100
 
     try:
         offset = int(request.query_params.get("offset"))
@@ -49,6 +64,10 @@ def get_limit_offset(request):
     return limit, offset
 
 
+def get_selected_db(request):
+    return request.query_params.get("dbname", CONFIGURATOR.get_database_name())
+
+
 def get_parameter_list(request, param_name, default=None, sep=","):
     qp = request.query_params
 
@@ -87,6 +106,7 @@ def get_menu(curr_url_name):
         ("conn_activity", "Connection Activity"),
         ("stmt_stats", "Statement Statistics"),
         ("lock_info", "Lock Information"),
+        ("schema_sizes", "Schema Sizes"),
         ("explain_query", "Explain Query"),
     )
     menu_elements = ['<ul id="menu-list" class="menu unselectable">']
@@ -103,7 +123,17 @@ def get_menu(curr_url_name):
     return os.linesep.join(menu_elements)
 
 
-def render_template(url_name, page_header, fields, data, targets=(), template="gen_table.html", action_urls=[]):
+def render_template(
+    url_name,
+    page_header,
+    fields,
+    data,
+    targets=(),
+    template="gen_table.html",
+    action_urls=[],
+    db_select=None,
+    pagination=None,
+):
     menu = get_menu(url_name)
     tmpl = JinjaTemplate(open(os.path.join(TEMPLATE_PATH, template)).read())
     return tmpl.render(
@@ -113,6 +143,8 @@ def render_template(url_name, page_header, fields, data, targets=(), template="g
         data=data,
         targets=targets,
         action_urls=action_urls,
+        db_select=db_select,
+        pagination=pagination,
     )
 
 
@@ -128,6 +160,44 @@ def get_identity_username(request):
     return "koku-user"
 
 
+def make_db_options(databases, selected_db, request, target):
+    jsnippet = """onchange="select_db(this)" """
+    params = request.query_params.dict()
+    path = reverse(target)
+    buff = [f'<select name="dbname" {jsnippet}>']
+    for db in databases:
+        params["dbname"] = db
+        url = f"{path}?{urlencode(params)}"
+        sel = "selected" if db == selected_db else ""
+        buff.append(f'    <option value="{url}" {sel}>{db}</option>')
+    buff.append("</select>")
+    return os.linesep.join(buff)
+
+
+def make_pagination(limit, offset, data, request, target):
+    offset = offset or 0
+    diff = abs(limit - offset)
+    links = []
+    if offset <= 0:
+        links.append("<span>Prev</span>")
+    else:
+        _prev = request.query_params.dict()
+        _prev["limit"] = limit - diff
+        _prev["offset"] = offset - diff
+        url = f"{reverse(target)}?{urlencode(_prev)}"
+        links.append(f"""<a href="{url}">&lt;&lt; Prev</a>""")
+    if len(data) >= diff:
+        _next = request.query_params.dict()
+        _next["limit"] = limit + diff
+        _next["offset"] = offset + diff
+        url = f"{reverse(target)}?{urlencode(_next)}"
+        links.append(f"""<a href="{url}">Next &gt;&gt;</a>""")
+    else:
+        links.append("<span>Next</span>")
+
+    return "<span> | </span>".join(links)
+
+
 @never_cache
 @api_view(http_method_names=["GET"])
 @permission_classes((AllowAny,))
@@ -142,10 +212,14 @@ def lockinfo(request):
     """Get any blocked and blocking process data"""
 
     limit, offset = get_limit_offset(request)
+    selected_db = get_selected_db(request)
     data = None
+    databases = None
     with DBPerformanceStats(get_identity_username(request), CONFIGURATOR) as dbp:
-        data = dbp.get_lock_info(limit=limit, offset=offset)
+        databases = get_database_list(dbp)
+        data = dbp.get_lock_info(selected_db, limit=limit, offset=offset)
 
+    pagination = make_pagination(limit, offset, data, request, "lock_info")
     if not data:
         data = [{"Result": "No blocking locks"}]
 
@@ -176,7 +250,7 @@ def lockinfo(request):
                 "blocking_pid": 'class="sans"',
                 "blocked_pid": 'class="sans"',
             }
-            activity_url = f'{reverse("conn_activity")}?pids={rec["blocking_pid"]},{rec["blocked_pid"]}'
+            activity_url = f'{reverse("conn_activity")}?pid={rec["blocking_pid"]}&pid={rec["blocked_pid"]}'
             for t in targets:
                 rec[f"_raw_{t}"] = rec[t]
             if template != "gen_table.html":
@@ -198,6 +272,7 @@ def lockinfo(request):
             )
 
     page_header = "Lock Information"
+    db_options = make_db_options(databases, selected_db, request, "lock_info")
     return HttpResponse(
         render_template(
             "lock_info",
@@ -206,6 +281,8 @@ def lockinfo(request):
             data,
             targets=targets,
             template=template,
+            db_select=db_options,
+            pagination=pagination,
             # action_urls=action_urls,
         )
     )
@@ -221,12 +298,15 @@ def stat_statements(request):
     query_bad_threshold = Decimal("5000")
     query_warn_threshold = Decimal("2500")
     limit, offset = get_limit_offset(request)
+    selected_db = get_selected_db(request)
 
-    with DBPerformanceStats(get_identity_username(request), CONFIGURATOR, database_ranking=DATABASE_RANKING) as dbp:
-        data = dbp.get_statement_stats(limit=limit, offset=offset)
+    with DBPerformanceStats(get_identity_username(request), CONFIGURATOR) as dbp:
+        databases = get_database_list(dbp)
+        data = dbp.get_statement_stats(selected_db, limit=limit, offset=offset)
 
+    pagination = make_pagination(limit, offset, data, request, "stmt_stats")
     action_urls = []
-    if "mean_exec_time" in data[0]:
+    if data and "mean_exec_time" in data[0]:
         for rec in data:
             set_null_display(rec)
             rec["_attrs"] = {"query": 'class="pre monospace"'}
@@ -242,8 +322,11 @@ def stat_statements(request):
                 rec["_attrs"][col] = " ".join(attrs)
 
         # action_urls.append(reverse("stat_statements_reset"))
+    else:
+        data = [{"Result": "No data matching the criteria"}]
 
     page_header = "Statement Statistics"
+    db_options = make_db_options(databases, selected_db, request, "stmt_stats")
     return HttpResponse(
         render_template(
             "stmt_stats",
@@ -252,6 +335,8 @@ def stat_statements(request):
             data,
             template="stats_table.html",
             action_urls=action_urls,
+            db_select=db_options,
+            pagination=pagination,
         )
     )
 
@@ -275,56 +360,60 @@ def stat_activity(request):
     template = "t_action_table.html"
     states = get_parameter_list(request, "state", default=[])
     pids = get_parameter_list(request, "pid", default=[])
-    include_self = get_parameter_bool(request, "include_self", False)
-    records_per_db = int(request.query_params.get("records_per_db", "100"))
     limit, offset = get_limit_offset(request)
+    selected_db = get_selected_db(request)
 
     data = None
-    with DBPerformanceStats(get_identity_username(request), CONFIGURATOR, database_ranking=DATABASE_RANKING) as dbp:
+    with DBPerformanceStats(get_identity_username(request), CONFIGURATOR) as dbp:
+        databases = get_database_list(dbp)
         data = dbp.get_activity(
+            selected_db,
             pid=pids,
             state=states,
-            include_self=include_self,
             limit=limit,
             offset=offset,
-            records_per_db=records_per_db,
         )
+
+    pagination = make_pagination(limit, offset, data, request, "conn_activity")
     if not data:
         data = [{"Response": "No data matching the criteria"}]
         targets = ()
     else:
         targets = ("backend_pid",)
+        rec_attrs = {
+            "query": 'class="pre monospace"',
+            "state": 'class="monospace"',
+            "backend_pid": 'class="sans"',
+            "client_ip": 'class="sans"',
+            "backend_start": 'class="sans"',
+            "xact_start": 'class="sans"',
+            "query_start": 'class="sans"',
+            "state_change": 'class="sans"',
+            "active_time": 'class="sans"',
+            "wait_type_event": 'class="sans"',
+        }
         for rec in data:
             set_null_display(rec)
             rec["_raw_backend_pid"] = rec["backend_pid"]
-            rec["_attrs"] = {
-                "query": 'class="pre monospace"',
-                "state": 'class="monospace"',
-                "backend_pid": 'class="sans"',
-                "client_ip": 'class="sans"',
-                "backend_start": 'class="sans"',
-                "xact_start": 'class="sans"',
-                "query_start": 'class="sans"',
-                "state_change": 'class="sans"',
-                "active_time": 'class="sans"',
-                "wait_type_event": 'class="sans"',
-            }
+            rec["_attrs"] = rec_attrs
             rec["query"] = format_sql(rec["query"], reindent=True, indent_realigned=True, keyword_case="upper")
 
     fields = tuple(f for f in data[0] if not f.startswith("_")) if data else ()
 
     page_header = "Connection Activity"
+    db_options = make_db_options(databases, selected_db, request, "conn_activity")
     return HttpResponse(
-        render_template("conn_activity", page_header, fields, data, targets=targets, template=template)
-        # render_template(
-        #     "conn_activity",
-        #     page_header,
-        #     fields,
-        #     data,
-        #     targets=("backend_pid",),
-        #     template=template,
-        #     action_urls=action_urls
-        # )
+        render_template(
+            "conn_activity",
+            page_header,
+            fields,
+            data,
+            targets=targets,
+            template=template,
+            db_select=db_options,
+            pagination=pagination,
+            # action_urls=action_urls,
+        )
     )
 
 
@@ -342,6 +431,7 @@ def dbsettings(request):
         set_null_display(rec)
 
         rec["_attrs"] = {
+            "category": 'style="font-weight: bold;"',
             "name": 'class="monospace"',
             "unit": 'class="monospace"',
             "setting": 'class="monospace"',
@@ -406,3 +496,41 @@ def explain_query(request):
                 data = {"query_plan": (os.linesep * 3).join(all_plans)}
 
         return Response(data)
+
+
+@never_cache
+@api_view(http_method_names=["GET"])
+@permission_classes((AllowAny,))
+def schema_sizes(request):
+    """Get any blocked and blocking process data"""
+
+    limit, offset = get_limit_offset(request)
+    top = int(request.query_params.get("top", "0"))
+    if top > limit:
+        top = limit
+    data = None
+    with DBPerformanceStats(get_identity_username(request), CONFIGURATOR) as dbp:
+        data = dbp.get_schema_sizes(top=top, limit=limit, offset=offset)
+
+    pagination = make_pagination(limit, offset, data, request, "schema_sizes")
+    for rec in data:
+        set_null_display(rec)
+
+        rec["_attrs"] = {
+            "schema_name": 'class="monospace"',
+            "table_name": 'class="monospace"',
+            "table_size_gb": 'class="sans"',
+            "schema_size_gb": 'class="sans"',
+        }
+
+    table_header = "and Top {top} Table " if top else ""
+    page_header = f'Schema {table_header}Sizes for Database "{APPLICATION_DBNAME}"'
+    return HttpResponse(
+        render_template(
+            "schema_sizes",
+            page_header,
+            tuple(f for f in data[0] if not f.startswith("_")) if data else (),
+            data,
+            pagination=pagination,
+        )
+    )
diff --git a/koku/masu/api/db_performance/templates/gen_table.html b/koku/masu/api/db_performance/templates/gen_table.html
index 56492dcea4..1d4d543928 100644
--- a/koku/masu/api/db_performance/templates/gen_table.html
+++ b/koku/masu/api/db_performance/templates/gen_table.html
@@ -72,6 +72,12 @@
                 user-select: none;
             }
         </style>
+        <script>
+
+            function select_db(db_sel) {
+                location = db_sel.value;
+            }
+        </script>
     </head>
     <body>
         <div id="header-container" class="container unselectable">
@@ -82,6 +88,20 @@
         </div>
         <hr />
         <h2 id="data_header">{{page_header}}</h2>
+        <div id="controls" style="display: block; clear: both;">
+{% if db_select %}
+            <div id="dbseldiv" style="float: left;">
+                <b>Database: </b>
+                {{db_select}}
+            </div>
+{% endif %}
+{% if pagination %}
+            <div id="pagination" style="float: right;">
+                {{pagination}}
+            </div>
+{% endif %}
+        </div>
+        <div id="tablediv" style="display: block; clear: both;">
         <table id="generic_table" cellspacing="0">
 {% for rec in data %}
     {% if loop.first %}
@@ -106,5 +126,6 @@ <h2 id="data_header">{{page_header}}</h2>
     {% endif %}
 {% endfor %}
         </table>
+        </div>
     </body>
 </html>
diff --git a/koku/masu/api/db_performance/templates/stats_table.html b/koku/masu/api/db_performance/templates/stats_table.html
index 91de7c6ac0..2c97a78cab 100644
--- a/koku/masu/api/db_performance/templates/stats_table.html
+++ b/koku/masu/api/db_performance/templates/stats_table.html
@@ -75,21 +75,27 @@
                 user-select: none;
             }
         </style>
-        <!-- <script>
-function clear_stmt_stats() {
-    document.getElementById("clear-stats-btn").disabled = true;
-    if (window.confirm("Reset and clear statement statistics?\nThis cannot be undone.")) {
-        xhttp = new XMLHttpRequest();
-        xhttp.open("GET", "{{action_urls[0]}}", false);
-        xhttp.send();
-        if (xhttp.status != 200) {
-            window.alert("Request failed: " + xhttp.statusText + " (" + xhttp.status + ")");
-        }
-        location.reload();
-    }
-}
+        <script>
+
+            function select_db(db_sel) {
+                location = db_sel.value;
+            }
+
+            // function clear_stmt_stats() {
+            //     document.getElementById("clear-stats-btn").disabled = true;
+            //     if (window.confirm("Reset and clear statement statistics?\nThis cannot be undone.")) {
+            //         xhttp = new XMLHttpRequest();
+            //         xhttp.open("GET", "{{action_urls[0]}}", false);
+            //         xhttp.send();
+            //         if (xhttp.status != 200) {
+            //             window.alert("Request failed: " + xhttp.statusText + " (" + xhttp.status + ")");
+            //         }
+            //         location.reload();
+            //     }
+            // }
+
         </script>
-    </head> -->
+    </head>
     <body>
         <div id="header-container" class="container unselectable">
             <div id="header-div" class="header1 unselectable" style="display: inline-block !important;">Database Performance</div>
@@ -99,8 +105,22 @@
         </div>
         <hr />
         <h2 id="data_header">{{page_header}}</h2>
+        <div id="controls" class="unselectable" style="display: block; clear: both;">
+{% if db_select %}
+            <div id="dbseldiv" style="float: left;">
+                <b>Database: </b>
+                {{db_select}}
+            </div>
+{% endif %}
+{% if pagination %}
+            <div id="pagination" style="float: right;">
+                {{pagination}}
+            </div>
+{% endif %}
+        </div>
         <!-- <button class="clear-stats" id="clear-stats-btn" onclick="clear_stmt_stats();" disabled="true">Clear Statement Statistics</button> -->
-    <table id="stmt_stats_table" cellspacing="0">
+        <div id="tablediv" style="display: block; clear: both;"></div>
+        <table id="stmt_stats_table" cellspacing="0">
 {% for rec in data %}
     {% if loop.first %}
             <thead>
@@ -124,5 +144,6 @@ <h2 id="data_header">{{page_header}}</h2>
     {% endif %}
 {% endfor %}
         </table>
+    </div>
     </body>
 </html>
diff --git a/koku/masu/api/db_performance/templates/t_action_table.html b/koku/masu/api/db_performance/templates/t_action_table.html
index b531bb0093..463494c8c0 100644
--- a/koku/masu/api/db_performance/templates/t_action_table.html
+++ b/koku/masu/api/db_performance/templates/t_action_table.html
@@ -134,6 +134,10 @@
                 //     }
                 // }
             }
+
+            function select_db(db_sel) {
+                location = db_sel.value;
+            }
         </script>
     </head>
     <body>
@@ -145,6 +149,20 @@
         </div>
         <hr />
         <h2 id="data_header">{{page_header}}</h2>
+        <div id="controls" style="display: block; clear: both;">
+{% if db_select %}
+            <div id="dbseldiv" style="float: left;">
+                <b>Database: </b>
+                {{db_select}}
+            </div>
+{% endif %}
+{% if pagination %}
+            <div id="pagination" style="float: right;">
+                {{pagination}}
+            </div>
+{% endif %}
+        </div>
+        <div id="tablediv" style="display:block; clear: both;">
         <table id="term_action_table" cellspacing="0">
 {% for rec in data %}
     {% set rec_loop = loop %}
@@ -184,5 +202,6 @@ <h2 id="data_header">{{page_header}}</h2>
     {% endif %}
 {% endfor %}
         </table>
+        </div>
     </body>
 </html>
diff --git a/koku/masu/api/urls.py b/koku/masu/api/urls.py
index cd2ac47b2a..14765dd297 100644
--- a/koku/masu/api/urls.py
+++ b/koku/masu/api/urls.py
@@ -29,6 +29,7 @@
 from masu.api.views import purge_trino_files
 from masu.api.views import report_data
 from masu.api.views import running_celery_tasks
+from masu.api.views import schema_sizes
 from masu.api.views import stat_activity
 from masu.api.views import stat_statements
 from masu.api.views import trino_query
@@ -93,6 +94,7 @@
     path("db-performance/db-version/", pg_engine_version, name="db_version"),
     path("db-performance/explain-query/", explain_query, name="explain_query"),
     path("db-performance/db-version/", pg_engine_version, name="db_version"),
+    path("db-performance/schema-sizes/", schema_sizes, name="schema_sizes"),
 ]
 
 urlpatterns += ROUTER.urls
diff --git a/koku/masu/api/views.py b/koku/masu/api/views.py
index d9483b9c2a..0d1211a6f0 100644
--- a/koku/masu/api/views.py
+++ b/koku/masu/api/views.py
@@ -11,6 +11,7 @@
 from masu.api.db_performance.dbp_views import explain_query
 from masu.api.db_performance.dbp_views import lockinfo
 from masu.api.db_performance.dbp_views import pg_engine_version
+from masu.api.db_performance.dbp_views import schema_sizes
 from masu.api.db_performance.dbp_views import stat_activity
 from masu.api.db_performance.dbp_views import stat_statements
 from masu.api.download import download_report
diff --git a/koku/masu/openapi.json b/koku/masu/openapi.json
index 27089fda3b..c6be2733ea 100644
--- a/koku/masu/openapi.json
+++ b/koku/masu/openapi.json
@@ -1139,10 +1139,21 @@
           "operationId": "dbPerformanceStatStatements",
           "description": "Returns a HTML document showing query statement statistics if the pg_stat_statements extension has been installed.",
           "parameters": [
+            {
+              "name": "dbname",
+              "in": "query",
+              "description": "Specify a database in the cluster. Default is the application DB",
+              "required": false,
+              "schema": {
+                "type": "string",
+                "minlength": 4,
+                "maxlength": 100
+              }
+            },
             {
               "name": "limit",
               "in": "query",
-              "description": "Limit of the returned result set",
+              "description": "Limit of the returned result set. Default is 100",
               "required": false,
               "schema": {
                 "type": "integer",
@@ -1182,10 +1193,21 @@
           "operationId": "dbPerformanceStatActivity",
           "description": "Returns a HTML document showing current connection activity.",
           "parameters": [
-            {
+              {
+                "name": "dbname",
+                "in": "query",
+                "description": "Specify a database in the cluster. Default is the application DB",
+                "required": false,
+                "schema": {
+                  "type": "string",
+                  "minlength": 4,
+                  "maxlength": 100
+                }
+              },
+              {
               "name": "limit",
               "in": "query",
-              "description": "Limit of the returned result set. The default is 500.",
+              "description": "Limit of the returned result set. The default is 100.",
               "required": false,
               "schema": {
                 "type": "integer",
@@ -1229,20 +1251,54 @@
                     "type": "string"
                 }
               }
+            }
+          ],
+          "responses": {
+            "200": {
+              "description": "Returns a HTML document showing current connection activity.",
+              "content": {
+                "text/html": {}
+            }
+          }
+          },
+          "tags": [
+            "db-performance",
+            "stat-activity"
+          ]
+        }
+      },
+      "/db-performance/lock-info/": {
+        "get": {
+          "summary": "Returns a table showing any detected blocking locks.",
+          "operationId": "dbPerformanceLockInfo",
+          "description": "Returns a HTML document showing any blocking locks and processes that are blocked by them.",
+          "parameters": [
+            {
+              "name": "dbname",
+              "in": "query",
+              "description": "Specify a database in the cluster. Default is the application DB",
+              "required": false,
+              "schema": {
+                "type": "string",
+                "minlength": 4,
+                "maxlength": 100
+              }
             },
             {
-              "name": "include_self",
+              "name": "limit",
               "in": "query",
-              "description": "If true, include the pid of the connection running the DB Performance queries",
+              "description": "Limit of the returned result set. Default is 100",
               "required": false,
               "schema": {
-                "type": "boolean"
+                "type": "integer",
+                "format": "int32",
+                "minimum": 1
               }
             },
             {
-              "name": "records_per_db",
+              "name": "offset",
               "in": "query",
-              "description": "If there are multiple databases hosted by the engine, then how many records per db to include up to the limit. The default is 100.",
+              "description": "Offset into the query result set before returning records",
               "required": false,
               "schema": {
                 "type": "integer",
@@ -1253,7 +1309,7 @@
           ],
           "responses": {
             "200": {
-              "description": "Returns a HTML document showing current connection activity.",
+              "description": "Returns a HTML document showing any blocking locks and processes that are blocked by them.",
               "content": {
                 "text/html": {}
             }
@@ -1261,20 +1317,20 @@
           },
           "tags": [
             "db-performance",
-            "stat-activity"
+            "lock-info"
           ]
         }
       },
-      "/db-performance/lock-info/": {
+      "/db-performance/schema-sizes/": {
         "get": {
-          "summary": "Returns a table showing any detected blocking locks.",
-          "operationId": "dbPerformanceLockInfo",
-          "description": "Returns a HTML document showing any blocking locks and processes that are blocked by them.",
+          "summary": "Return a table listing dtabase schemata and the assiciated storage size.",
+          "operationId": "dbPerformanceSchemaSize",
+          "description": "Returns a HTML document showing schema sizes.",
           "parameters": [
             {
               "name": "limit",
               "in": "query",
-              "description": "Limit of the returned result set",
+              "description": "Limit of the returned result set. The default is 500.",
               "required": false,
               "schema": {
                 "type": "integer",
@@ -1285,18 +1341,29 @@
             {
               "name": "offset",
               "in": "query",
-              "description": "Offset into the query result set before returning records",
+              "description": "Offset into the query result set before returning records. The default is no offset.",
               "required": false,
               "schema": {
                 "type": "integer",
                 "format": "int32",
                 "minimum": 1
               }
+            },
+            {
+              "name": "top",
+              "in": "query",
+              "description": "Also include top n tables by storage size (if > 0). Default is zero",
+              "required": false,
+              "schema": {
+                "type": "integer",
+                "format": "int32",
+                "minimum": 0
+              }
             }
           ],
           "responses": {
             "200": {
-              "description": "Returns a HTML document showing any blocking locks and processes that are blocked by them.",
+              "description": "Returns a HTML document showing current connection activity.",
               "content": {
                 "text/html": {}
             }
@@ -1304,7 +1371,7 @@
           },
           "tags": [
             "db-performance",
-            "lock-info"
+            "stat-activity"
           ]
         }
       },
diff --git a/koku/masu/test/api/test_db_performance.py b/koku/masu/test/api/test_db_performance.py
index a46cdf8911..4c82cd5a1b 100644
--- a/koku/masu/test/api/test_db_performance.py
+++ b/koku/masu/test/api/test_db_performance.py
@@ -2,8 +2,6 @@
 # Copyright 2022 Red Hat Inc.
 # SPDX-License-Identifier: Apache-2.0
 #
-import os
-import re
 from unittest.mock import patch
 
 from django.db import connection
@@ -17,6 +15,16 @@
 from masu.api.db_performance.db_performance import SERVER_VERSION
 
 
+TEST_CONFIGURATOR = type("TEST_CONFIGURATOR", CONFIGURATOR.__bases__, dict(CONFIGURATOR.__dict__))
+
+
+def _get_database_name():
+    return "test_postgres"
+
+
+TEST_CONFIGURATOR.get_database_name = staticmethod(_get_database_name)
+
+
 class TestDBPerformanceClass(IamTestCase):
     @classmethod
     def setUpClass(cls):
@@ -113,60 +121,42 @@ def test_handle_offset(self):
             self.assertEqual(params, {"offset": 10})
 
     def test_handle_lockinfo(self):
-        with DBPerformanceStats("KOKU", CONFIGURATOR) as dbp:
-            lockinfo = dbp.get_lock_info()
+        with DBPerformanceStats("KOKU", TEST_CONFIGURATOR) as dbp:
+            lockinfo = dbp.get_lock_info(TEST_CONFIGURATOR.get_database_name())
             if lockinfo:
-                self.assertTrue(len(lockinfo) < 500)
+                self.assertTrue(len(lockinfo) <= 100)
 
-            lockinfo = dbp.get_lock_info(limit=1)
+            lockinfo = dbp.get_lock_info(TEST_CONFIGURATOR.get_database_name(), limit=1)
             if lockinfo:
-                self.assertTrue(len(lockinfo) < 1)
+                self.assertTrue(len(lockinfo) <= 1)
 
     def test_get_conn_activity(self):
         """Test that the correct connection activty is returned."""
-        with DBPerformanceStats("KOKU", CONFIGURATOR) as dbp:
+        with DBPerformanceStats("KOKU", TEST_CONFIGURATOR) as dbp:
             dbpid = dbp.conn.get_backend_pid()
-            activity = dbp.get_activity()
-            self.assertTrue(all(a["backend_pid"] != dbpid for a in activity))
-
-            activity = dbp.get_activity(include_self=True)
+            activity = dbp.get_activity(TEST_CONFIGURATOR.get_database_name())
             self.assertTrue(any(a["backend_pid"] == dbpid for a in activity))
 
-            activity = dbp.get_activity(include_self=True, pid=[dbpid])
-            self.assertTrue(all(a["backend_pid"] == dbpid for a in activity))
-
-            activity = dbp.get_activity(state=["COMPLETELY INVALID STATE HERE!"])
+            activity = dbp.get_activity(
+                TEST_CONFIGURATOR.get_database_name(), state=["COMPLETELY INVALID STATE HERE!"]
+            )
             self.assertEqual(activity, [])
 
     def test_get_stmt_stats(self):
         """Test that statement statistics are returned."""
-        with DBPerformanceStats("KOKU", CONFIGURATOR) as dbp:
+        with DBPerformanceStats("KOKU", TEST_CONFIGURATOR) as dbp:
             has_pss, pss_ver = dbp._validate_pg_stat_statements()
             if has_pss:
                 self.assertIsNotNone(pss_ver)
-                stats = dbp.get_statement_stats()
-                self.assertTrue(0 < len(stats) <= 500)
+                stats = dbp.get_statement_stats(TEST_CONFIGURATOR.get_database_name())
+                self.assertTrue(0 < len(stats) <= 100)
                 self.assertIn("calls", stats[0])
             else:
                 self.assertIsNone(pss_ver)
-                stats = dbp.get_statement_stats()
+                stats = dbp.get_statement_stats(TEST_CONFIGURATOR.get_database_name())
                 self.assertEqual(len(stats), 1)
                 self.assertIn("Result", stats[0])
 
-    def test_case_ranking(self):
-        with DBPerformanceStats("KOKU", CONFIGURATOR) as dbp:
-            res = dbp._case_db_ordering_clause("eek")
-            self.assertEqual(res, ("", {}))
-
-        with DBPerformanceStats("KOKU", CONFIGURATOR, database_ranking=["zero", "one"]) as dbp:
-            case, params = dbp._case_db_ordering_clause("eek")
-            case = re.sub(" +", " ", case.replace(os.linesep, " ").lower())
-            expected = (
-                "case eek when %(db_val_0)s then %(db_rank_0)s "
-                + "when %(db_val_1)s then %(db_rank_1)s else %(def_case_val)s end::text || eek"
-            )
-            self.assertEqual(case, expected)
-
     def test_explain(self):
         bad_statements = [
             "analyze select 1",
@@ -182,10 +172,30 @@ def test_explain(self):
         for bad_sql in bad_statements:
             with self.assertRaises(ProgrammingError, msg=f"Failing statement is {bad_sql}"):
                 with DBPerformanceStats("KOKU", CONFIGURATOR) as dbp:
-                    res = dbp.explain_sql("analyze select 1")
+                    res = dbp.explain_sql(bad_sql)
 
         expected = [{"query_plan": "Result  (cost=0.00..0.01 rows=1 width=4)\n  Output: 1", "query_text": "select 1"}]
 
         with DBPerformanceStats("KOKU", CONFIGURATOR) as dbp:
             res = dbp.explain_sql("select 1")
             self.assertEqual(res, expected)
+
+    def test_get_databases(self):
+        with connection.cursor() as cur:
+            cur.execute("select datname from pg_database where datname !~ '^templ';")
+            expected = len(cur.fetchall())
+
+        with DBPerformanceStats("KOKU", TEST_CONFIGURATOR) as dbp:
+            res = dbp.get_databases()
+            self.assertEqual(len(res), expected)
+
+    def test_get_schema_sizes(self):
+        with DBPerformanceStats("KOKU", TEST_CONFIGURATOR) as dbp:
+            res = dbp.get_schema_sizes()
+            self.assertTrue(len(res) > 0)
+
+    def test_get_schema_sizes_with_tables(self):
+        with DBPerformanceStats("KOKU", TEST_CONFIGURATOR) as dbp:
+            res = dbp.get_schema_sizes(top=10)
+            self.assertTrue(len(res) > 0)
+            self.assertIn("table_size_gb", res[0])
diff --git a/koku/masu/test/api/test_db_performance_views.py b/koku/masu/test/api/test_db_performance_views.py
index abe44ff0f0..597672b712 100644
--- a/koku/masu/test/api/test_db_performance_views.py
+++ b/koku/masu/test/api/test_db_performance_views.py
@@ -16,15 +16,36 @@
 
 from api.common import RH_IDENTITY_HEADER
 from api.iam.test.iam_test_case import IamTestCase
+from koku.configurator import CONFIGURATOR
+from masu.api.db_performance.db_performance import DBPerformanceStats
+from masu.api.db_performance.dbp_views import APPLICATION_DBNAME
+from masu.api.db_performance.dbp_views import get_database_list
 from masu.api.db_performance.dbp_views import get_limit_offset
 from masu.api.db_performance.dbp_views import get_menu
 from masu.api.db_performance.dbp_views import get_parameter_bool
 from masu.api.db_performance.dbp_views import get_parameter_list
+from masu.api.db_performance.dbp_views import make_db_options
+from masu.api.db_performance.dbp_views import make_pagination
 
 
 LOG = logging.getLogger(__name__)
 
 
+TEST_CONFIGURATOR = type("TEST_CONFIGURATOR", CONFIGURATOR.__bases__, dict(CONFIGURATOR.__dict__))
+
+
+def _get_database_name():
+    return "test_postgres"
+
+
+TEST_CONFIGURATOR.get_database_name = staticmethod(_get_database_name)
+
+
+class _dikt(dict):
+    def dict(self):
+        return self
+
+
 @override_settings(ROOT_URLCONF="masu.urls")
 class TestDBPerformance(IamTestCase):
     """Test cases for the running_celery_tasks endpoint."""
@@ -73,14 +94,43 @@ def test_get_lockinfo(self, mok_middl):
             self.assertIn("blocked_pid", html)
 
     @patch("koku.middleware.MASU", return_value=True)
-    def test_get_conn_activity(self, mok_middl):
+    @patch("koku.configurator.CONFIGURATOR.get_database_name", return_value=TEST_CONFIGURATOR.get_database_name())
+    def test_get_conn_activity(self, mok_conf, mok_middl):
         """Test the stat activity view."""
+        with DBPerformanceStats("KOKU", TEST_CONFIGURATOR) as dbp:
+            activity = dbp.get_activity(TEST_CONFIGURATOR.get_database_name())
+        pid = activity[0]["backend_pid"]
+        state = activity[0]["state"]
         response = self.client.get(reverse("conn_activity"), **self._get_headers())
         html = response.content.decode("utf-8")
         self.assertIn('id="term_action_table"', html)
         self.assertIn("Connection Activity", html)
         self.assertIn("backend_pid", html)
 
+        response = self.client.get(reverse("conn_activity"), {"pid": pid}, **self._get_headers())
+        html = response.content.decode("utf-8")
+        self.assertIn('id="term_action_table"', html)
+        self.assertIn("Connection Activity", html)
+        self.assertIn("backend_pid", html)
+
+        response = self.client.get(reverse("conn_activity"), {"pid": [pid]}, **self._get_headers())
+        html = response.content.decode("utf-8")
+        self.assertIn('id="term_action_table"', html)
+        self.assertIn("Connection Activity", html)
+        self.assertIn("backend_pid", html)
+
+        response = self.client.get(reverse("conn_activity"), {"state": state}, **self._get_headers())
+        html = response.content.decode("utf-8")
+        self.assertIn('id="term_action_table"', html)
+        self.assertIn("Connection Activity", html)
+        self.assertIn("backend_pid", html)
+
+        response = self.client.get(reverse("conn_activity"), {"state": [state]}, **self._get_headers())
+        html = response.content.decode("utf-8")
+        self.assertIn('id="term_action_table"', html)
+        self.assertIn("Connection Activity", html)
+        self.assertIn("backend_pid", html)
+
     @patch("koku.middleware.MASU", return_value=True)
     def test_get_stmt_stats(self, mok_middl):
         """Test the stat statements view."""
@@ -137,6 +187,25 @@ def test_explain(self, mok_middl):
         response = self.client.post(reverse("explain_query"), payload, "json", **headers)
         self.assertEqual(response.status_code, 200)
 
+    @patch("koku.middleware.MASU", return_value=True)
+    @patch("koku.configurator.CONFIGURATOR.get_database_name", return_value=TEST_CONFIGURATOR.get_database_name())
+    def test_get_schema_sizes(self, mod_conf, mok_middl):
+        headers = self._get_headers()
+        response = self.client.get(reverse("schema_sizes"), **headers)
+        self.assertEqual(response.status_code, 200)
+        html = response.content.decode("utf-8")
+        self.assertIn("schema_name", html)
+        self.assertIn("schema_size_gb", html)
+        self.assertNotIn("table_name", html)
+
+        headers["HTTP_X_REQUESTED_WITH"] = "XMLHttpRequest"
+        response = self.client.get(reverse("schema_sizes"), {"top": "5"}, **headers)
+        html = response.content.decode("utf-8")
+        self.assertEqual(response.status_code, 200)
+        self.assertIn("schema_name", html)
+        self.assertIn("schema_size_gb", html)
+        self.assertIn("table_name", html)
+
     @patch("koku.middleware.MASU", return_value=True)
     def test_get_menu(self, mok_middl):
         """Test the db version view."""
@@ -147,6 +216,7 @@ def test_get_menu(self, mok_middl):
         self.assertIn("Connection Activity", res)
         self.assertIn("Statement Statistics", res)
         self.assertIn("Lock Information", res)
+        self.assertIn("Schema Sizes", res)
         self.assertIn("Explain Query", res)
 
         res = get_menu("conn_activity")
@@ -159,7 +229,7 @@ def test_get_menu(self, mok_middl):
 
     @patch("koku.middleware.MASU", return_value=True)
     def test_get_limit_offset(self, mok_middl):
-        _default_limit = 500
+        _default_limit = 100
         request = Mock()
 
         request.query_params = {}
@@ -250,3 +320,71 @@ def test_get_parameter_bool(self, mok_middl):
         for p_val in truthy:
             request.query_params["a_param"] = p_val
             self.assertTrue(get_parameter_bool(request, "a_param"))
+
+    @patch("koku.middleware.MASU", return_value=True)
+    def test_make_pagination(self, mok_middl):
+        request = Mock()
+        data = ["a"] * 10
+        request.query_params = _dikt(limit=10, offset=0)
+        path = reverse("schema_sizes")
+
+        # test full first page
+        res = make_pagination(10, None, data, request, "schema_sizes")
+        self.assertIn(path, res)
+        self.assertEqual(res.count("<span"), 2)
+        self.assertEqual(res.count("<a"), 1)
+        self.assertIn("limit=20", res)
+        self.assertIn("offset=10", res)
+
+        # test middle of pages
+        request.query_params["limit"] = 20
+        request.query_params["offset"] = 10
+        res = make_pagination(20, 10, data, request, "schema_sizes")
+        self.assertIn(path, res)
+        self.assertEqual(res.count("<span"), 1)
+        self.assertEqual(res.count("<a"), 2)
+        self.assertIn("limit=10", res)
+        self.assertIn("offset=0", res)
+        self.assertIn("limit=30", res)
+        self.assertIn("offset=20", res)
+
+        # test end of pages
+        request.query_params["limit"] = 20
+        request.query_params["offset"] = 10
+        data = data[:2]
+        res = make_pagination(20, 10, data, request, "schema_sizes")
+        self.assertIn(path, res)
+        self.assertEqual(res.count("<span"), 2)
+        self.assertEqual(res.count("<a"), 1)
+        self.assertIn("limit=10", res)
+        self.assertIn("offset=0", res)
+
+        # test no pagination
+        request.query_params["limit"] = 10
+        request.query_params["offset"] = 0
+        res = make_pagination(10, 0, data, request, "schema_sizes")
+        self.assertFalse(path in res)
+        self.assertEqual(res.count("<span"), 3)
+
+    @patch("koku.middleware.MASU", return_value=True)
+    def test_get_database_list(self, mok_middl):
+        with DBPerformanceStats("KOKU", TEST_CONFIGURATOR) as dbps:
+            res = get_database_list(dbps)
+            self.assertIn(APPLICATION_DBNAME, res[0])
+
+    @patch("koku.middleware.MASU", return_value=True)
+    def test_make_db_options(self, mok_middl):
+        request = Mock()
+        target_db = TEST_CONFIGURATOR.get_database_name()
+        request.query_params = _dikt(dbname=target_db)
+
+        with DBPerformanceStats("KOKU", TEST_CONFIGURATOR) as dbps:
+            databases = get_database_list(dbps)
+            res = make_db_options(databases, target_db, request, "schema_sizes")
+            found = False
+            for line in res.split(os.linesep):
+                found = target_db in line
+                if found:
+                    self.assertIn("selected", line)
+                    break
+            self.assertTrue(found)