diff --git a/tests/connectors/core/test_display.py b/tests/connectors/core/test_display.py
index b21bab12b06214a0ff28e7ccd5f6cfec71e5ae42..6d2b1b682a0872a30537bef45bf290d9e22c2afe 100644
--- a/tests/connectors/core/test_display.py
+++ b/tests/connectors/core/test_display.py
@@ -191,7 +191,7 @@ class CoreDisplayTablesTestMixin:
 
     def test__display__show_tables(self):
         """"""
-        show_tables_query = '{0}{1}{2}'.format(OUTPUT_QUERY, self.show_tables_query, OUTPUT_RESET)
+        show_tables_query = '{0}{1}{2}'.format(OUTPUT_QUERY, self._show_tables_query, OUTPUT_RESET)
 
         # Since this directly tests display of tables, ensure we use a fresh database.
         db_name = '{0}d__tables__show'.format(self.test_db_name[0:-15])
@@ -207,7 +207,7 @@ class CoreDisplayTablesTestMixin:
 
         with self.subTest('Db name longer - Pt 1'):
             # Create table.
-            self.connector.tables.create('category', self.columns_query__basic, display_query=False)
+            self.connector.tables.create('category', self._columns_clause__basic, display_query=False)
 
             # Capture logging output.
             with self.assertLogs(None, 'INFO') as ilog:
@@ -220,7 +220,7 @@ class CoreDisplayTablesTestMixin:
 
         with self.subTest('Db name longer - Pt 2'):
             # Create table.
-            self.connector.tables.create('priority', self.columns_query__basic, display_query=False)
+            self.connector.tables.create('priority', self._columns_clause__basic, display_query=False)
 
             # Capture logging output.
             with self.assertLogs(None, 'INFO') as ilog:
@@ -233,7 +233,7 @@ class CoreDisplayTablesTestMixin:
 
         with self.subTest('Db name longer - Pt 3'):
             # Create table.
-            self.connector.tables.create('a', self.columns_query__basic, display_query=False)
+            self.connector.tables.create('a', self._columns_clause__basic, display_query=False)
 
             # Capture logging output.
             with self.assertLogs(None, 'INFO') as ilog:
@@ -248,7 +248,7 @@ class CoreDisplayTablesTestMixin:
             # Create table.
             self.connector.tables.create(
                 'test___{0}___this_is_a_really_long_table_name__test_'.format(self.db_type.lower()),
-                self.columns_query__basic,
+                self._columns_clause__basic,
                 display_query=False,
             )
 
@@ -265,7 +265,7 @@ class CoreDisplayTablesTestMixin:
             # Create table.
             self.connector.tables.create(
                 'test___{0}___this_is_a_really_long_table_name__test__'.format(self.db_type.lower()),
-                self.columns_query__basic,
+                self._columns_clause__basic,
                 display_query=False,
             )
 
@@ -280,7 +280,7 @@ class CoreDisplayTablesTestMixin:
 
         with self.subTest('Table name longer - Pt 2'):
             # Create table.
-            self.connector.tables.create('zzz', self.columns_query__basic, display_query=False)
+            self.connector.tables.create('zzz', self._columns_clause__basic, display_query=False)
 
             # Capture logging output.
             with self.assertLogs(None, 'INFO') as ilog:
@@ -295,7 +295,7 @@ class CoreDisplayTablesTestMixin:
             # Create table.
             self.connector.tables.create(
                 'test___{0}___this_is_a_really_long_table_name__testing__'.format(self.db_type.lower()),
-                self.columns_query__basic,
+                self._columns_clause__basic,
                 display_query=False,
             )
 
@@ -310,7 +310,7 @@ class CoreDisplayTablesTestMixin:
 
     def test__display__describe_tables(self):
         """"""
-        describe_table_query = '{0}{1}{2}'.format(OUTPUT_QUERY, self.describe_table_query, OUTPUT_RESET)
+        describe_table_query = '{0}{1}{2}'.format(OUTPUT_QUERY, self._describe_table_query, OUTPUT_RESET)
 
         # Since this directly tests display of tables, ensure we use a fresh database.
         db_name = '{0}d__tables__desc'.format(self.test_db_name[0:-15])
@@ -318,7 +318,7 @@ class CoreDisplayTablesTestMixin:
         self.connector.database.use(db_name, display_query=False)
 
         # Create initial table to describe.
