Basic support for viewing tables in Greenplum. Patch from George & Tira @ Pivotal.

web/pgadmin/browser/server_groups/servers/databases/schemas/tables/templates/table/sql/9.1_plus/nodes.sql

@@ -0,0 +1,7 @@
+SELECT rel.oid, rel.relname AS name,
+    (SELECT count(*) FROM pg_trigger WHERE tgrelid=rel.oid AND tgisinternal = FALSE) AS triggercount,
+    (SELECT count(*) FROM pg_trigger WHERE tgrelid=rel.oid AND tgisinternal = FALSE AND tgenabled = 'O') AS has_enable_triggers
+FROM pg_class rel
+    WHERE rel.relkind IN ('r','s','t') AND rel.relnamespace = {{ scid }}::oid
+    {% if tid %} AND rel.oid = {{tid}}::OID {% endif %}
+    ORDER BY rel.relname;

web/pgadmin/browser/server_groups/servers/databases/schemas/tables/templates/table/sql/default/nodes.sql

@@ -1,6 +1,6 @@
 SELECT rel.oid, rel.relname AS name,
-    (SELECT count(*) FROM pg_trigger WHERE tgrelid=rel.oid AND tgisinternal = FALSE) AS triggercount,
-    (SELECT count(*) FROM pg_trigger WHERE tgrelid=rel.oid AND tgisinternal = FALSE AND tgenabled = 'O') AS has_enable_triggers
+    (SELECT count(*) FROM pg_trigger WHERE tgrelid=rel.oid) AS triggercount,
+    (SELECT count(*) FROM pg_trigger WHERE tgrelid=rel.oid AND tgenabled = 'O') AS has_enable_triggers
 FROM pg_class rel
     WHERE rel.relkind IN ('r','s','t') AND rel.relnamespace = {{ scid }}::oid
     {% if tid %} AND rel.oid = {{tid}}::OID {% endif %}

web/pgadmin/browser/server_groups/servers/databases/schemas/tables/templates/table/sql/tests/test_tables_node.py

@@ -0,0 +1,60 @@
+import os
+
+from jinja2 import BaseLoader
+from jinja2 import Environment
+
+from pgadmin.utils.route import BaseTestGenerator
+from regression import test_utils
+
+
+class TestTablesNode(BaseTestGenerator):
+    def runTest(self):
+        """
+            This tests that all applicable sql template versions can fetch table names
+        """
+        with test_utils.Database(self.server) as (connection, database_name):
+            test_utils.create_table(self.server, database_name, "test_table")
+
+            if connection.server_version < 91000:
+                self.versions_to_test = ['default']
+            else:
+                self.versions_to_test = ['default', '9.1_plus']
+
+            for version in self.versions_to_test:
+                template_file = os.path.join(os.path.dirname(__file__), "..", version, "nodes.sql")
+                file_content = open(template_file, 'r').read()
+
+                env = Environment(loader=SimpleTemplateLoader(file_content))
+
+                template = env.get_template("")
+                public_schema_id = 2200
+                sql = template.render(scid=public_schema_id)
+
+                cursor = connection.cursor()
+                cursor.execute(sql)
+                fetch_result = cursor.fetchall()
+
+                first_row = {}
+                for index, description in enumerate(cursor.description):
+                    first_row[description.name] = fetch_result[0][index]
+
+                print first_row
+
+                oid = first_row['oid']
+                name = first_row['name']
+                triggercount = first_row['triggercount']
+                has_enable_triggers = first_row['has_enable_triggers']
+
+                self.assertIsNotNone(long(oid))
+                self.assertEqual('test_table', name)
+                # triggercount is sometimes returned as a string for some reason
+                self.assertEqual(0L, long(triggercount))
+                self.assertIsNotNone(long(has_enable_triggers))
+
+
+class SimpleTemplateLoader(BaseLoader):
+    def __init__(self, file_content):
+        self.file_content = file_content
+
+    def get_source(self, *args):
+        return self.file_content, "required-return-not-a-real-file.txt", True

web/regression/test_utils.py

@@ -134,6 +134,25 @@ def create_database(server, db_name):
         traceback.print_exc(file=sys.stderr)
 
 
+def create_table(server, db_name, table_name):
+    try:
+        connection = get_db_connection(db_name,
+                                       server['username'],
+                                       server['db_password'],
+                                       server['host'],
+                                       server['port'])
+        old_isolation_level = connection.isolation_level
+        connection.set_isolation_level(0)
+        pg_cursor = connection.cursor()
+        pg_cursor.execute('''CREATE TABLE "%s" (name VARCHAR, value NUMERIC)''' % table_name)
+        pg_cursor.execute('''INSERT INTO "%s" VALUES ('Some-Name', 6)''' % table_name)
+        connection.set_isolation_level(old_isolation_level)
+        connection.commit()
+
+    except Exception:
+        traceback.print_exc(file=sys.stderr)
+
+
 def drop_database(connection, database_name):
     """This function used to drop the database"""
     if database_name not in ["postgres", "template1", "template0"]:
@@ -389,3 +408,40 @@ def _drop_objects(tester):
 def get_cleanup_handler(tester):
     """This function use to bind variable to drop_objects function"""
     return partial(_drop_objects, tester)
+
+
+class Database:
+    """
+    Temporarily create and connect to a database, tear it down at exit
+
+    example:
+
+    with Database(server, 'some_test_db') as (connection, database_name):
+        connection.cursor().execute(...)
+
+    """
+
+    def __init__(self, server):
+        self.name = None
+        self.server = server
+        self.maintenance_connection = None
+        self.connection = None
+
+    def __enter__(self):
+        self.name = "test_db_{}".format(str(uuid.uuid4())[0:7])
+        self.maintenance_connection = get_db_connection(self.server['db'],
+                                                        self.server['username'],
+                                                        self.server['db_password'],
+                                                        self.server['host'],
+                                                        self.server['port'])
+        create_database(self.server, self.name)
+        self.connection = get_db_connection(self.name,
+                                            self.server['username'],
+                                            self.server['db_password'],
+                                            self.server['host'],
+                                            self.server['port'])
+        return self.connection, self.name
+
+    def __exit__(self, type, value, traceback):
+        self.connection.close()
+        drop_database(self.maintenance_connection, self.name)