Exemple #1
0
class PlrMPPTestCase(MPPTestCase):
    def __init__(self, methodName):
        self.pl = ProceduralLanguage()
        self.language = 'plr'
        super(PlrMPPTestCase, self).__init__(methodName)

    @classmethod
    def setUpClass(self):
        super(PlrMPPTestCase, self).setUpClass()
        gppkg = Gppkg()
        gppkg.gppkg_install(product_version, 'plr')

    def setUp(self):
        """
        @summary: Overrides setUp for gptest to check if current OS is supported for gppkg.  If not, test is skipped.
        
        """
        if self.pl.gppkg_os.find('rhel') < 0 and self.pl.gppkg_os.find(
                'suse') < 0:
            self.skipTest(
                'TEST SKIPPED: pljava is only supported on RHEL and SuSE. Skipping test.'
            )

    def tearDown(self):
        pass

    def test_install_Plr(self):
        """Install plr"""
        if self.pl.language_in_db(self.language) == True:
            self.pl.drop_lanaguage_from_db(self.language)
        self.assertTrue(self.pl.create_language_in_db(self.language))

    def test_uninstall_Plr(self):
        """uninstall plr language"""
        if self.pl.language_in_db(self.language) == False:
            self.pl.create_language_in_db(self.language)
        self.assertTrue(self.pl.drop_lanaguage_from_db(self.language))
Exemple #2
0
class PlrMPPTestCase(MPPTestCase):


    def __init__(self, methodName):
        self.pl = ProceduralLanguage()
        self.language = 'plr'
        super(PlrMPPTestCase, self).__init__(methodName)

    @classmethod
    def setUpClass(self):
        super(PlrMPPTestCase, self).setUpClass()
        gppkg = Gppkg()
        gppkg.gppkg_install(product_version, 'plr')

    def setUp(self):
        """
        @summary: Overrides setUp for gptest to check if current OS is supported for gppkg.  If not, test is skipped.
        
        """
        if self.pl.gppkg_os.find('rhel') < 0 and self.pl.gppkg_os.find('suse') < 0:
            self.skipTest('TEST SKIPPED: plr is only supported on RHEL and SuSE. Skipping test.')

    def tearDown(self):
        pass

    def test_install_Plr(self):
        """Install plr"""
        if self.pl.language_in_db(self.language) == True:
            self.pl.drop_lanaguage_from_db(self.language)
        self.assertTrue(self.pl.create_language_in_db(self.language))


    def test_uninstall_Plr(self):
        """uninstall plr language"""
        if self.pl.language_in_db(self.language) == False:
            self.pl.create_language_in_db(self.language)
        self.assertTrue(self.pl.drop_lanaguage_from_db(self.language))
Exemple #3
0
 def __init__(self, methodName):
     self.pl = ProceduralLanguage()
     self.language = 'plperl'
     super(PlperlMPPTestCase, self).__init__(methodName)
Exemple #4
0
 def __init__(self, methodName):
     self.pl = ProceduralLanguage()
     self.language = 'plr'
     super(PlrMPPTestCase, self).__init__(methodName)
Exemple #5
0
 def __init__(self, methodName):
     self.pl = ProceduralLanguage()
     self.gpdb = GpdbSystem()
     super(PlPgsqlCachingTest, self).__init__(methodName)