-        self.connector.tables.create('category', self.columns_query__minimal, display_query=False)
+        self.connector.tables.create('category', self._columns_clause__minimal, display_query=False)
 
         with self.subTest('With only id'):
             # Capture logging output.
@@ -376,7 +376,7 @@ class CoreDisplayRecordsMixin:
         """"""
         select_from_query = '{0}SELECT * FROM category;{1}'.format(OUTPUT_QUERY, OUTPUT_RESET)
 
-        self.connector.tables.create('category', self.columns_query__basic, display_query=False)
+        self.connector.tables.create('category', self._columns_clause__basic, display_query=False)
 
         with self.subTest('With no records present'):
             # Capture logging output.
diff --git a/tests/connectors/core/test_records.py b/tests/connectors/core/test_records.py
index 599fde84c5158ff19babacf4e01d1009ae0c9b9b..180c82e7fcdd8489f5678240837e2efb630948da 100644
--- a/tests/connectors/core/test_records.py
+++ b/tests/connectors/core/test_records.py
@@ -27,8 +27,8 @@ class CoreRecordsTestMixin:
         """
         cls.test_db_name_start = cls.test_db_name_start.format(cls.db_type)
 
-        cls._columns_query__basic = None
-        cls._columns_query__datetime = None
+        cls._columns_clause__basic = None
+        cls._columns_clause__datetime = None
 
         cls.error_handler__table_already_exists = None
 
@@ -50,7 +50,7 @@ class CoreRecordsTestMixin:
 
         # Verify table exists.
         try:
-            self.connector.query.execute('CREATE TABLE {0}{1};'.format(table_name, self._columns_query__basic))
+            self.connector.query.execute('CREATE TABLE {0}{1};'.format(table_name, self._columns_clause__basic))
         except self.error_handler__table_already_exists:
             # Table already exists, as we want.
             pass
@@ -128,7 +128,7 @@ class CoreRecordsTestMixin:
 
         # Verify table exists.
         try:
-            self.connector.query.execute('CREATE TABLE {0}{1};'.format(table_name, self._columns_query__basic))
+            self.connector.query.execute('CREATE TABLE {0}{1};'.format(table_name, self._columns_clause__basic))
         except self.error_handler__table_already_exists:
             # Table already exists, as we want.
             pass
@@ -216,7 +216,7 @@ class CoreRecordsTestMixin:
 
         # Verify table exists.
         try:
-            self.connector.query.execute('CREATE TABLE {0}{1};'.format(table_name, self._columns_query__basic))
+            self.connector.query.execute('CREATE TABLE {0}{1};'.format(table_name, self._columns_clause__basic))
         except self.error_handler__table_already_exists:
             # Table already exists, as we want.
             pass
@@ -253,7 +253,7 @@ class CoreRecordsTestMixin:
 
         # Verify table exists.
         try:
-            self.connector.query.execute('CREATE TABLE {0} {1};'.format(table_name, self._columns_query__datetime))
+            self.connector.query.execute('CREATE TABLE {0} {1};'.format(table_name, self._columns_clause__datetime))
         except self.error_handler__table_already_exists:
             # Table already exists, as we want.
             pass
@@ -315,7 +315,7 @@ class CoreRecordsTestMixin:
 
         # Verify table exists.
         try:
-            self.connector.query.execute('CREATE TABLE {0}{1};'.format(table_name, self._columns_query__basic))
+            self.connector.query.execute('CREATE TABLE {0}{1};'.format(table_name, self._columns_clause__basic))
         except self.error_handler__table_already_exists:
             # Table already exists, as we want.
             pass
@@ -415,7 +415,7 @@ class CoreRecordsTestMixin:
 
         # Verify table exists.
         try:
-            self.connector.query.execute('CREATE TABLE {0}{1};'.format(table_name, self._columns_query__datetime))
+            self.connector.query.execute('CREATE TABLE {0}{1};'.format(table_name, self._columns_clause__datetime))
         except self.error_handler__table_already_exists:
             # Table already exists, as we want.
             pass
@@ -566,7 +566,7 @@ class CoreRecordsTestMixin:
 
         # Verify table exists.
         try:
-            self.connector.query.execute('CREATE TABLE {0}{1};'.format(table_name, self._columns_query__basic))
+            self.connector.query.execute('CREATE TABLE {0}{1};'.format(table_name, self._columns_clause__basic))
         except self.error_handler__table_already_exists:
             # Table already exists, as we want.
             pass
diff --git a/tests/connectors/core/test_tables.py b/tests/connectors/core/test_tables.py
index 87e2ff1f112ccd1573ede67216dfae28071e2bdd..40157c0d859cd2b44045610c12b6a620699dd48c 100644
--- a/tests/connectors/core/test_tables.py
+++ b/tests/connectors/core/test_tables.py
@@ -51,7 +51,7 @@ class CoreTablesTestMixin:
         self.assertNotIn(table_name, results)
 
         # Attempt to generate table.
-        self.connector.tables.create(table_name, self._basic_table_columns)
+        self.connector.tables.create(table_name, self._columns_clause__minimal)
 
         # Check that expected table now exists in database.
         results = self.connector.tables.show()
@@ -85,7 +85,7 @@ class CoreTablesTestMixin:
         self.assertNotIn(table_name, results)
 
         # Attempt to generate table.
-        self.connector.tables.create(table_name, self._basic_table_columns)
+        self.connector.tables.create(table_name, self._columns_clause__minimal)
 
         # Check that expected table now exists in database.
         results = self.connector.tables.show()
@@ -107,7 +107,7 @@ class CoreTablesTestMixin:
         with self.subTest('SHOW query when table exists'):
             # Verify table exists.
             try:
-                self.connector.query.execute('CREATE TABLE {0}{1};'.format(table_name, self._columns_query))
+                self.connector.query.execute('CREATE TABLE {0}{1};'.format(table_name, self._columns_clause__basic))
             except self.error_handler__table_already_exists:
                 # Table already exists, as we want.
                 pass
@@ -152,7 +152,7 @@ class CoreTablesTestMixin:
         self.assertNotIn(table_name, results)
 
         # Run test query.
-        self.connector.tables.create(table_name, self._columns_query)
+        self.connector.tables.create(table_name, self._columns_clause__basic)
 
         # Check tables after test query. Verify expected table returned.
         results = self.connector.tables.show()
@@ -167,7 +167,7 @@ class CoreTablesTestMixin:
 
         # Verify table exists.
         try:
-            self.connector.query.execute('CREATE TABLE {0}{1};'.format(table_name, self._columns_query))
+            self.connector.query.execute('CREATE TABLE {0}{1};'.format(table_name, self._columns_clause__basic))
         except self.error_handler__table_already_exists:
             # Table already exists, as we want.
             pass
@@ -179,7 +179,7 @@ class CoreTablesTestMixin:
 
         # Run test query.
         with self.assertRaises(ValueError):
-            self.connector.tables.create(table_name, self._columns_query)
+            self.connector.tables.create(table_name, self._columns_clause__basic)
 
     # def test__modify_table__success(self):
     #     """
