def setUp(self): self.logger = Mock(spec=['log', 'info', 'debug', 'error']) self.db_connection = Mock(spec=['close', 'query']) self.autoCast = { 'regproc': '::oid', 'regprocedure': '::oid', 'regoper': '::oid', 'regoperator': '::oid', 'regclass': '::oid', 'regtype': '::oid', 'int2vector': '::int2[]' } self.subject = ForeignKeyCheck(self.db_connection, self.logger, False, self.autoCast) self.full_join_cat_tables = set([ 'pg_attribute', 'gp_distribution_policy', 'pg_appendonly', 'pg_constraint', 'pg_index' ]) self.foreign_key_check = Mock(spec=['runCheck']) self.foreign_key_check.runCheck.return_value = [] self.db_connection.query.return_value.ntuples.return_value = 2 self.db_connection.query.return_value.listfields.return_value = [ 'pkey1', 'pkey2' ] self.db_connection.query.return_value.getresult.return_value = [ ('r1', 'r2'), ('r3', 'r4') ]
def setUp(self): self.logger = Mock(spec=['log', 'info', 'debug', 'error']) self.db_connection = Mock(spec=['close', 'query']) self.autoCast = {'regproc': '::oid', 'regprocedure': '::oid', 'regoper': '::oid', 'regoperator': '::oid', 'regclass': '::oid', 'regtype': '::oid', 'int2vector': '::int2[]'} self.subject = ForeignKeyCheck(self.db_connection, self.logger, False, self.autoCast) self.full_join_cat_tables = set(['pg_attribute','gp_distribution_policy','pg_appendonly','pg_constraint','pg_index']) self.foreign_key_check= Mock(spec=['runCheck']) self.foreign_key_check.runCheck.return_value = [] self.db_connection.query.return_value.ntuples.return_value = 2 self.db_connection.query.return_value.listfields.return_value = ['pkey1', 'pkey2'] self.db_connection.query.return_value.getresult.return_value = [('r1','r2'), ('r3','r4')]
class GpCheckCatTestCase(GpTestCase): def setUp(self): self.logger = Mock(spec=['log', 'info', 'debug', 'error']) self.db_connection = Mock(spec=['close', 'query']) self.autoCast = { 'regproc': '::oid', 'regprocedure': '::oid', 'regoper': '::oid', 'regoperator': '::oid', 'regclass': '::oid', 'regtype': '::oid', 'int2vector': '::int2[]' } self.subject = ForeignKeyCheck(self.db_connection, self.logger, False, self.autoCast) self.full_join_cat_tables = set([ 'pg_attribute', 'gp_distribution_policy', 'pg_appendonly', 'pg_constraint', 'pg_index' ]) self.foreign_key_check = Mock(spec=['runCheck']) self.foreign_key_check.runCheck.return_value = [] self.db_connection.query.return_value.ntuples.return_value = 2 self.db_connection.query.return_value.listfields.return_value = [ 'pkey1', 'pkey2' ] self.db_connection.query.return_value.getresult.return_value = [ ('r1', 'r2'), ('r3', 'r4') ] def test_get_fk_query_left_join_returns_the_correct_query(self): expected_query = """ SELECT pkeys-1, pkeys-2, missing_catalog, present_key, pkcatname_pkeystr, array_agg(gp_segment_id order by gp_segment_id) as segids FROM ( SELECT (case when cat1.fkeystr is not NULL then 'pkcatname' when cat2.pkeystr is not NULL then 'catname' end) as missing_catalog, (case when cat1.fkeystr is not NULL then 'fkeystr' when cat2.pkeystr is not NULL then 'pkeystr' end) as present_key, cat1.gp_segment_id, cat1pkeys-1, cat1pkeys-2, cat1.fkeystr as pkcatname_pkeystr FROM gp_dist_random('catname') cat1 LEFT OUTER JOIN gp_dist_random('pkcatname') cat2 ON (cat1.gp_segment_id = cat2.gp_segment_id AND cat1.fkeystr = cat2.pkeystr ) WHERE cat2.pkeystr is NULL AND cat1.fkeystr != 0 UNION ALL SELECT (case when cat1.fkeystr is not NULL then 'pkcatname' when cat2.pkeystr is not NULL then 'catname' end) as missing_catalog, (case when cat1.fkeystr is not NULL then 'fkeystr' when cat2.pkeystr is not NULL then 'pkeystr' end) as present_key, -1 as gp_segment_id, cat1pkeys-1, cat1pkeys-2, cat1.fkeystr as pkcatname_pkeystr FROM catname cat1 LEFT OUTER JOIN pkcatname cat2 ON (cat1.gp_segment_id = cat2.gp_segment_id AND cat1.fkeystr = cat2.pkeystr ) WHERE cat2.pkeystr is NULL AND cat1.fkeystr != 0 ORDER BY pkeys-1, pkeys-2, gp_segment_id ) allresults GROUP BY pkeys-1, pkeys-2, pkcatname_pkeystr, missing_catalog, present_key """ result_query = self.subject.get_fk_query_left_join( "catname", "pkcatname", "fkeystr", "pkeystr", ["pkeys-1", "pkeys-2"], ["cat1pkeys-1", "cat1pkeys-2"]) self.assertEquals(expected_query, result_query) def test_get_fk_query_full_join_returns_the_correct_query(self): expected_query = """ SELECT pkeys-1, pkeys-2, missing_catalog, present_key, pkcatname_pkeystr, array_agg(gp_segment_id order by gp_segment_id) as segids FROM ( SELECT (case when cat1.fkeystr is not NULL then 'pkcatname' when cat2.pkeystr is not NULL then 'catname' end) as missing_catalog, (case when cat1.fkeystr is not NULL then 'fkeystr' when cat2.pkeystr is not NULL then 'pkeystr' end) as present_key, COALESCE(cat1.gp_segment_id,cat2.gp_segment_id) as gp_segment_id , cat1pkeys-1, cat1pkeys-2, COALESCE(cat1.fkeystr, cat2.pkeystr) as pkcatname_pkeystr FROM gp_dist_random('catname') cat1 FULL OUTER JOIN gp_dist_random('pkcatname') cat2 ON (cat1.gp_segment_id = cat2.gp_segment_id AND cat1.fkeystr = cat2.pkeystr ) WHERE (cat2.pkeystr is NULL or cat1.fkeystr is NULL) AND filter UNION ALL SELECT (case when cat1.fkeystr is not NULL then 'pkcatname' when cat2.pkeystr is not NULL then 'catname' end) as missing_catalog, (case when cat1.fkeystr is not NULL then 'fkeystr' when cat2.pkeystr is not NULL then 'pkeystr' end) as present_key, -1, cat1pkeys-1, cat1pkeys-2, COALESCE(cat1.fkeystr, cat2.pkeystr) as pkcatname_pkeystr FROM catname cat1 FULL OUTER JOIN pkcatname cat2 ON (cat1.gp_segment_id = cat2.gp_segment_id AND cat1.fkeystr = cat2.pkeystr ) WHERE (cat2.pkeystr is NULL or cat1.fkeystr is NULL) AND filter ORDER BY pkeys-1, pkeys-2, gp_segment_id ) allresults GROUP BY pkeys-1, pkeys-2, pkcatname_pkeystr, missing_catalog, present_key """ result_query = self.subject.get_fk_query_full_join( "catname", "pkcatname", "fkeystr", "pkeystr", ["pkeys-1", "pkeys-2"], ["cat1pkeys-1", "cat1pkeys-2"], "filter") self.assertEquals(expected_query, result_query) @patch( 'gpcheckcat_modules.foreign_key_check.ForeignKeyCheck.checkTableForeignKey' ) def test_runCheck(self, mock): tables = [ self._get_mock_for_catalog_table("table1"), self._get_mock_for_catalog_table("table2") ] self.subject.runCheck(tables) self.assertEquals( len(self.subject.checkTableForeignKey.call_args_list), len(tables)) for table in tables: self.assertIn(call(table), self.subject.checkTableForeignKey.call_args_list) @patch( 'gpcheckcat_modules.foreign_key_check.ForeignKeyCheck.get_fk_query_full_join' ) @patch( 'gpcheckcat_modules.foreign_key_check.ForeignKeyCheck.get_fk_query_left_join' ) @patch('gpcheckcat_modules.foreign_key_check.log_literal') def test_checkTableForeignKey__returns_correct_join_query( self, log_literal_mock, fk_query_left_join_mock, fk_query_full_join_mock): #cat_tables_to_validate = set(['pg_attribute','gp_distribution_policy','pg_appendonly','pg_constraint','pg_index','pg_type','pg_window']) cat_tables_to_validate = set([ 'pg_attribute', 'pg_appendonly', 'pg_index', 'pg_type', 'pg_window' ]) foreign_key_mock_calls = [] foreign_key_mock_calls_left = [] for table_name in cat_tables_to_validate: foreign_key_mock_1 = self._get_mock_for_foreign_key( pkey_tablename="pg_class", cat_table_name=table_name) foreign_key_mock_2 = self._get_mock_for_foreign_key( pkey_tablename="arbitrary_catalog_table", cat_table_name=table_name) catalog_table_mock = self._get_mock_for_catalog_table( table_name, [foreign_key_mock_1, foreign_key_mock_2]) col_type = self._get_col_types(table_name) issue_list = self.subject.checkTableForeignKey(catalog_table_mock) self.assertEquals(len(issue_list), 2) self.assertEquals(issue_list[0], ('pg_class', ['pkey1', 'pkey2'], [('r1', 'r2'), ('r3', 'r4')])) self.assertEquals(issue_list[1], ('arbitrary_catalog_table', ['pkey1', 'pkey2' ], [('r1', 'r2'), ('r3', 'r4')])) self.assertEquals(self.db_connection.query.call_count, 2) def __generate_pg_class_call(table, primary_key_cat_name, col_type, with_filter=True): if with_filter: return call( table_name, '%s' % primary_key_cat_name, '%s' % col_type.keys()[0], 'oid', ['%s_pkey1' % (table_name), '%s_pkey2' % (table_name)], filter=self._get_filter(table_name), cat1pkeys=[ 'cat1.pkey1 as %s_pkey1' % (table_name), 'cat1.pkey2 as %s_pkey2' % (table_name) ]) else: return call( table_name, '%s' % primary_key_cat_name, '%s' % col_type.keys()[0], 'oid', ['%s_pkey1' % (table_name), '%s_pkey2' % (table_name)], [ 'cat1.pkey1 as %s_pkey1' % (table_name), 'cat1.pkey2 as %s_pkey2' % (table_name) ]) # make sure that the correct pg_class_call is used depending on the # foreign key # XXX: if we know that it's the fake catalog, then we can assume # that it will do a left join... we need to figure that out if table_name in self.full_join_cat_tables: pg_class_call = __generate_pg_class_call(table_name, 'pg_class', col_type, with_filter=True) foreign_key_mock_calls.append(pg_class_call) pg_class_call = __generate_pg_class_call( table_name, 'arbitrary_catalog_table', col_type, with_filter=False) foreign_key_mock_calls_left.append(pg_class_call) else: pg_class_call = __generate_pg_class_call(table_name, 'pg_class', col_type, with_filter=False) foreign_key_mock_calls_left.append(pg_class_call) if table_name in self.full_join_cat_tables: self.assertEquals(fk_query_full_join_mock.call_count, 1) self.assertEquals(fk_query_left_join_mock.call_count, 1) fk_query_full_join_mock.assert_has_calls( foreign_key_mock_calls, any_order=False) else: arbitrary_catalog_table_call = __generate_pg_class_call( table_name, 'arbitrary_catalog_table', col_type, with_filter=False) foreign_key_mock_calls_left.append( arbitrary_catalog_table_call) self.assertEquals(fk_query_left_join_mock.call_count, 2) self.assertEquals(fk_query_full_join_mock.call_count, 0) fk_query_left_join_mock.assert_has_calls( foreign_key_mock_calls_left, any_order=False) self.db_connection.query.call_count = 0 fk_query_full_join_mock.call_count = 0 fk_query_left_join_mock.call_count = 0 ####################### PRIVATE METHODS ####################### def _get_filter(self, table_name): query_filters = {} query_filters['pg_appendonly'] = "(relstorage='a' or relstorage='c')" query_filters['pg_attribute'] = "true" query_filters[ 'pg_constraint'] = "((relchecks>0 or relhaspkey='t') and relkind = 'r')" query_filters[ 'gp_distribution_policy'] = """(relnamespace not in(select oid from pg_namespace where nspname ~ 'pg_') and relnamespace not in(select oid from pg_namespace where nspname ~ 'gp_') and relnamespace!=(select oid from pg_namespace where nspname='information_schema') and relkind='r' and (relstorage='a' or relstorage='h' or relstorage='c'))""" query_filters["pg_index"] = "(relkind='i')" if table_name in query_filters: return query_filters[table_name] else: return [] def _get_col_types(self, table_name): table_col_types = { 'pg_attribute': { 'attlen': 'int2', 'atthasdef': 'bool', 'attndims': 'int4', 'attnum': 'int2', 'attname': 'name', 'attalign': 'char', 'attnotnull': 'bool', 'atttypid': 'oid', 'attrelid': 'oid', 'attinhcount': 'int4', 'attcacheoff': 'int4', 'attislocal': 'bool', 'attstattarget': 'int4', 'attstorage': 'char', 'attbyval': 'bool', 'atttypmod': 'int4', 'attisdropped': 'bool' }, 'pg_appendonly': { 'relid': 'oid' }, 'pg_attribute': { 'attrelid': 'oid' }, 'pg_constraint': { 'conrelid': 'oid' }, 'pg_index': { 'indexrelid': 'oid' }, 'gp_distribution_policy': {} } if table_name not in table_col_types.keys(): table_name = 'pg_attribute' return table_col_types[table_name] def _get_mock_for_catalog_table(self, table_name, foreign_keys=None): catalog_table_mock = Mock(spec=[ 'getTableName', 'isShared', 'getForeignKeys', 'getPrimaryKey', 'getTableColtypes' ]) catalog_table_mock.getTableName.return_value = table_name catalog_table_mock.isShared.return_value = True catalog_table_mock.getForeignKeys.return_value = foreign_keys catalog_table_mock.getPrimaryKey.return_value = ["pkey1", "pkey2"] catalog_table_mock.getTableColtypes.return_value = self._get_col_types( table_name) return catalog_table_mock def _get_mock_for_foreign_key(self, pkey_tablename, cat_table_name): spec_list = ['getPKey', 'getPkeyTableName', 'getColumns'] filter_mapping = { 'pg_appendonly': ['relid'], 'pg_attribute': ['attrelid'], 'pg_constraint': ['conrelid'], 'pg_index': ['indexrelid'], 'gp_distribution_policy': [] } attribute_foreign_key_mock = Mock(spec=spec_list) attribute_foreign_key_mock.getPKey.return_value = ['oid'] attribute_foreign_key_mock.getPkeyTableName.return_value = pkey_tablename query_filter = ['attrelid'] if cat_table_name in filter_mapping: query_filter = filter_mapping[cat_table_name] attribute_foreign_key_mock.getColumns.return_value = query_filter return attribute_foreign_key_mock
class GpCheckCatTestCase(GpTestCase): def setUp(self): self.logger = Mock(spec=['log', 'info', 'debug', 'error']) self.db_connection = Mock(spec=['close', 'query']) self.autoCast = {'regproc': '::oid', 'regprocedure': '::oid', 'regoper': '::oid', 'regoperator': '::oid', 'regclass': '::oid', 'regtype': '::oid', 'int2vector': '::int2[]'} self.subject = ForeignKeyCheck(self.db_connection, self.logger, False, self.autoCast) self.full_join_cat_tables = set(['pg_attribute','gp_distribution_policy','pg_appendonly','pg_constraint','pg_index']) self.foreign_key_check= Mock(spec=['runCheck']) self.foreign_key_check.runCheck.return_value = [] self.db_connection.query.return_value.ntuples.return_value = 2 self.db_connection.query.return_value.listfields.return_value = ['pkey1', 'pkey2'] self.db_connection.query.return_value.getresult.return_value = [('r1','r2'), ('r3','r4')] def test_get_fk_query_left_join_returns_the_correct_query(self): expected_query = """ SELECT pkeys-1, pkeys-2, missing_catalog, present_key, pkcatname_pkeystr, array_agg(gp_segment_id order by gp_segment_id) as segids FROM ( SELECT (case when cat1.fkeystr is not NULL then 'pkcatname' when cat2.pkeystr is not NULL then 'catname' end) as missing_catalog, (case when cat1.fkeystr is not NULL then 'fkeystr' when cat2.pkeystr is not NULL then 'pkeystr' end) as present_key, cat1.gp_segment_id, cat1pkeys-1, cat1pkeys-2, cat1.fkeystr as pkcatname_pkeystr FROM gp_dist_random('catname') cat1 LEFT OUTER JOIN gp_dist_random('pkcatname') cat2 ON (cat1.gp_segment_id = cat2.gp_segment_id AND cat1.fkeystr = cat2.pkeystr ) WHERE cat2.pkeystr is NULL AND cat1.fkeystr != 0 UNION ALL SELECT (case when cat1.fkeystr is not NULL then 'pkcatname' when cat2.pkeystr is not NULL then 'catname' end) as missing_catalog, (case when cat1.fkeystr is not NULL then 'fkeystr' when cat2.pkeystr is not NULL then 'pkeystr' end) as present_key, -1 as gp_segment_id, cat1pkeys-1, cat1pkeys-2, cat1.fkeystr as pkcatname_pkeystr FROM catname cat1 LEFT OUTER JOIN pkcatname cat2 ON (cat1.gp_segment_id = cat2.gp_segment_id AND cat1.fkeystr = cat2.pkeystr ) WHERE cat2.pkeystr is NULL AND cat1.fkeystr != 0 ORDER BY pkeys-1, pkeys-2, gp_segment_id ) allresults GROUP BY pkeys-1, pkeys-2, pkcatname_pkeystr, missing_catalog, present_key """ result_query = self.subject.get_fk_query_left_join("catname", "pkcatname", "fkeystr", "pkeystr", ["pkeys-1", "pkeys-2"], ["cat1pkeys-1", "cat1pkeys-2"]) self.assertEquals(expected_query, result_query) def test_get_fk_query_full_join_returns_the_correct_query(self): expected_query = """ SELECT pkeys-1, pkeys-2, missing_catalog, present_key, pkcatname_pkeystr, array_agg(gp_segment_id order by gp_segment_id) as segids FROM ( SELECT (case when cat1.fkeystr is not NULL then 'pkcatname' when cat2.pkeystr is not NULL then 'catname' end) as missing_catalog, (case when cat1.fkeystr is not NULL then 'fkeystr' when cat2.pkeystr is not NULL then 'pkeystr' end) as present_key, COALESCE(cat1.gp_segment_id,cat2.gp_segment_id) as gp_segment_id , cat1pkeys-1, cat1pkeys-2, COALESCE(cat1.fkeystr, cat2.pkeystr) as pkcatname_pkeystr FROM gp_dist_random('catname') cat1 FULL OUTER JOIN gp_dist_random('pkcatname') cat2 ON (cat1.gp_segment_id = cat2.gp_segment_id AND cat1.fkeystr = cat2.pkeystr ) WHERE (cat2.pkeystr is NULL or cat1.fkeystr is NULL) AND filter UNION ALL SELECT (case when cat1.fkeystr is not NULL then 'pkcatname' when cat2.pkeystr is not NULL then 'catname' end) as missing_catalog, (case when cat1.fkeystr is not NULL then 'fkeystr' when cat2.pkeystr is not NULL then 'pkeystr' end) as present_key, -1, cat1pkeys-1, cat1pkeys-2, COALESCE(cat1.fkeystr, cat2.pkeystr) as pkcatname_pkeystr FROM catname cat1 FULL OUTER JOIN pkcatname cat2 ON (cat1.gp_segment_id = cat2.gp_segment_id AND cat1.fkeystr = cat2.pkeystr ) WHERE (cat2.pkeystr is NULL or cat1.fkeystr is NULL) AND filter ORDER BY pkeys-1, pkeys-2, gp_segment_id ) allresults GROUP BY pkeys-1, pkeys-2, pkcatname_pkeystr, missing_catalog, present_key """ result_query = self.subject.get_fk_query_full_join("catname", "pkcatname", "fkeystr", "pkeystr", ["pkeys-1", "pkeys-2"], ["cat1pkeys-1", "cat1pkeys-2"], "filter") self.assertEquals(expected_query, result_query) @patch('gpcheckcat_modules.foreign_key_check.ForeignKeyCheck.checkTableForeignKey') def test_runCheck(self, mock): tables = [self._get_mock_for_catalog_table("table1"), self._get_mock_for_catalog_table("table2")] self.subject.runCheck(tables) self.assertEquals(len(self.subject.checkTableForeignKey.call_args_list), len(tables)) for table in tables: self.assertIn(call(table), self.subject.checkTableForeignKey.call_args_list) @patch('gpcheckcat_modules.foreign_key_check.ForeignKeyCheck.get_fk_query_full_join') @patch('gpcheckcat_modules.foreign_key_check.ForeignKeyCheck.get_fk_query_left_join') @patch('gpcheckcat_modules.foreign_key_check.log_literal') def test_checkTableForeignKey__returns_correct_join_query(self, log_literal_mock, fk_query_left_join_mock, fk_query_full_join_mock): #cat_tables_to_validate = set(['pg_attribute','gp_distribution_policy','pg_appendonly','pg_constraint','pg_index','pg_type','pg_window']) cat_tables_to_validate = set(['pg_attribute', 'pg_appendonly', 'pg_index','pg_type','pg_window']) foreign_key_mock_calls = [] foreign_key_mock_calls_left = [] for table_name in cat_tables_to_validate: foreign_key_mock_1 = self._get_mock_for_foreign_key(pkey_tablename="pg_class", cat_table_name=table_name) foreign_key_mock_2 = self._get_mock_for_foreign_key(pkey_tablename="arbitrary_catalog_table", cat_table_name=table_name) catalog_table_mock = self._get_mock_for_catalog_table(table_name, [foreign_key_mock_1, foreign_key_mock_2]) col_type = self._get_col_types(table_name) issue_list = self.subject.checkTableForeignKey(catalog_table_mock) self.assertEquals(len(issue_list) , 2) self.assertEquals(issue_list[0], ('pg_class', ['pkey1', 'pkey2'], [('r1', 'r2'), ('r3', 'r4')])) self.assertEquals(issue_list[1], ('arbitrary_catalog_table', ['pkey1', 'pkey2'], [('r1', 'r2'), ('r3', 'r4')])) self.assertEquals(self.db_connection.query.call_count, 2) def __generate_pg_class_call(table, primary_key_cat_name, col_type, with_filter=True): if with_filter: return call(table_name, '%s' % primary_key_cat_name, '%s' % col_type.keys()[0], 'oid', ['%s_pkey1' % (table_name), '%s_pkey2' % (table_name)], filter=self._get_filter(table_name), cat1pkeys=['cat1.pkey1 as %s_pkey1' % (table_name), 'cat1.pkey2 as %s_pkey2' % (table_name)]) else: return call(table_name, '%s' % primary_key_cat_name, '%s' % col_type.keys()[0], 'oid', ['%s_pkey1' % (table_name), '%s_pkey2' % (table_name)], ['cat1.pkey1 as %s_pkey1' % (table_name), 'cat1.pkey2 as %s_pkey2' % (table_name)]) # make sure that the correct pg_class_call is used depending on the # foreign key # XXX: if we know that it's the fake catalog, then we can assume # that it will do a left join... we need to figure that out if table_name in self.full_join_cat_tables: pg_class_call = __generate_pg_class_call(table_name, 'pg_class', col_type, with_filter=True) foreign_key_mock_calls.append(pg_class_call) pg_class_call = __generate_pg_class_call(table_name, 'arbitrary_catalog_table', col_type, with_filter=False) foreign_key_mock_calls_left.append(pg_class_call) else: pg_class_call = __generate_pg_class_call(table_name, 'pg_class', col_type, with_filter=False) foreign_key_mock_calls_left.append(pg_class_call) if table_name in self.full_join_cat_tables: self.assertEquals(fk_query_full_join_mock.call_count, 1) self.assertEquals(fk_query_left_join_mock.call_count, 1) fk_query_full_join_mock.assert_has_calls(foreign_key_mock_calls, any_order=False) else: arbitrary_catalog_table_call = __generate_pg_class_call(table_name, 'arbitrary_catalog_table', col_type, with_filter=False) foreign_key_mock_calls_left.append(arbitrary_catalog_table_call) self.assertEquals(fk_query_left_join_mock.call_count, 2) self.assertEquals(fk_query_full_join_mock.call_count, 0) fk_query_left_join_mock.assert_has_calls(foreign_key_mock_calls_left, any_order=False) self.db_connection.query.call_count = 0 fk_query_full_join_mock.call_count = 0 fk_query_left_join_mock.call_count = 0 ####################### PRIVATE METHODS ####################### def _get_filter(self, table_name): query_filters = {} query_filters['pg_appendonly'] = "(relstorage='a' or relstorage='c')" query_filters['pg_attribute'] = "true" query_filters['pg_constraint'] = "((relchecks>0 or relhaspkey='t') and relkind = 'r')" query_filters['gp_distribution_policy'] = """(relnamespace not in(select oid from pg_namespace where nspname ~ 'pg_') and relnamespace not in(select oid from pg_namespace where nspname ~ 'gp_') and relnamespace!=(select oid from pg_namespace where nspname='information_schema') and relkind='r' and (relstorage='a' or relstorage='h' or relstorage='c'))""" query_filters["pg_index"] = "(relkind='i')" if table_name in query_filters: return query_filters[table_name] else: return [] def _get_col_types(self, table_name): table_col_types = {'pg_attribute': {'attlen': 'int2', 'atthasdef': 'bool', 'attndims': 'int4', 'attnum': 'int2', 'attname': 'name', 'attalign': 'char', 'attnotnull': 'bool', 'atttypid': 'oid', 'attrelid': 'oid', 'attinhcount': 'int4', 'attcacheoff': 'int4', 'attislocal': 'bool', 'attstattarget': 'int4', 'attstorage': 'char', 'attbyval': 'bool', 'atttypmod': 'int4', 'attisdropped': 'bool'}, 'pg_appendonly': {'relid': 'oid'}, 'pg_attribute': {'attrelid': 'oid'}, 'pg_constraint': {'conrelid': 'oid'}, 'pg_index': {'indexrelid': 'oid'}, 'gp_distribution_policy': {} } if table_name not in table_col_types.keys(): table_name = 'pg_attribute' return table_col_types[table_name] def _get_mock_for_catalog_table(self, table_name, foreign_keys=None): catalog_table_mock = Mock(spec=['getTableName','isShared','getForeignKeys','getPrimaryKey','getTableColtypes']) catalog_table_mock.getTableName.return_value = table_name catalog_table_mock.isShared.return_value = True catalog_table_mock.getForeignKeys.return_value = foreign_keys catalog_table_mock.getPrimaryKey.return_value = ["pkey1", "pkey2"] catalog_table_mock.getTableColtypes.return_value = self._get_col_types(table_name) return catalog_table_mock def _get_mock_for_foreign_key(self, pkey_tablename, cat_table_name): spec_list = ['getPKey', 'getPkeyTableName', 'getColumns'] filter_mapping = {'pg_appendonly': ['relid'], 'pg_attribute': ['attrelid'], 'pg_constraint': ['conrelid'], 'pg_index': ['indexrelid'], 'gp_distribution_policy': [] } attribute_foreign_key_mock = Mock(spec=spec_list) attribute_foreign_key_mock.getPKey.return_value = ['oid'] attribute_foreign_key_mock.getPkeyTableName.return_value = pkey_tablename query_filter = ['attrelid'] if cat_table_name in filter_mapping: query_filter = filter_mapping[cat_table_name] attribute_foreign_key_mock.getColumns.return_value = query_filter return attribute_foreign_key_mock