Exemple #6
0
class PlPgsqlCachingTest(MPPTestCase):
    """
    @summary: Test class for MPP-16428 - Improve plan caching in PL/pgsql. Extends ProceduralLanguageTestCase
    
    """
    def __init__(self, methodName):
        self.pl = ProceduralLanguage()
        self.gpdb = GpdbSystem()
        super(PlPgsqlCachingTest, self).__init__(methodName)

    @classmethod
    def setUpClass(cls):
        sql_files = ['negative_cachedplan_cmdutility_drop.sql', 'recursive_functions_droprecreatetable.sql', 'reexec_functioninwhere_droprecreateao.sql']
        ans_files = ['negative_cachedplan_cmdutility_drop.ans', 'recursive_functions_droprecreatetable.ans', 'reexec_functioninwhere_droprecreateao.ans']
        if product_version.startswith('4.2'):
            plpg.pre_process(sql_files, ans_files)

    def setUp(self):
        self.do_test_fixture('setup')

    def tearDown(self):
        self.do_test_fixture('teardown')
     
    def do_test_fixture(self, fixture):
        """
        @summary: Runs a setup or teardown routine
        
        @param fixture: Set to either 'setup' or 'teardown'. Used to determine sql file suffix.
        """
        testcase1 = inspect.stack()[1][3] 
        testcase = self.id().split(".")[2]
        init_file = local_path('init_file') 
        init_file_list = []
        init_file_list.append(init_file)
        if fixture == 'setup':
            sqlfile = local_path(testcase + "_setup.sql")
            outfile = local_path(testcase + "_setup.out")
            ansfile = local_path(testcase + "_setup.ans")
        elif fixture == 'teardown':
            sqlfile = local_path(testcase + "_teardown.sql")
            outfile = local_path(testcase + "_teardown.out")
            ansfile = local_path(testcase + "_teardown.ans")
        else:
            raise Exception("do_test_fixture(): Invalid value for fixture. Acceptable values are 'setup' or 'teardown'")
        
        # check if setup sql file exists
        if os.path.isfile(sqlfile):
            # if exists, run setup sql, and validate result
            PSQL.run_sql_file(sql_file = sqlfile, out_file = outfile)            
            Gpdiff.are_files_equal(outfile, ansfile, match_sub=init_file_list)
        else:
            pass
    
    def install_plperl(self):
        """
        @summary: Installs plperl gppkg and creates plperl language in database if it doesn't exist
        
        """
        gppkg = Gppkg()
        gppkg.gppkg_install(product_version, 'plperl')
        if self.pl.language_in_db('plperl') == False:
            self.pl.create_language_in_db('plperl')
            
    def check_plperl_env(self):
        """
        @summary: Checks if environment is suitable for plperl test since it requires gppkg, which is only supported on RHEL and SuSE
        
        """
        if self.pl.gppkg_os.find('rhel') < 0 and self.pl.gppkg_os.find('suse') < 0:
            self.skipTest('TEST SKIPPED: Test requires plperl. gppkg is only supported on RHEL and SuSE. Skipping test')


    def create_language_plpython(self):
        """
        @summary: Creates plpython language in database if it doesn't exist
        
        """

        if self.pl.language_in_db("plpythonu") == False:
            tinctest.logger.info("plperl language doesn't exist in database. Creating language...")
            self.pl.create_language_in_db("plpythonu")


    def do_test(self, timeout=0, sqlfile=None, host=None, port=None, username=None, password=None, flags='-a', ans_version=False):
        """
        @summary: Run a test case
        
        @param timeout: Number of seconds to run sql file before timing out
        @param sqlfile: The path to sql file (relative to TEST.py directory)
        @param host: The GPDB master host name to use to connect to database
        @param port: The GPDB port used to make connections to the database
        @param username: The database username to use to connect to the database
        @param password: The password for the database user used to connect to database
        """
        (gpdb_version, build) = self.gpdb.GetGpdbVersion()
        if sqlfile is None:
            testcase = inspect.stack()[1][3]
            filename = testcase.split('test_')[1]
            sql_file = local_path(filename +".sql")
            out_file = local_path(filename + ".out")
            ans_file = local_path(filename + ".ans")
        else:
            sql_file = local_path(sqlfile)
            out_file = local_path(sqlfile.split('.')[0] + '.out')
            ans_file = local_path(sqlfile.split('.')[0] + '.ans')
        if ans_version:
            (gpdb_version, _) = self.gpdb.GetGpdbVersion()
            if gpdb_version.startswith('4.3'):
                ans_file = ans_file+'.4.3'

        init_file = local_path('init_file')
        init_file_list = []
        init_file_list.append(init_file)

        # run psql on file, and check result
        PSQL.run_sql_file(sql_file=sql_file, out_file=out_file, timeout=timeout, host=host, port=port, username=username, password=password,flags=flags)
        self.assertTrue(Gpdiff.are_files_equal(out_file, ans_file, match_sub=init_file_list))

    def test_reexec_functioninselect_droprecreateheap(self):
        """plpgsql caching: Re-execute function in select list. Function drops and recreates heap table."""
        self.do_test()
    
    def test_reexec_functioninwhere_droprecreateao(self):
        """plpgsql caching: Re-execute function in where clause list. Function drops and recreates AO/CO compressed table."""
        self.do_test()
        
    def test_cursors_droprecreate_tablereferencedbycursor(self):
        """plpgsql caching: Curors - Re-execute function that drops and recreates a heap table referenced by a cursor"""
        self.do_test()
        
    def test_cursors_forloop_droprecreatetable(self):
        """plpgsql caching: Cursors - Execute a function that has a for loop which drops and recreates a table at each iteration"""
        self.do_test()
        
    def test_temptables_droprecreate_temptable(self):
        """plpgsql caching: Temp Tables - Execute function that drops and recreates temp table."""
        self.do_test()
        
    def test_nestedfunc_1level_droprecreate_function(self):
        """plpgsql caching: Nested Functions - Drop-recreate a nested function in between function calls."""
        self.do_test()
        
    def test_nestedfunc_3levels_droprecreate_table(self):
        """plpgsql caching: Nested Functions - 3 levels of function calls, drop-recreate a table reference by one of the functions in between function calls."""
        self.do_test()
        
    def test_nestedfunc_3levels_redefinefunc(self):
        """plpgsql caching: Nested Functions - 3 levels of function calls, change contents of nested function in between function calls."""
        self.do_test()
    
    def test_reexec_function_splitpartition(self):
        """plpgsql caching: Partitioned Tables - Re-execute function after splitting partitioned table referenced in function."""
        self.do_test()
    
    def test_recursive_functions_droprecreatetable(self):
        """plpgsql caching: Recursive Functions - Drop and recreate AO table referenced in recursive plpgsql function"""
        self.do_test()
        
    def test_views_redefine_view(self):
        """plpgsql caching: Views - Change definition of view referenced in plpgsql function in between function calls."""
        result = PSQL.run_sql_command("show optimizer", dbname="postgres", flags='-q -t') 
        optimizer = result.strip()

        if optimizer == "on":
            self.do_test()
        else:
            self.skipTest("MPP-20715: Function involving view gives wrong results with planner")
        
    def test_masteronly_redefine_view(self):
        """plpgsql caching: Master Only - Change definition of view referenced in plpgsql function in between function calls."""
        self.do_test()
        
    def test_negative_cachedplan_segmentquery(self):
        """plpgsql caching: Negative Test - Cache is not cleared. Run function query that is only compiled and executed on segments"""
        self.do_test()
        
    def test_negative_cachedplan_cmdutility_drop(self):
        """plpgsql caching: Negative Test - Cache is not cleared. Run function that runs a CMD_UTILITY statement - drop table"""
        self.do_test()
        
    def test_negative_cachedplan_cmdutility_create(self):
        """plpgsql caching: Negative Test - Cache is not cleared. Run function that runs a CMD_UTILITY statement - create table"""
        self.do_test()
    
    def test_negative_plperl_split_between_prepexec(self):
        """plpgsql caching: Negative Test - Non-plpgsql function: plperl. Split partition in between prepare and execute functions"""
        self.check_plperl_env()
        self.install_plperl()
        self.do_test()

    def test_negative_nocaching_plperl_drop_between_exec(self):
        """plpgsql caching: Negative Test - Non-plpgsql function: plperl. No caching test. Re-execute function after drop and recreate table."""
        self.check_plperl_env()
        self.install_plperl()
        self.do_test()

    def test_negative_nocaching_plperl_drop_recreate(self):
        """plpgsql caching: Negative Test - Non-plpgsql function: plperl. No caching test. Re-execute function after drop and recreate table in function."""
        self.check_plperl_env()
        self.install_plperl()
        self.do_test()

    def test_negative_plpython_drop_between_preexec(self):
        """plpgsql caching: Negative Test - Non-plpgsql function: plpython. Drop and recreate table in between prepare and execute functions"""
        self.create_language_plpython()
        self.do_test()

    def test_negative_nocaching_plpython_drop_between_exec(self):
        """plpgsql caching: Negative Test - Non-plpgsql function: plpython. No caching test. Re-execute function after drop and recreate table."""
        self.create_language_plpython()
        self.do_test()

    def test_negative_unsupported_drop_between_prepexec(self):
        """plpgsql caching: Negative Test - Unsupported: Drop and recreate table in between PREPARE and EXECUTE"""
        self.do_test(ans_version=True)