@@ -192,7 +192,7 @@ class CoreTablesTestMixin:
     #
     #     # Verify table exists.
     #     try:
-    #         self.connector.query.execute('CREATE TABLE {0}{1};'.format(table_name, self._columns_query))
+    #         self.connector.query.execute('CREATE TABLE {0}{1};'.format(table_name, _columns_clause__basic))
     #     except self.error_handler__table_already_exists:
     #         # Table already exists, as we want.
     #         pass
@@ -279,7 +279,7 @@ class CoreTablesTestMixin:
 
         # Verify table exists.
         try:
-            self.connector.query.execute('CREATE TABLE {0}{1};'.format(table_name, self._columns_query))
+            self.connector.query.execute('CREATE TABLE {0}{1};'.format(table_name, self._columns_clause__basic))
         except self.error_handler__table_already_exists:
             # Table already exists, as we want.
             pass
@@ -300,7 +300,7 @@ class CoreTablesTestMixin:
 
         # Verify table exists.
         # try:
-        self.connector.query.execute('CREATE TABLE {0}{1};'.format(table_name, self._columns_query))
+        self.connector.query.execute('CREATE TABLE {0}{1};'.format(table_name, self._columns_clause__basic))
 
         # Check tables prior to test query. Verify expected table returned.
         results = self.connector.tables.show()
