Support inspection of computed column

Added support for reflection of "computed" columns, which are now returned
as part of the structure returned by :meth:`.Inspector.get_columns`.
When reflecting full :class:`.Table` objects, computed columns will
be represented using the :class:`.Computed` construct.

Also improve the documentation in :meth:`Inspector.get_columns`, correctly
listing all the returned keys.

Fixes: #5063
Fixes: #4051

Closes: #5064
Pull-request: https://github.com/sqlalchemy/sqlalchemy/pull/5064
Pull-request-sha: ba00fc321ce468f8885aad23b3dd33c789e50fbe

Change-Id: I789986554fc8ac7f084270474d0b2c12046b1cc2

3 files changed, 53 insertions, 1 deletions

diff --git a/test/dialect/postgresql/test_reflection.py b/test/dialect/postgresql/test_reflection.py
index c66537250..374bda565 100644
--- a/test/dialect/postgresql/test_reflection.py
+++ b/test/dialect/postgresql/test_reflection.py
@@ -1669,7 +1669,7 @@ class CustomTypeReflectionTest(fixtures.TestBase):
             ("my_custom_type(ARG1, ARG2)", ("ARG1", "ARG2")),
         ]:
             column_info = dialect._get_column_info(
-                "colname", sch, None, False, {}, {}, "public", None
+                "colname", sch, None, False, {}, {}, "public", None, ""
             )
             assert isinstance(column_info["type"], self.CustomType)
             eq_(column_info["type"].arg1, args[0])
diff --git a/test/engine/test_reflection.py b/test/engine/test_reflection.py
index 579f1aece..9de181216 100644
--- a/test/engine/test_reflection.py
+++ b/test/engine/test_reflection.py
@@ -1,6 +1,7 @@
 import unicodedata
 
 import sqlalchemy as sa
+from sqlalchemy import Computed
 from sqlalchemy import DefaultClause
 from sqlalchemy import FetchedValue
 from sqlalchemy import ForeignKey
@@ -26,6 +27,8 @@ from sqlalchemy.testing import fixtures
 from sqlalchemy.testing import in_
 from sqlalchemy.testing import is_
 from sqlalchemy.testing import is_false
+from sqlalchemy.testing import is_instance_of
+from sqlalchemy.testing import is_not_
 from sqlalchemy.testing import is_true
 from sqlalchemy.testing import mock
 from sqlalchemy.testing import not_in_
@@ -2263,3 +2266,36 @@ class ColumnEventsTest(fixtures.RemovesEvents, fixtures.TestBase):
             eq_(str(table.c.x.server_default.arg), "1")
 
         self._do_test("x", {"default": my_default}, assert_text_of_one)
+
+
+class ComputedColumnTest(fixtures.ComputedReflectionFixtureTest):
+    def check_table_column(self, table, name, text, persisted):
+        is_true(name in table.columns)
+        col = table.columns[name]
+        is_not_(col.computed, None)
+        is_instance_of(col.computed, Computed)
+
+        eq_(self.normalize(str(col.computed.sqltext)), text)
+        if testing.requires.computed_columns_reflect_persisted.enabled:
+            eq_(col.computed.persisted, persisted)
+        else:
+            is_(col.computed.persisted, None)
+
+    def test_table_reflection(self):
+        meta = MetaData()
+        table = Table("computed_column_table", meta, autoload_with=config.db)
+
+        self.check_table_column(
+            table,
+            "computed_no_flag",
+            "normal+42",
+            testing.requires.computed_columns_default_persisted.enabled,
+        )
+        if testing.requires.computed_columns_virtual.enabled:
+            self.check_table_column(
+                table, "computed_virtual", "normal+2", False,
+            )
+        if testing.requires.computed_columns_stored.enabled:
+            self.check_table_column(
+                table, "computed_stored", "normal-42", True,
+            )
diff --git a/test/requirements.py b/test/requirements.py
index a1bd57aea..913d06a01 100644
--- a/test/requirements.py
+++ b/test/requirements.py
@@ -1509,3 +1509,19 @@ class DefaultRequirements(SuiteRequirements):
     @property
     def python_profiling_backend(self):
         return only_on([self._sqlite_memory_db])
+
+    @property
+    def computed_columns_stored(self):
+        return self.computed_columns + skip_if(["oracle", "firebird"])
+
+    @property
+    def computed_columns_virtual(self):
+        return self.computed_columns + skip_if(["postgresql", "firebird"])
+
+    @property
+    def computed_columns_default_persisted(self):
+        return self.computed_columns + only_if("postgresql")
+
+    @property
+    def computed_columns_reflect_persisted(self):
+        return self.computed_columns + skip_if("oracle")