Method test_execute_rollback

tests/query_test/test_iceberg.py:368–437

Test for EXECUTE ROLLBACK.

(self, unique_database)

    self.run_test_case('QueryTest/iceberg-rollback-negative', vector)

  def test_execute_rollback(self, unique_database):
    """Test for EXECUTE ROLLBACK."""
    iceberg_catalogs = IcebergCatalogs(unique_database)
    for catalog_properties in iceberg_catalogs.get_iceberg_catalog_properties():
      # Create a table with multiple snapshots.
      tbl_name = unique_database + ".iceberg_execute_rollback"
      # We are setting the TIMEZONE query option in this test, so let's create a local
      # impala client.
      with self.create_impala_client() as impalad_client:
        orig_timezone = 'America/Los_Angeles'
        impalad_client.execute("SET TIMEZONE='" + orig_timezone + "'")
        impalad_client.execute("""
          create table {0} (i int) stored as iceberg
          TBLPROPERTIES ({1})""".format(tbl_name, catalog_properties))
        initial_snapshots = 3
        for i in range(initial_snapshots):
          impalad_client.execute("INSERT INTO {0} VALUES ({1})".format(tbl_name, i))
        snapshots = get_snapshots(impalad_client, tbl_name,
          expected_result_size=initial_snapshots)

        output = self.rollback_to_id(tbl_name, snapshots[1].get_snapshot_id())
        LOG.info("success output={0}".format(output))

        # We rolled back, but that creates a new snapshot, so now there are 4.
        snapshots = get_snapshots(impalad_client, tbl_name, expected_result_size=4)
        # The new snapshot has the same id (and parent id) as the snapshot we rolled back
        # to, but it has a different creation time.
        assert snapshots[1].get_snapshot_id() == snapshots[3].get_snapshot_id()
        assert snapshots[1].get_parent_id() == snapshots[3].get_parent_id()
        assert snapshots[1].get_creation_time() < snapshots[3].get_creation_time()
        # The "orphaned" snapshot is now not a current ancestor.
        assert not snapshots[2].is_current_ancestor()

        # We cannot roll back to a snapshot that is not a current ancestor.
        output = self.rollback_to_id_expect_failure(tbl_name,
            snapshots[2].get_snapshot_id(),
            expected_text="Cannot roll back to snapshot, not an ancestor of the current "
                          "state")

        # Create another snapshot.
        before_insert = datetime.datetime.now(pytz.timezone(orig_timezone))
        impalad_client.execute("INSERT INTO {0} VALUES ({1})".format(tbl_name, 4))
        snapshots = get_snapshots(impalad_client, tbl_name, expected_result_size=5)

        # Rollback to before the last insert.
        self.rollback_to_ts(impalad_client, tbl_name, before_insert)
        # This creates another snapshot.
        snapshots = get_snapshots(impalad_client, tbl_name, expected_result_size=6)
        # The snapshot id is the same, the dates differ
        assert snapshots[3].get_snapshot_id() == snapshots[5].get_snapshot_id()
        assert snapshots[3].get_creation_time() < snapshots[5].get_creation_time()
        assert not snapshots[4].is_current_ancestor()

        # Show that the EXECUTE ROLLBACK is respecting the current timezone.
        # To do this we try to roll back to a time for which there is no
        # snapshot, this will fail with an error message that includes the specified
        # time. We parse out that time. By doing this in two timezones we can see
        # that the parameter being used was affected by the current timezone.