diff --git a/tests/connectors/mysql/constants.py b/tests/connectors/mysql/constants.py
new file mode 100644
index 0000000000000000000000000000000000000000..deac2545d3af09f4d10be86950ca53732a9489b7
--- /dev/null
+++ b/tests/connectors/mysql/constants.py
@@ -0,0 +1,41 @@
+"""
+Various testing constants for MySQL.
+"""
+
+
+SHOW_TABLES_QUERY = """
+SHOW TABLES;
+""".strip()
+
+
+DESCRIBE_TABLE_QUERY = """
+DESCRIBE category;
+""".strip()
+
+
+COLUMNS_CLAUSE__MINIMAL = """
+(
+    id INT NOT NULL AUTO_INCREMENT,
+    PRIMARY KEY ( id )
+)
+""".strip()
+
+
+COLUMNS_CLAUSE__BASIC = """
+(
+    id INT NOT NULL AUTO_INCREMENT,
+    name VARCHAR(100),
+    description VARCHAR(100),
+    PRIMARY KEY ( id )
+)
+""".strip()
+
+
+COLUMNS_CLAUSE__DATETIME = """
+(
+    id INT NOT NULL AUTO_INCREMENT,
+    test_datetime DATETIME,
+    test_date DATE,
+    PRIMARY KEY ( id )
+)
+""".strip()
diff --git a/tests/connectors/mysql/test_display.py b/tests/connectors/mysql/test_display.py
index 00ff0eca8ee947bea5d0a9489655b8014f9842eb..b2ed3518c6fcaf182e2d6f83ce3ef518731124da 100644
--- a/tests/connectors/mysql/test_display.py
+++ b/tests/connectors/mysql/test_display.py
@@ -5,6 +5,12 @@ Tests for "display" logic of "MySQL" DB Connector class.
 # System Imports.
 
 # Internal Imports.
+from .constants import (
+    DESCRIBE_TABLE_QUERY,
+    SHOW_TABLES_QUERY,
+    COLUMNS_CLAUSE__BASIC,
+    COLUMNS_CLAUSE__MINIMAL,
+)
 from .test_core import TestMysqlDatabaseParent
 from .expected_display_output import ExpectedOutput
 from tests.connectors.core.test_display import (
@@ -14,27 +20,6 @@ from tests.connectors.core.test_display import (
 )
 
 
-SHOW_TABLES_QUERY = """
-SHOW TABLES;
-""".strip()
-DESCRIBE_TABLE_QUERY = """DESCRIBE category;"""
-COLUMNS_QUERY__MINIMAL = """
-(
-    id INT NOT NULL AUTO_INCREMENT,
-    PRIMARY KEY ( id )
-)
-""".strip()
-COLUMNS_QUERY__BASIC = """
-(
-    id INT NOT NULL AUTO_INCREMENT,
-    name VARCHAR(100),
-    description VARCHAR(100),
-    PRIMARY KEY ( id )
-)
-""".strip()
-
-
-
 class TestMysqlDisplayCore(TestMysqlDatabaseParent, CoreDisplayBaseTestMixin):
     """
     Tests "MySQL" DB Connector class display logic.
@@ -64,7 +49,7 @@ class TestMysqlDisplayCore(TestMysqlDatabaseParent, CoreDisplayBaseTestMixin):
 
         # Define expected output to compare against.
         cls.expected_output = ExpectedOutput
-        cls.show_tables_query = SHOW_TABLES_QUERY
+        cls._show_tables_query = SHOW_TABLES_QUERY
 
 
 class TestMysqlDisplayTables(TestMysqlDatabaseParent, CoreDisplayTablesTestMixin):
@@ -96,10 +81,10 @@ class TestMysqlDisplayTables(TestMysqlDatabaseParent, CoreDisplayTablesTestMixin
 
         # Define expected output to compare against.
         cls.expected_output = ExpectedOutput
-        cls.show_tables_query = SHOW_TABLES_QUERY
-        cls.describe_table_query = DESCRIBE_TABLE_QUERY
-        cls.columns_query__minimal = COLUMNS_QUERY__MINIMAL
-        cls.columns_query__basic = COLUMNS_QUERY__BASIC
+        cls._show_tables_query = SHOW_TABLES_QUERY
+        cls._describe_table_query = DESCRIBE_TABLE_QUERY
+        cls._columns_clause__minimal = COLUMNS_CLAUSE__MINIMAL
+        cls._columns_clause__basic = COLUMNS_CLAUSE__BASIC
 
 
 class TestMysqlDisplayRecords(TestMysqlDatabaseParent, CoreDisplayRecordsMixin):
@@ -131,6 +116,6 @@ class TestMysqlDisplayRecords(TestMysqlDatabaseParent, CoreDisplayRecordsMixin):
 
         # Define expected output to compare against.
         cls.expected_output = ExpectedOutput
-        cls.show_tables_query = SHOW_TABLES_QUERY
-        cls.columns_query__minimal = COLUMNS_QUERY__MINIMAL
-        cls.columns_query__basic = COLUMNS_QUERY__BASIC
+        cls._show_tables_query = SHOW_TABLES_QUERY
+        cls._columns_clause__minimal = COLUMNS_CLAUSE__MINIMAL
+        cls._columns_clause__basic = COLUMNS_CLAUSE__BASIC
diff --git a/tests/connectors/mysql/test_records.py b/tests/connectors/mysql/test_records.py
index bf849386f6d68bc1b3f1aa129d2ae39e0545747a..df595f2e9c36b4bdb8488f3677d6ef5a5ab3d005 100644
--- a/tests/connectors/mysql/test_records.py
+++ b/tests/connectors/mysql/test_records.py
@@ -6,6 +6,7 @@ Tests for "records" logic of "MySQL" DB Connector class.
 import textwrap
 
 # Internal Imports.
+from .constants import COLUMNS_CLAUSE__BASIC, COLUMNS_CLAUSE__DATETIME
 from .test_core import TestMysqlDatabaseParent
 from tests.connectors.core.test_records import CoreRecordsTestMixin
 
@@ -36,26 +37,8 @@ class TestMysqlRecords(TestMysqlDatabaseParent, CoreRecordsTestMixin):
                 cls.connector.tables.drop(result)
 
         # Define default table columns.
-        cls._columns_query__basic = textwrap.dedent(
-            """
-            (
-                id INT NOT NULL AUTO_INCREMENT,
-                name VARCHAR(100),
-                description VARCHAR(100),
-                PRIMARY KEY ( id )
-            )
-            """
-        ).strip()
-        cls._columns_query__datetime = textwrap.dedent(
-            """
-            (
-                id INT NOT NULL AUTO_INCREMENT,
-                test_datetime DATETIME,
-                test_date DATE,
-                PRIMARY KEY ( id )
-            )
-            """
-        ).strip()
+        cls._columns_clause__basic = COLUMNS_CLAUSE__BASIC
+        cls._columns_clause__datetime = COLUMNS_CLAUSE__DATETIME
 
         cls.error_handler__table_already_exists = cls.db_error_handler.OperationalError
 
@@ -72,7 +55,7 @@ class TestMysqlRecords(TestMysqlDatabaseParent, CoreRecordsTestMixin):
         with self.subTest('Verify handling when database already exists'):
             # Make sure we're using a table name that is not already created.
             table_name = 'test_table'
-            self.connector.tables.create(table_name, self._columns_query__basic)
+            self.connector.tables.create(table_name, self._columns_clause__basic)
 
             results = self.connector.tables.show()
             if table_name not in results:
@@ -80,4 +63,4 @@ class TestMysqlRecords(TestMysqlDatabaseParent, CoreRecordsTestMixin):
 
             # Check that we use the correct handler.
             with self.assertRaises(self.error_handler__table_already_exists):
-                self.connector.query.execute('CREATE TABLE {0} {1};'.format(table_name, self._columns_query__basic))
+                self.connector.query.execute('CREATE TABLE {0} {1};'.format(table_name, self._columns_clause__basic))
diff --git a/tests/connectors/mysql/test_tables.py b/tests/connectors/mysql/test_tables.py
index 49c0677c7d987d55170df818cb42f0f124d0aaa4..b97da30e14307f610500f082adea4bdbf4895af9 100644
--- a/tests/connectors/mysql/test_tables.py
+++ b/tests/connectors/mysql/test_tables.py
@@ -6,6 +6,10 @@ Tests for "tables" logic of "MySQL" DB Connector class.
 import textwrap
 
 # Internal Imports.
+from .constants import (
+    COLUMNS_CLAUSE__MINIMAL,
+    COLUMNS_CLAUSE__BASIC,
+)
 from .test_core import TestMysqlDatabaseParent
 from tests.connectors.core.test_tables import CoreTablesTestMixin
 
@@ -36,24 +40,8 @@ class TestMysqlTables(TestMysqlDatabaseParent, CoreTablesTestMixin):
                 cls.connector.tables.drop(result)
 
         # Define database-specific query values.
-        cls._basic_table_columns = textwrap.dedent(
-            """
-            (
-                id INT(11) NOT NULL AUTO_INCREMENT,
-                PRIMARY KEY (id)
-            )
-            """
-        ).strip()
-        cls._columns_query = textwrap.dedent(
-            """
-            (
-                id INT NOT NULL AUTO_INCREMENT,
-                name VARCHAR(100),
-                description VARCHAR(100),
-                PRIMARY KEY ( id )
-            )
-            """
-        ).strip()
+        cls._columns_clause__minimal = COLUMNS_CLAUSE__MINIMAL
+        cls._columns_clause__basic = COLUMNS_CLAUSE__BASIC
 
         cls.error_handler__table_does_not_exist = cls.db_error_handler.OperationalError
         cls.error_handler__table_already_exists = cls.db_error_handler.OperationalError
@@ -82,7 +70,7 @@ class TestMysqlTables(TestMysqlDatabaseParent, CoreTablesTestMixin):
         with self.subTest('Verify handling when database already exists'):
             # Make sure we're using a table name that is not already created.
             table_name = 'test_table'
-            self.connector.tables.create(table_name, self._basic_table_columns)
+            self.connector.tables.create(table_name, self._columns_clause__minimal)
 
             results = self.connector.tables.show()
             if table_name not in results:
@@ -90,4 +78,4 @@ class TestMysqlTables(TestMysqlDatabaseParent, CoreTablesTestMixin):
 
             # Check that we use the correct handler.
             with self.assertRaises(self.error_handler__table_already_exists):
-                self.connector.query.execute('CREATE TABLE {0} {1};'.format(table_name, self._basic_table_columns))
+                self.connector.query.execute('CREATE TABLE {0} {1};'.format(table_name, self._columns_clause__minimal))
diff --git a/tests/connectors/postgresql/constants.py b/tests/connectors/postgresql/constants.py
new file mode 100644
index 0000000000000000000000000000000000000000..90c0cf9837a964440c553e568ae53775716ceaec
--- /dev/null
+++ b/tests/connectors/postgresql/constants.py
@@ -0,0 +1,40 @@
+"""
+Various testing constants for PostgreSQL.
+"""
+
+
+SHOW_TABLES_QUERY = """
+SELECT table_name FROM information_schema.tables
+WHERE table_schema = 'public';
+""".strip()
+
+
+DESCRIBE_TABLE_QUERY = """
+SELECT * FROM information_schema.columns
+WHERE (table_schema = 'public' AND table_name = 'category');
+""".strip()
+
+
+COLUMNS_CLAUSE__MINIMAL = """
+(
+    id serial PRIMARY KEY
+)
+""".strip()
+
+
+COLUMNS_CLAUSE__BASIC = """
+(
+    id serial PRIMARY KEY,
+    name VARCHAR(100),
+    description VARCHAR(100)
+)
+""".strip()
+
+
+COLUMNS_CLAUSE__DATETIME = """
+(
+    id serial PRIMARY KEY,
+    test_datetime TIMESTAMP,
+    test_date DATE
+)
+""".strip()
diff --git a/tests/connectors/postgresql/test_display.py b/tests/connectors/postgresql/test_display.py
index 040ca3665717a9b2d89d4fecd64902ffc7b6e517..550fc9776ba0e64c339c64bb14dc94b104afd05c 100644
--- a/tests/connectors/postgresql/test_display.py
+++ b/tests/connectors/postgresql/test_display.py
@@ -5,6 +5,12 @@ Tests for "display" logic of "PostgreSQL" DB Connector class.
 # System Imports.
 
 # Internal Imports.
+from .constants import (
+    DESCRIBE_TABLE_QUERY,
+    SHOW_TABLES_QUERY,
+    COLUMNS_CLAUSE__BASIC,
+    COLUMNS_CLAUSE__MINIMAL,
+)
 from .expected_display_output import ExpectedOutput
 from .test_core import TestPostgresqlDatabaseParent
 from tests.connectors.core.test_display import (
@@ -14,28 +20,6 @@ from tests.connectors.core.test_display import (
 )
 
 
-SHOW_TABLES_QUERY = """
-SELECT table_name FROM information_schema.tables
-WHERE table_schema = 'public';
-""".strip()
-DESCRIBE_TABLE_QUERY = """
-SELECT * FROM information_schema.columns
-WHERE (table_schema = 'public' AND table_name = 'category');
-""".strip()
-COLUMNS_QUERY__MINIMAL = """
-(
-    id serial PRIMARY KEY
-)
-""".strip()
-COLUMNS_QUERY__BASIC = """
-(
-    id serial PRIMARY KEY,
-    name VARCHAR(100),
-    description VARCHAR(100)
-)
-""".strip()
-
-
 class TestPostgresqlDisplay(TestPostgresqlDatabaseParent, CoreDisplayBaseTestMixin):
     """
     Tests "PostgreSQL" DB Connector class display logic.
@@ -63,7 +47,7 @@ class TestPostgresqlDisplay(TestPostgresqlDatabaseParent, CoreDisplayBaseTestMix
 
         # Define expected output to compare against.
         cls.expected_output = ExpectedOutput
-        cls.show_tables_query = SHOW_TABLES_QUERY
+        cls._show_tables_query = SHOW_TABLES_QUERY
 
 
 class TestPostgresqlDisplayTables(TestPostgresqlDatabaseParent, CoreDisplayTablesTestMixin):
@@ -95,10 +79,10 @@ class TestPostgresqlDisplayTables(TestPostgresqlDatabaseParent, CoreDisplayTable
 
         # Define expected output to compare against.
         cls.expected_output = ExpectedOutput
-        cls.show_tables_query = SHOW_TABLES_QUERY
-        cls.describe_table_query = DESCRIBE_TABLE_QUERY
-        cls.columns_query__minimal = COLUMNS_QUERY__MINIMAL
-        cls.columns_query__basic = COLUMNS_QUERY__BASIC
+        cls._show_tables_query = SHOW_TABLES_QUERY
+        cls._describe_table_query = DESCRIBE_TABLE_QUERY
+        cls._columns_clause__minimal = COLUMNS_CLAUSE__MINIMAL
+        cls._columns_clause__basic = COLUMNS_CLAUSE__BASIC
 
 
 class TestPostgreSQLDisplayRecords(TestPostgresqlDatabaseParent, CoreDisplayRecordsMixin):
@@ -130,6 +114,6 @@ class TestPostgreSQLDisplayRecords(TestPostgresqlDatabaseParent, CoreDisplayReco
 
         # Define expected output to compare against.
         cls.expected_output = ExpectedOutput
-        cls.show_tables_query = SHOW_TABLES_QUERY
-        cls.columns_query__minimal = COLUMNS_QUERY__MINIMAL
-        cls.columns_query__basic = COLUMNS_QUERY__BASIC
+        cls._show_tables_query = SHOW_TABLES_QUERY
+        cls._columns_clause__minimal = COLUMNS_CLAUSE__MINIMAL
+        cls._columns_clause__basic = COLUMNS_CLAUSE__BASIC
diff --git a/tests/connectors/postgresql/test_records.py b/tests/connectors/postgresql/test_records.py
index d5ce428d06071bcd616d11d727e27a38efd21fcf..3b4e43c6fab62ca39451dd0b65514edfda0415dc 100644
--- a/tests/connectors/postgresql/test_records.py
+++ b/tests/connectors/postgresql/test_records.py
@@ -6,6 +6,7 @@ Tests for "records" logic of "PostgreSQL" DB Connector class.
 import textwrap
 
 # Internal Imports.
+from .constants import COLUMNS_CLAUSE__BASIC, COLUMNS_CLAUSE__DATETIME
 from .test_core import TestPostgresqlDatabaseParent
 from tests.connectors.core.test_records import CoreRecordsTestMixin
 
@@ -36,24 +37,8 @@ class TestPostgresqlRecords(TestPostgresqlDatabaseParent, CoreRecordsTestMixin):
                 cls.connector.tables.drop(result)
 
         # Define default table columns.
-        cls._columns_query__basic = textwrap.dedent(
-            """
-            (
-                id serial PRIMARY KEY,
-                name VARCHAR(100),
-                description VARCHAR(100)
-            )
-            """
-        ).strip()
-        cls._columns_query__datetime = textwrap.dedent(
-            """
-            (
-                id serial PRIMARY KEY,
-                test_datetime TIMESTAMP,
-                test_date DATE
-            )
-            """
-        ).strip()
+        cls._columns_clause__basic = COLUMNS_CLAUSE__BASIC
+        cls._columns_clause__datetime = COLUMNS_CLAUSE__DATETIME
 
         cls.error_handler__table_already_exists = cls.db_error_handler.errors.DuplicateTable
 
@@ -70,7 +55,7 @@ class TestPostgresqlRecords(TestPostgresqlDatabaseParent, CoreRecordsTestMixin):
         with self.subTest('Verify handling when database already exists'):
             # Make sure we're using a table name that is not already created.
             table_name = 'test_table'
-            self.connector.tables.create(table_name, self._columns_query__basic)
+            self.connector.tables.create(table_name, self._columns_clause__basic)
 
             results = self.connector.tables.show()
             if table_name not in results:
@@ -78,4 +63,4 @@ class TestPostgresqlRecords(TestPostgresqlDatabaseParent, CoreRecordsTestMixin):
 
             # Check that we use the correct handler.
             with self.assertRaises(self.error_handler__table_already_exists):
-                self.connector.query.execute('CREATE TABLE {0} {1};'.format(table_name, self._columns_query__basic))
+                self.connector.query.execute('CREATE TABLE {0} {1};'.format(table_name, self._columns_clause__basic))
diff --git a/tests/connectors/postgresql/test_tables.py b/tests/connectors/postgresql/test_tables.py
index b26b26d0b7bc4651f6396f173e06b60a88a563b0..2ff6c36f407e235d8efa393435776abbe6ad4306 100644
--- a/tests/connectors/postgresql/test_tables.py
+++ b/tests/connectors/postgresql/test_tables.py
@@ -3,9 +3,9 @@ Tests for "tables" logic of "PostgreSQL" DB Connector class.
 """
 
 # System Imports.
-import textwrap
 
 # Internal Imports.
+from .constants import COLUMNS_CLAUSE__MINIMAL, COLUMNS_CLAUSE__BASIC
 from .test_core import TestPostgresqlDatabaseParent
 from tests.connectors.core.test_tables import CoreTablesTestMixin
 
@@ -36,22 +36,8 @@ class TestPostgresqlTables(TestPostgresqlDatabaseParent, CoreTablesTestMixin):
                 cls.connector.tables.drop(result)
 
         # Define database-specific query values.
-        cls._basic_table_columns = textwrap.dedent(
-            """
-            (
-                id serial PRIMARY KEY
-            )
-            """
-        ).strip()
-        cls._columns_query = textwrap.dedent(
-            """
-            (
-                id serial PRIMARY KEY,
-                name VARCHAR(100),
-                description VARCHAR(100)
-            )
-            """
-        ).strip()
+        cls._columns_clause__minimal = COLUMNS_CLAUSE__MINIMAL
+        cls._columns_clause__basic = COLUMNS_CLAUSE__BASIC
 
         cls.error_handler__table_does_not_exist = cls.db_error_handler.errors.UndefinedTable
         cls.error_handler__table_already_exists = cls.db_error_handler.errors.DuplicateTable
@@ -80,7 +66,7 @@ class TestPostgresqlTables(TestPostgresqlDatabaseParent, CoreTablesTestMixin):
         with self.subTest('Verify handling when database already exists'):
             # Make sure we're using a table name that is not already created.
             table_name = 'test_table'
-            self.connector.tables.create(table_name, self._basic_table_columns)
+            self.connector.tables.create(table_name, self._columns_clause__minimal)
 
             results = self.connector.tables.show()
             if table_name not in results:
@@ -88,4 +74,4 @@ class TestPostgresqlTables(TestPostgresqlDatabaseParent, CoreTablesTestMixin):
 
             # Check that we use the correct handler.
             with self.assertRaises(self.error_handler__table_already_exists):
-                self.connector.query.execute('CREATE TABLE {0} {1};'.format(table_name, self._basic_table_columns))
+                self.connector.query.execute('CREATE TABLE {0} {1};'.format(table_name, self._columns_clause__minimal))