<?xml version="1.0" encoding="UTF-8"?>
<changelog xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:noNamespaceSchemaLocation="https://www.liquigraph.org/schema/1.0/liquigraph.xsd">
    <changeset id="DISTRO-4707_acr_ingest_20210921:1" author="pdumoulin" run-on-change="true">
        <query>
            <![CDATA[
                CALL apoc.periodic.iterate(
                     "
                        WITH 'snowflake_orchard' AS url_alias,
                        '
                            SELECT * FROM facts.qa.jsonified_track_mapping ORDER BY ACR_ID ASC LIMIT 100000 OFFSET 0
                        '
                        AS sql
                        CALL apoc.load.jdbc(url_alias, sql)
                        YIELD row
                        return apoc.convert.fromJsonMap(row.NODE) AS row;
                    ",
                    '
                        WITH *, "database/distro-4707" AS by
                        MERGE (acrId:ACRID { id: row.acr_id })
                            ON CREATE SET
                                acrId.createdAt = datetime(),
                                acrId.createdBy = by,
                                acrId.lastModifiedAt = datetime(),
                                acrId.lastModifiedBy = by
                        MERGE (acrId)<-[acrIdToOsr:CONTAINS_FINGERPRINT]-(osr:OrchardSoundRecording)
                            ON CREATE SET
                                osr.id = apoc.create.uuid(),
                                osr.createdAt = datetime(),
                                osr.createdBy = by,
                                osr.lastModifiedAt = datetime(),
                                osr.lastModifiedBy = by,
                                acrIdToOsr.createdAt = datetime(),
                                acrIdToOsr.createdBy = by,
                                acrIdToOsr.lastModifiedAt = datetime(),
                                acrIdToOsr.lastModifiedBy = by
                        WITH *
                        UNWIND row.assets AS source_asset
                        MERGE (asset:OrchardAsset {
                            filename: source_asset.filename,
                            extension: "mp3",
                            source: "direct-delivery-db"
                        })
                            ON CREATE SET
                                asset.id = apoc.create.uuid(),
                                asset.createdAt = datetime(),
                                asset.createdBy = by,
                                asset.lastModifiedAt = datetime(),
                                asset.lastModifiedBy = by
                        MERGE (asset)-[assetToAcrId:FINGERPRINTED_AS]->(acrId)
                            ON CREATE SET
                                assetToAcrId.createdAt = datetime(),
                                assetToAcrId.createdBy = by
                            SET
                                assetToAcrId.lastModifiedAt = datetime(),
                                assetToAcrId.lastModifiedBy = by
                        WITH *
                        OPTIONAL MATCH (asset)-[assetToOldAcrId:FINGERPRINTED_AS]->(oldAcrId:ACRID)
                            WHERE oldAcrId <> acrId
                        FOREACH (hasOldAcrId IN CASE WHEN oldAcrId IS NOT NULL THEN [1] ELSE [] END |
                            CREATE (asset)-[deletedRelationship:DELETED_FINGERPRINTED_AS]->(oldAcrId)
                            SET
                                deletedRelationship += assetToOldAcrId,
                                deletedRelationship.deletedAt = datetime(),
                                deletedRelationship.deletedBy = by
                            DELETE assetToOldAcrId
                        )
                        WITH DISTINCT source_asset, by, asset
                        OPTIONAL MATCH (track:Track { id: toInteger(source_asset.tuid) })
                        CALL apoc.util.validate(track IS NULL, "Could not find the track %s", [source_asset.tuid])
                        MERGE (track)-[trackHasAsset:HAS_ASSET]->(asset)
                            ON CREATE SET
                                trackHasAsset.createdAt = datetime(),
                                trackHasAsset.createdBy = by,
                                trackHasAsset.lastModifiedAt = datetime(),
                                trackHasAsset.lastModifiedBy = by
                    ',
                    {
                        batchSize: 1000
                    }
                )
                YIELD failedOperations, errorMessages, failedBatches, batch
                CALL apoc.util.validate(failedOperations > 0, "At least one sub-operation failed: %s", [reduce(all_errors = "", error IN keys(errorMessages) | all_errors + ", " + error)])
                CALL apoc.util.validate(failedBatches > 0, "At least one batch failed: %s", [reduce(all_errors = "", error IN keys(batch.errors) | all_errors + ", " + error)])
                RETURN 0
            ]]>
        </query>
        <query>
            CALL apoc.log.info("Finished acr_cloud data ingest part 1 of 169 at %s", [datetime()]);
        </query>

        <query>
            <![CDATA[
                CALL apoc.periodic.iterate(
                     "
                        WITH 'snowflake_orchard' AS url_alias,
                        '
                            SELECT * FROM facts.qa.jsonified_track_mapping ORDER BY ACR_ID ASC LIMIT 100000 OFFSET 100000
                        '
                        AS sql
                        CALL apoc.load.jdbc(url_alias, sql)
                        YIELD row
                        return apoc.convert.fromJsonMap(row.NODE) AS row;
                    ",
                    '
                        WITH *, "database/distro-4707" AS by
                        MERGE (acrId:ACRID { id: row.acr_id })
                            ON CREATE SET
                                acrId.createdAt = datetime(),
                                acrId.createdBy = by,
                                acrId.lastModifiedAt = datetime(),
                                acrId.lastModifiedBy = by
                        MERGE (acrId)<-[acrIdToOsr:CONTAINS_FINGERPRINT]-(osr:OrchardSoundRecording)
                            ON CREATE SET
                                osr.id = apoc.create.uuid(),
                                osr.createdAt = datetime(),
                                osr.createdBy = by,
                                osr.lastModifiedAt = datetime(),
                                osr.lastModifiedBy = by,
                                acrIdToOsr.createdAt = datetime(),
                                acrIdToOsr.createdBy = by,
                                acrIdToOsr.lastModifiedAt = datetime(),
                                acrIdToOsr.lastModifiedBy = by
                        WITH *
                        UNWIND row.assets AS source_asset
                        MERGE (asset:OrchardAsset {
                            filename: source_asset.filename,
                            extension: "mp3",
                            source: "direct-delivery-db"
                        })
                            ON CREATE SET
                                asset.id = apoc.create.uuid(),
                                asset.createdAt = datetime(),
                                asset.createdBy = by,
                                asset.lastModifiedAt = datetime(),
                                asset.lastModifiedBy = by
                        MERGE (asset)-[assetToAcrId:FINGERPRINTED_AS]->(acrId)
                            ON CREATE SET
                                assetToAcrId.createdAt = datetime(),
                                assetToAcrId.createdBy = by
                            SET
                                assetToAcrId.lastModifiedAt = datetime(),
                                assetToAcrId.lastModifiedBy = by
                        WITH *
                        OPTIONAL MATCH (asset)-[assetToOldAcrId:FINGERPRINTED_AS]->(oldAcrId:ACRID)
                            WHERE oldAcrId <> acrId
                        FOREACH (hasOldAcrId IN CASE WHEN oldAcrId IS NOT NULL THEN [1] ELSE [] END |
                            CREATE (asset)-[deletedRelationship:DELETED_FINGERPRINTED_AS]->(oldAcrId)
                            SET
                                deletedRelationship += assetToOldAcrId,
                                deletedRelationship.deletedAt = datetime(),
                                deletedRelationship.deletedBy = by
                            DELETE assetToOldAcrId
                        )
                        WITH DISTINCT source_asset, by, asset
                        OPTIONAL MATCH (track:Track { id: toInteger(source_asset.tuid) })
                        CALL apoc.util.validate(track IS NULL, "Could not find the track %s", [source_asset.tuid])
                        MERGE (track)-[trackHasAsset:HAS_ASSET]->(asset)
                            ON CREATE SET
                                trackHasAsset.createdAt = datetime(),
                                trackHasAsset.createdBy = by,
                                trackHasAsset.lastModifiedAt = datetime(),
                                trackHasAsset.lastModifiedBy = by
                    ',
                    {
                        batchSize: 1000
                    }
                )
                YIELD failedOperations, errorMessages, failedBatches, batch
                CALL apoc.util.validate(failedOperations > 0, "At least one sub-operation failed: %s", [reduce(all_errors = "", error IN keys(errorMessages) | all_errors + ", " + error)])
                CALL apoc.util.validate(failedBatches > 0, "At least one batch failed: %s", [reduce(all_errors = "", error IN keys(batch.errors) | all_errors + ", " + error)])
                RETURN 0
            ]]>
        </query>
        <query>
            CALL apoc.log.info("Finished acr_cloud data ingest part 2 of 169 at %s", [datetime()]);
        </query>

        <query>
            <![CDATA[
                CALL apoc.periodic.iterate(
                     "
                        WITH 'snowflake_orchard' AS url_alias,
                        '
                            SELECT * FROM facts.qa.jsonified_track_mapping ORDER BY ACR_ID ASC LIMIT 100000 OFFSET 200000
                        '
                        AS sql
                        CALL apoc.load.jdbc(url_alias, sql)
                        YIELD row
                        return apoc.convert.fromJsonMap(row.NODE) AS row;
                    ",
                    '
                        WITH *, "database/distro-4707" AS by
                        MERGE (acrId:ACRID { id: row.acr_id })
                            ON CREATE SET
                                acrId.createdAt = datetime(),
                                acrId.createdBy = by,
                                acrId.lastModifiedAt = datetime(),
                                acrId.lastModifiedBy = by
                        MERGE (acrId)<-[acrIdToOsr:CONTAINS_FINGERPRINT]-(osr:OrchardSoundRecording)
                            ON CREATE SET
                                osr.id = apoc.create.uuid(),
                                osr.createdAt = datetime(),
                                osr.createdBy = by,
                                osr.lastModifiedAt = datetime(),
                                osr.lastModifiedBy = by,
                                acrIdToOsr.createdAt = datetime(),
                                acrIdToOsr.createdBy = by,
                                acrIdToOsr.lastModifiedAt = datetime(),
                                acrIdToOsr.lastModifiedBy = by
                        WITH *
                        UNWIND row.assets AS source_asset
                        MERGE (asset:OrchardAsset {
                            filename: source_asset.filename,
                            extension: "mp3",
                            source: "direct-delivery-db"
                        })
                            ON CREATE SET
                                asset.id = apoc.create.uuid(),
                                asset.createdAt = datetime(),
                                asset.createdBy = by,
                                asset.lastModifiedAt = datetime(),
                                asset.lastModifiedBy = by
                        MERGE (asset)-[assetToAcrId:FINGERPRINTED_AS]->(acrId)
                            ON CREATE SET
                                assetToAcrId.createdAt = datetime(),
                                assetToAcrId.createdBy = by
                            SET
                                assetToAcrId.lastModifiedAt = datetime(),
                                assetToAcrId.lastModifiedBy = by
                        WITH *
                        OPTIONAL MATCH (asset)-[assetToOldAcrId:FINGERPRINTED_AS]->(oldAcrId:ACRID)
                            WHERE oldAcrId <> acrId
                        FOREACH (hasOldAcrId IN CASE WHEN oldAcrId IS NOT NULL THEN [1] ELSE [] END |
                            CREATE (asset)-[deletedRelationship:DELETED_FINGERPRINTED_AS]->(oldAcrId)
                            SET
                                deletedRelationship += assetToOldAcrId,
                                deletedRelationship.deletedAt = datetime(),
                                deletedRelationship.deletedBy = by
                            DELETE assetToOldAcrId
                        )
                        WITH DISTINCT source_asset, by, asset
                        OPTIONAL MATCH (track:Track { id: toInteger(source_asset.tuid) })
                        CALL apoc.util.validate(track IS NULL, "Could not find the track %s", [source_asset.tuid])
                        MERGE (track)-[trackHasAsset:HAS_ASSET]->(asset)
                            ON CREATE SET
                                trackHasAsset.createdAt = datetime(),
                                trackHasAsset.createdBy = by,
                                trackHasAsset.lastModifiedAt = datetime(),
                                trackHasAsset.lastModifiedBy = by
                    ',
                    {
                        batchSize: 1000
                    }
                )
                YIELD failedOperations, errorMessages, failedBatches, batch
                CALL apoc.util.validate(failedOperations > 0, "At least one sub-operation failed: %s", [reduce(all_errors = "", error IN keys(errorMessages) | all_errors + ", " + error)])
                CALL apoc.util.validate(failedBatches > 0, "At least one batch failed: %s", [reduce(all_errors = "", error IN keys(batch.errors) | all_errors + ", " + error)])
                RETURN 0
            ]]>
        </query>
        <query>
            CALL apoc.log.info("Finished acr_cloud data ingest part 3 of 169 at %s", [datetime()]);
        </query>

        <query>
            <![CDATA[
                CALL apoc.periodic.iterate(
                     "
                        WITH 'snowflake_orchard' AS url_alias,
                        '
                            SELECT * FROM facts.qa.jsonified_track_mapping ORDER BY ACR_ID ASC LIMIT 100000 OFFSET 300000
                        '
                        AS sql
                        CALL apoc.load.jdbc(url_alias, sql)
                        YIELD row
                        return apoc.convert.fromJsonMap(row.NODE) AS row;
                    ",
                    '
                        WITH *, "database/distro-4707" AS by
                        MERGE (acrId:ACRID { id: row.acr_id })
                            ON CREATE SET
                                acrId.createdAt = datetime(),
                                acrId.createdBy = by,
                                acrId.lastModifiedAt = datetime(),
                                acrId.lastModifiedBy = by
                        MERGE (acrId)<-[acrIdToOsr:CONTAINS_FINGERPRINT]-(osr:OrchardSoundRecording)
                            ON CREATE SET
                                osr.id = apoc.create.uuid(),
                                osr.createdAt = datetime(),
                                osr.createdBy = by,
                                osr.lastModifiedAt = datetime(),
                                osr.lastModifiedBy = by,
                                acrIdToOsr.createdAt = datetime(),
                                acrIdToOsr.createdBy = by,
                                acrIdToOsr.lastModifiedAt = datetime(),
                                acrIdToOsr.lastModifiedBy = by
                        WITH *
                        UNWIND row.assets AS source_asset
                        MERGE (asset:OrchardAsset {
                            filename: source_asset.filename,
                            extension: "mp3",
                            source: "direct-delivery-db"
                        })
                            ON CREATE SET
                                asset.id = apoc.create.uuid(),
                                asset.createdAt = datetime(),
                                asset.createdBy = by,
                                asset.lastModifiedAt = datetime(),
                                asset.lastModifiedBy = by
                        MERGE (asset)-[assetToAcrId:FINGERPRINTED_AS]->(acrId)
                            ON CREATE SET
                                assetToAcrId.createdAt = datetime(),
                                assetToAcrId.createdBy = by
                            SET
                                assetToAcrId.lastModifiedAt = datetime(),
                                assetToAcrId.lastModifiedBy = by
                        WITH *
                        OPTIONAL MATCH (asset)-[assetToOldAcrId:FINGERPRINTED_AS]->(oldAcrId:ACRID)
                            WHERE oldAcrId <> acrId
                        FOREACH (hasOldAcrId IN CASE WHEN oldAcrId IS NOT NULL THEN [1] ELSE [] END |
                            CREATE (asset)-[deletedRelationship:DELETED_FINGERPRINTED_AS]->(oldAcrId)
                            SET
                                deletedRelationship += assetToOldAcrId,
                                deletedRelationship.deletedAt = datetime(),
                                deletedRelationship.deletedBy = by
                            DELETE assetToOldAcrId
                        )
                        WITH DISTINCT source_asset, by, asset
                        OPTIONAL MATCH (track:Track { id: toInteger(source_asset.tuid) })
                        CALL apoc.util.validate(track IS NULL, "Could not find the track %s", [source_asset.tuid])
                        MERGE (track)-[trackHasAsset:HAS_ASSET]->(asset)
                            ON CREATE SET
                                trackHasAsset.createdAt = datetime(),
                                trackHasAsset.createdBy = by,
                                trackHasAsset.lastModifiedAt = datetime(),
                                trackHasAsset.lastModifiedBy = by
                    ',
                    {
                        batchSize: 1000
                    }
                )
                YIELD failedOperations, errorMessages, failedBatches, batch
                CALL apoc.util.validate(failedOperations > 0, "At least one sub-operation failed: %s", [reduce(all_errors = "", error IN keys(errorMessages) | all_errors + ", " + error)])
                CALL apoc.util.validate(failedBatches > 0, "At least one batch failed: %s", [reduce(all_errors = "", error IN keys(batch.errors) | all_errors + ", " + error)])
                RETURN 0
            ]]>
        </query>
        <query>
            CALL apoc.log.info("Finished acr_cloud data ingest part 4 of 169 at %s", [datetime()]);
        </query>

        <query>
            <![CDATA[
                CALL apoc.periodic.iterate(
                     "
                        WITH 'snowflake_orchard' AS url_alias,
                        '
                            SELECT * FROM facts.qa.jsonified_track_mapping ORDER BY ACR_ID ASC LIMIT 100000 OFFSET 400000
                        '
                        AS sql
                        CALL apoc.load.jdbc(url_alias, sql)
                        YIELD row
                        return apoc.convert.fromJsonMap(row.NODE) AS row;
                    ",
                    '
                        WITH *, "database/distro-4707" AS by
                        MERGE (acrId:ACRID { id: row.acr_id })
                            ON CREATE SET
                                acrId.createdAt = datetime(),
                                acrId.createdBy = by,
                                acrId.lastModifiedAt = datetime(),
                                acrId.lastModifiedBy = by
                        MERGE (acrId)<-[acrIdToOsr:CONTAINS_FINGERPRINT]-(osr:OrchardSoundRecording)
                            ON CREATE SET
                                osr.id = apoc.create.uuid(),
                                osr.createdAt = datetime(),
                                osr.createdBy = by,
                                osr.lastModifiedAt = datetime(),
                                osr.lastModifiedBy = by,
                                acrIdToOsr.createdAt = datetime(),
                                acrIdToOsr.createdBy = by,
                                acrIdToOsr.lastModifiedAt = datetime(),
                                acrIdToOsr.lastModifiedBy = by
                        WITH *
                        UNWIND row.assets AS source_asset
                        MERGE (asset:OrchardAsset {
                            filename: source_asset.filename,
                            extension: "mp3",
                            source: "direct-delivery-db"
                        })
                            ON CREATE SET
                                asset.id = apoc.create.uuid(),
                                asset.createdAt = datetime(),
                                asset.createdBy = by,
                                asset.lastModifiedAt = datetime(),
                                asset.lastModifiedBy = by
                        MERGE (asset)-[assetToAcrId:FINGERPRINTED_AS]->(acrId)
                            ON CREATE SET
                                assetToAcrId.createdAt = datetime(),
                                assetToAcrId.createdBy = by
                            SET
                                assetToAcrId.lastModifiedAt = datetime(),
                                assetToAcrId.lastModifiedBy = by
                        WITH *
                        OPTIONAL MATCH (asset)-[assetToOldAcrId:FINGERPRINTED_AS]->(oldAcrId:ACRID)
                            WHERE oldAcrId <> acrId
                        FOREACH (hasOldAcrId IN CASE WHEN oldAcrId IS NOT NULL THEN [1] ELSE [] END |
                            CREATE (asset)-[deletedRelationship:DELETED_FINGERPRINTED_AS]->(oldAcrId)
                            SET
                                deletedRelationship += assetToOldAcrId,
                                deletedRelationship.deletedAt = datetime(),
                                deletedRelationship.deletedBy = by
                            DELETE assetToOldAcrId
                        )
                        WITH DISTINCT source_asset, by, asset
                        OPTIONAL MATCH (track:Track { id: toInteger(source_asset.tuid) })
                        CALL apoc.util.validate(track IS NULL, "Could not find the track %s", [source_asset.tuid])
                        MERGE (track)-[trackHasAsset:HAS_ASSET]->(asset)
                            ON CREATE SET
                                trackHasAsset.createdAt = datetime(),
                                trackHasAsset.createdBy = by,
                                trackHasAsset.lastModifiedAt = datetime(),
                                trackHasAsset.lastModifiedBy = by
                    ',
                    {
                        batchSize: 1000
                    }
                )
                YIELD failedOperations, errorMessages, failedBatches, batch
                CALL apoc.util.validate(failedOperations > 0, "At least one sub-operation failed: %s", [reduce(all_errors = "", error IN keys(errorMessages) | all_errors + ", " + error)])
                CALL apoc.util.validate(failedBatches > 0, "At least one batch failed: %s", [reduce(all_errors = "", error IN keys(batch.errors) | all_errors + ", " + error)])
                RETURN 0
            ]]>
        </query>
        <query>
            CALL apoc.log.info("Finished acr_cloud data ingest part 5 of 169 at %s", [datetime()]);
        </query>

        <query>
            <![CDATA[
                CALL apoc.periodic.iterate(
                     "
                        WITH 'snowflake_orchard' AS url_alias,
                        '
                            SELECT * FROM facts.qa.jsonified_track_mapping ORDER BY ACR_ID ASC LIMIT 100000 OFFSET 500000
                        '
                        AS sql
                        CALL apoc.load.jdbc(url_alias, sql)
                        YIELD row
                        return apoc.convert.fromJsonMap(row.NODE) AS row;
                    ",
                    '
                        WITH *, "database/distro-4707" AS by
                        MERGE (acrId:ACRID { id: row.acr_id })
                            ON CREATE SET
                                acrId.createdAt = datetime(),
                                acrId.createdBy = by,
                                acrId.lastModifiedAt = datetime(),
                                acrId.lastModifiedBy = by
                        MERGE (acrId)<-[acrIdToOsr:CONTAINS_FINGERPRINT]-(osr:OrchardSoundRecording)
                            ON CREATE SET
                                osr.id = apoc.create.uuid(),
                                osr.createdAt = datetime(),
                                osr.createdBy = by,
                                osr.lastModifiedAt = datetime(),
                                osr.lastModifiedBy = by,
                                acrIdToOsr.createdAt = datetime(),
                                acrIdToOsr.createdBy = by,
                                acrIdToOsr.lastModifiedAt = datetime(),
                                acrIdToOsr.lastModifiedBy = by
                        WITH *
                        UNWIND row.assets AS source_asset
                        MERGE (asset:OrchardAsset {
                            filename: source_asset.filename,
                            extension: "mp3",
                            source: "direct-delivery-db"
                        })
                            ON CREATE SET
                                asset.id = apoc.create.uuid(),
                                asset.createdAt = datetime(),
                                asset.createdBy = by,
                                asset.lastModifiedAt = datetime(),
                                asset.lastModifiedBy = by
                        MERGE (asset)-[assetToAcrId:FINGERPRINTED_AS]->(acrId)
                            ON CREATE SET
                                assetToAcrId.createdAt = datetime(),
                                assetToAcrId.createdBy = by
                            SET
                                assetToAcrId.lastModifiedAt = datetime(),
                                assetToAcrId.lastModifiedBy = by
                        WITH *
                        OPTIONAL MATCH (asset)-[assetToOldAcrId:FINGERPRINTED_AS]->(oldAcrId:ACRID)
                            WHERE oldAcrId <> acrId
                        FOREACH (hasOldAcrId IN CASE WHEN oldAcrId IS NOT NULL THEN [1] ELSE [] END |
                            CREATE (asset)-[deletedRelationship:DELETED_FINGERPRINTED_AS]->(oldAcrId)
                            SET
                                deletedRelationship += assetToOldAcrId,
                                deletedRelationship.deletedAt = datetime(),
                                deletedRelationship.deletedBy = by
                            DELETE assetToOldAcrId
                        )
                        WITH DISTINCT source_asset, by, asset
                        OPTIONAL MATCH (track:Track { id: toInteger(source_asset.tuid) })
                        CALL apoc.util.validate(track IS NULL, "Could not find the track %s", [source_asset.tuid])
                        MERGE (track)-[trackHasAsset:HAS_ASSET]->(asset)
                            ON CREATE SET
                                trackHasAsset.createdAt = datetime(),
                                trackHasAsset.createdBy = by,
                                trackHasAsset.lastModifiedAt = datetime(),
                                trackHasAsset.lastModifiedBy = by
                    ',
                    {
                        batchSize: 1000
                    }
                )
                YIELD failedOperations, errorMessages, failedBatches, batch
                CALL apoc.util.validate(failedOperations > 0, "At least one sub-operation failed: %s", [reduce(all_errors = "", error IN keys(errorMessages) | all_errors + ", " + error)])
                CALL apoc.util.validate(failedBatches > 0, "At least one batch failed: %s", [reduce(all_errors = "", error IN keys(batch.errors) | all_errors + ", " + error)])
                RETURN 0
            ]]>
        </query>
        <query>
            CALL apoc.log.info("Finished acr_cloud data ingest part 6 of 169 at %s", [datetime()]);
        </query>

        <query>
            <![CDATA[
                CALL apoc.periodic.iterate(
                     "
                        WITH 'snowflake_orchard' AS url_alias,
                        '
                            SELECT * FROM facts.qa.jsonified_track_mapping ORDER BY ACR_ID ASC LIMIT 100000 OFFSET 600000
                        '
                        AS sql
                        CALL apoc.load.jdbc(url_alias, sql)
                        YIELD row
                        return apoc.convert.fromJsonMap(row.NODE) AS row;
                    ",
                    '
                        WITH *, "database/distro-4707" AS by
                        MERGE (acrId:ACRID { id: row.acr_id })
                            ON CREATE SET
                                acrId.createdAt = datetime(),
                                acrId.createdBy = by,
                                acrId.lastModifiedAt = datetime(),
                                acrId.lastModifiedBy = by
                        MERGE (acrId)<-[acrIdToOsr:CONTAINS_FINGERPRINT]-(osr:OrchardSoundRecording)
                            ON CREATE SET
                                osr.id = apoc.create.uuid(),
                                osr.createdAt = datetime(),
                                osr.createdBy = by,
                                osr.lastModifiedAt = datetime(),
                                osr.lastModifiedBy = by,
                                acrIdToOsr.createdAt = datetime(),
                                acrIdToOsr.createdBy = by,
                                acrIdToOsr.lastModifiedAt = datetime(),
                                acrIdToOsr.lastModifiedBy = by
                        WITH *
                        UNWIND row.assets AS source_asset
                        MERGE (asset:OrchardAsset {
                            filename: source_asset.filename,
                            extension: "mp3",
                            source: "direct-delivery-db"
                        })
                            ON CREATE SET
                                asset.id = apoc.create.uuid(),
                                asset.createdAt = datetime(),
                                asset.createdBy = by,
                                asset.lastModifiedAt = datetime(),
                                asset.lastModifiedBy = by
                        MERGE (asset)-[assetToAcrId:FINGERPRINTED_AS]->(acrId)
                            ON CREATE SET
                                assetToAcrId.createdAt = datetime(),
                                assetToAcrId.createdBy = by
                            SET
                                assetToAcrId.lastModifiedAt = datetime(),
                                assetToAcrId.lastModifiedBy = by
                        WITH *
                        OPTIONAL MATCH (asset)-[assetToOldAcrId:FINGERPRINTED_AS]->(oldAcrId:ACRID)
                            WHERE oldAcrId <> acrId
                        FOREACH (hasOldAcrId IN CASE WHEN oldAcrId IS NOT NULL THEN [1] ELSE [] END |
                            CREATE (asset)-[deletedRelationship:DELETED_FINGERPRINTED_AS]->(oldAcrId)
                            SET
                                deletedRelationship += assetToOldAcrId,
                                deletedRelationship.deletedAt = datetime(),
                                deletedRelationship.deletedBy = by
                            DELETE assetToOldAcrId
                        )
                        WITH DISTINCT source_asset, by, asset
                        OPTIONAL MATCH (track:Track { id: toInteger(source_asset.tuid) })
                        CALL apoc.util.validate(track IS NULL, "Could not find the track %s", [source_asset.tuid])
                        MERGE (track)-[trackHasAsset:HAS_ASSET]->(asset)
                            ON CREATE SET
                                trackHasAsset.createdAt = datetime(),
                                trackHasAsset.createdBy = by,
                                trackHasAsset.lastModifiedAt = datetime(),
                                trackHasAsset.lastModifiedBy = by
                    ',
                    {
                        batchSize: 1000
                    }
                )
                YIELD failedOperations, errorMessages, failedBatches, batch
                CALL apoc.util.validate(failedOperations > 0, "At least one sub-operation failed: %s", [reduce(all_errors = "", error IN keys(errorMessages) | all_errors + ", " + error)])
                CALL apoc.util.validate(failedBatches > 0, "At least one batch failed: %s", [reduce(all_errors = "", error IN keys(batch.errors) | all_errors + ", " + error)])
                RETURN 0
            ]]>
        </query>
        <query>
            CALL apoc.log.info("Finished acr_cloud data ingest part 7 of 169 at %s", [datetime()]);
        </query>

        <query>
            <![CDATA[
                CALL apoc.periodic.iterate(
                     "
                        WITH 'snowflake_orchard' AS url_alias,
                        '
                            SELECT * FROM facts.qa.jsonified_track_mapping ORDER BY ACR_ID ASC LIMIT 100000 OFFSET 700000
                        '
                        AS sql
                        CALL apoc.load.jdbc(url_alias, sql)
                        YIELD row
                        return apoc.convert.fromJsonMap(row.NODE) AS row;
                    ",
                    '
                        WITH *, "database/distro-4707" AS by
                        MERGE (acrId:ACRID { id: row.acr_id })
                            ON CREATE SET
                                acrId.createdAt = datetime(),
                                acrId.createdBy = by,
                                acrId.lastModifiedAt = datetime(),
                                acrId.lastModifiedBy = by
                        MERGE (acrId)<-[acrIdToOsr:CONTAINS_FINGERPRINT]-(osr:OrchardSoundRecording)
                            ON CREATE SET
                                osr.id = apoc.create.uuid(),
                                osr.createdAt = datetime(),
                                osr.createdBy = by,
                                osr.lastModifiedAt = datetime(),
                                osr.lastModifiedBy = by,
                                acrIdToOsr.createdAt = datetime(),
                                acrIdToOsr.createdBy = by,
                                acrIdToOsr.lastModifiedAt = datetime(),
                                acrIdToOsr.lastModifiedBy = by
                        WITH *
                        UNWIND row.assets AS source_asset
                        MERGE (asset:OrchardAsset {
                            filename: source_asset.filename,
                            extension: "mp3",
                            source: "direct-delivery-db"
                        })
                            ON CREATE SET
                                asset.id = apoc.create.uuid(),
                                asset.createdAt = datetime(),
                                asset.createdBy = by,
                                asset.lastModifiedAt = datetime(),
                                asset.lastModifiedBy = by
                        MERGE (asset)-[assetToAcrId:FINGERPRINTED_AS]->(acrId)
                            ON CREATE SET
                                assetToAcrId.createdAt = datetime(),
                                assetToAcrId.createdBy = by
                            SET
                                assetToAcrId.lastModifiedAt = datetime(),
                                assetToAcrId.lastModifiedBy = by
                        WITH *
                        OPTIONAL MATCH (asset)-[assetToOldAcrId:FINGERPRINTED_AS]->(oldAcrId:ACRID)
                            WHERE oldAcrId <> acrId
                        FOREACH (hasOldAcrId IN CASE WHEN oldAcrId IS NOT NULL THEN [1] ELSE [] END |
                            CREATE (asset)-[deletedRelationship:DELETED_FINGERPRINTED_AS]->(oldAcrId)
                            SET
                                deletedRelationship += assetToOldAcrId,
                                deletedRelationship.deletedAt = datetime(),
                                deletedRelationship.deletedBy = by
                            DELETE assetToOldAcrId
                        )
                        WITH DISTINCT source_asset, by, asset
                        OPTIONAL MATCH (track:Track { id: toInteger(source_asset.tuid) })
                        CALL apoc.util.validate(track IS NULL, "Could not find the track %s", [source_asset.tuid])
                        MERGE (track)-[trackHasAsset:HAS_ASSET]->(asset)
                            ON CREATE SET
                                trackHasAsset.createdAt = datetime(),
                                trackHasAsset.createdBy = by,
                                trackHasAsset.lastModifiedAt = datetime(),
                                trackHasAsset.lastModifiedBy = by
                    ',
                    {
                        batchSize: 1000
                    }
                )
                YIELD failedOperations, errorMessages, failedBatches, batch
                CALL apoc.util.validate(failedOperations > 0, "At least one sub-operation failed: %s", [reduce(all_errors = "", error IN keys(errorMessages) | all_errors + ", " + error)])
                CALL apoc.util.validate(failedBatches > 0, "At least one batch failed: %s", [reduce(all_errors = "", error IN keys(batch.errors) | all_errors + ", " + error)])
                RETURN 0
            ]]>
        </query>
        <query>
            CALL apoc.log.info("Finished acr_cloud data ingest part 8 of 169 at %s", [datetime()]);
        </query>

        <query>
            <![CDATA[
                CALL apoc.periodic.iterate(
                     "
                        WITH 'snowflake_orchard' AS url_alias,
                        '
                            SELECT * FROM facts.qa.jsonified_track_mapping ORDER BY ACR_ID ASC LIMIT 100000 OFFSET 800000
                        '
                        AS sql
                        CALL apoc.load.jdbc(url_alias, sql)
                        YIELD row
                        return apoc.convert.fromJsonMap(row.NODE) AS row;
                    ",
                    '
                        WITH *, "database/distro-4707" AS by
                        MERGE (acrId:ACRID { id: row.acr_id })
                            ON CREATE SET
                                acrId.createdAt = datetime(),
                                acrId.createdBy = by,
                                acrId.lastModifiedAt = datetime(),
                                acrId.lastModifiedBy = by
                        MERGE (acrId)<-[acrIdToOsr:CONTAINS_FINGERPRINT]-(osr:OrchardSoundRecording)
                            ON CREATE SET
                                osr.id = apoc.create.uuid(),
                                osr.createdAt = datetime(),
                                osr.createdBy = by,
                                osr.lastModifiedAt = datetime(),
                                osr.lastModifiedBy = by,
                                acrIdToOsr.createdAt = datetime(),
                                acrIdToOsr.createdBy = by,
                                acrIdToOsr.lastModifiedAt = datetime(),
                                acrIdToOsr.lastModifiedBy = by
                        WITH *
                        UNWIND row.assets AS source_asset
                        MERGE (asset:OrchardAsset {
                            filename: source_asset.filename,
                            extension: "mp3",
                            source: "direct-delivery-db"
                        })
                            ON CREATE SET
                                asset.id = apoc.create.uuid(),
                                asset.createdAt = datetime(),
                                asset.createdBy = by,
                                asset.lastModifiedAt = datetime(),
                                asset.lastModifiedBy = by
                        MERGE (asset)-[assetToAcrId:FINGERPRINTED_AS]->(acrId)
                            ON CREATE SET
                                assetToAcrId.createdAt = datetime(),
                                assetToAcrId.createdBy = by
                            SET
                                assetToAcrId.lastModifiedAt = datetime(),
                                assetToAcrId.lastModifiedBy = by
                        WITH *
                        OPTIONAL MATCH (asset)-[assetToOldAcrId:FINGERPRINTED_AS]->(oldAcrId:ACRID)
                            WHERE oldAcrId <> acrId
                        FOREACH (hasOldAcrId IN CASE WHEN oldAcrId IS NOT NULL THEN [1] ELSE [] END |
                            CREATE (asset)-[deletedRelationship:DELETED_FINGERPRINTED_AS]->(oldAcrId)
                            SET
                                deletedRelationship += assetToOldAcrId,
                                deletedRelationship.deletedAt = datetime(),
                                deletedRelationship.deletedBy = by
                            DELETE assetToOldAcrId
                        )
                        WITH DISTINCT source_asset, by, asset
                        OPTIONAL MATCH (track:Track { id: toInteger(source_asset.tuid) })
                        CALL apoc.util.validate(track IS NULL, "Could not find the track %s", [source_asset.tuid])
                        MERGE (track)-[trackHasAsset:HAS_ASSET]->(asset)
                            ON CREATE SET
                                trackHasAsset.createdAt = datetime(),
                                trackHasAsset.createdBy = by,
                                trackHasAsset.lastModifiedAt = datetime(),
                                trackHasAsset.lastModifiedBy = by
                    ',
                    {
                        batchSize: 1000
                    }
                )
                YIELD failedOperations, errorMessages, failedBatches, batch
                CALL apoc.util.validate(failedOperations > 0, "At least one sub-operation failed: %s", [reduce(all_errors = "", error IN keys(errorMessages) | all_errors + ", " + error)])
                CALL apoc.util.validate(failedBatches > 0, "At least one batch failed: %s", [reduce(all_errors = "", error IN keys(batch.errors) | all_errors + ", " + error)])
                RETURN 0
            ]]>
        </query>
        <query>
            CALL apoc.log.info("Finished acr_cloud data ingest part 9 of 169 at %s", [datetime()]);
        </query>

        <query>
            <![CDATA[
                CALL apoc.periodic.iterate(
                     "
                        WITH 'snowflake_orchard' AS url_alias,
                        '
                            SELECT * FROM facts.qa.jsonified_track_mapping ORDER BY ACR_ID ASC LIMIT 100000 OFFSET 900000
                        '
                        AS sql
                        CALL apoc.load.jdbc(url_alias, sql)
                        YIELD row
                        return apoc.convert.fromJsonMap(row.NODE) AS row;
                    ",
                    '
                        WITH *, "database/distro-4707" AS by
                        MERGE (acrId:ACRID { id: row.acr_id })
                            ON CREATE SET
                                acrId.createdAt = datetime(),
                                acrId.createdBy = by,
                                acrId.lastModifiedAt = datetime(),
                                acrId.lastModifiedBy = by
                        MERGE (acrId)<-[acrIdToOsr:CONTAINS_FINGERPRINT]-(osr:OrchardSoundRecording)
                            ON CREATE SET
                                osr.id = apoc.create.uuid(),
                                osr.createdAt = datetime(),
                                osr.createdBy = by,
                                osr.lastModifiedAt = datetime(),
                                osr.lastModifiedBy = by,
                                acrIdToOsr.createdAt = datetime(),
                                acrIdToOsr.createdBy = by,
                                acrIdToOsr.lastModifiedAt = datetime(),
                                acrIdToOsr.lastModifiedBy = by
                        WITH *
                        UNWIND row.assets AS source_asset
                        MERGE (asset:OrchardAsset {
                            filename: source_asset.filename,
                            extension: "mp3",
                            source: "direct-delivery-db"
                        })
                            ON CREATE SET
                                asset.id = apoc.create.uuid(),
                                asset.createdAt = datetime(),
                                asset.createdBy = by,
                                asset.lastModifiedAt = datetime(),
                                asset.lastModifiedBy = by
                        MERGE (asset)-[assetToAcrId:FINGERPRINTED_AS]->(acrId)
                            ON CREATE SET
                                assetToAcrId.createdAt = datetime(),
                                assetToAcrId.createdBy = by
                            SET
                                assetToAcrId.lastModifiedAt = datetime(),
                                assetToAcrId.lastModifiedBy = by
                        WITH *
                        OPTIONAL MATCH (asset)-[assetToOldAcrId:FINGERPRINTED_AS]->(oldAcrId:ACRID)
                            WHERE oldAcrId <> acrId
                        FOREACH (hasOldAcrId IN CASE WHEN oldAcrId IS NOT NULL THEN [1] ELSE [] END |
                            CREATE (asset)-[deletedRelationship:DELETED_FINGERPRINTED_AS]->(oldAcrId)
                            SET
                                deletedRelationship += assetToOldAcrId,
                                deletedRelationship.deletedAt = datetime(),
                                deletedRelationship.deletedBy = by
                            DELETE assetToOldAcrId
                        )
                        WITH DISTINCT source_asset, by, asset
                        OPTIONAL MATCH (track:Track { id: toInteger(source_asset.tuid) })
                        CALL apoc.util.validate(track IS NULL, "Could not find the track %s", [source_asset.tuid])
                        MERGE (track)-[trackHasAsset:HAS_ASSET]->(asset)
                            ON CREATE SET
                                trackHasAsset.createdAt = datetime(),
                                trackHasAsset.createdBy = by,
                                trackHasAsset.lastModifiedAt = datetime(),
                                trackHasAsset.lastModifiedBy = by
                    ',
                    {
                        batchSize: 1000
                    }
                )
                YIELD failedOperations, errorMessages, failedBatches, batch
                CALL apoc.util.validate(failedOperations > 0, "At least one sub-operation failed: %s", [reduce(all_errors = "", error IN keys(errorMessages) | all_errors + ", " + error)])
                CALL apoc.util.validate(failedBatches > 0, "At least one batch failed: %s", [reduce(all_errors = "", error IN keys(batch.errors) | all_errors + ", " + error)])
                RETURN 0
            ]]>
        </query>
        <query>
            CALL apoc.log.info("Finished acr_cloud data ingest part 10 of 169 at %s", [datetime()]);
        </query>

        <query>
            <![CDATA[
                CALL apoc.periodic.iterate(
                     "
                        WITH 'snowflake_orchard' AS url_alias,
                        '
                            SELECT * FROM facts.qa.jsonified_track_mapping ORDER BY ACR_ID ASC LIMIT 100000 OFFSET 1000000
                        '
                        AS sql
                        CALL apoc.load.jdbc(url_alias, sql)
                        YIELD row
                        return apoc.convert.fromJsonMap(row.NODE) AS row;
                    ",
                    '
                        WITH *, "database/distro-4707" AS by
                        MERGE (acrId:ACRID { id: row.acr_id })
                            ON CREATE SET
                                acrId.createdAt = datetime(),
                                acrId.createdBy = by,
                                acrId.lastModifiedAt = datetime(),
                                acrId.lastModifiedBy = by
                        MERGE (acrId)<-[acrIdToOsr:CONTAINS_FINGERPRINT]-(osr:OrchardSoundRecording)
                            ON CREATE SET
                                osr.id = apoc.create.uuid(),
                                osr.createdAt = datetime(),
                                osr.createdBy = by,
                                osr.lastModifiedAt = datetime(),
                                osr.lastModifiedBy = by,
                                acrIdToOsr.createdAt = datetime(),
                                acrIdToOsr.createdBy = by,
                                acrIdToOsr.lastModifiedAt = datetime(),
                                acrIdToOsr.lastModifiedBy = by
                        WITH *
                        UNWIND row.assets AS source_asset
                        MERGE (asset:OrchardAsset {
                            filename: source_asset.filename,
                            extension: "mp3",
                            source: "direct-delivery-db"
                        })
                            ON CREATE SET
                                asset.id = apoc.create.uuid(),
                                asset.createdAt = datetime(),
                                asset.createdBy = by,
                                asset.lastModifiedAt = datetime(),
                                asset.lastModifiedBy = by
                        MERGE (asset)-[assetToAcrId:FINGERPRINTED_AS]->(acrId)
                            ON CREATE SET
                                assetToAcrId.createdAt = datetime(),
                                assetToAcrId.createdBy = by
                            SET
                                assetToAcrId.lastModifiedAt = datetime(),
                                assetToAcrId.lastModifiedBy = by
                        WITH *
                        OPTIONAL MATCH (asset)-[assetToOldAcrId:FINGERPRINTED_AS]->(oldAcrId:ACRID)
                            WHERE oldAcrId <> acrId
                        FOREACH (hasOldAcrId IN CASE WHEN oldAcrId IS NOT NULL THEN [1] ELSE [] END |
                            CREATE (asset)-[deletedRelationship:DELETED_FINGERPRINTED_AS]->(oldAcrId)
                            SET
                                deletedRelationship += assetToOldAcrId,
                                deletedRelationship.deletedAt = datetime(),
                                deletedRelationship.deletedBy = by
                            DELETE assetToOldAcrId
                        )
                        WITH DISTINCT source_asset, by, asset
                        OPTIONAL MATCH (track:Track { id: toInteger(source_asset.tuid) })
                        CALL apoc.util.validate(track IS NULL, "Could not find the track %s", [source_asset.tuid])
                        MERGE (track)-[trackHasAsset:HAS_ASSET]->(asset)
                            ON CREATE SET
                                trackHasAsset.createdAt = datetime(),
                                trackHasAsset.createdBy = by,
                                trackHasAsset.lastModifiedAt = datetime(),
                                trackHasAsset.lastModifiedBy = by
                    ',
                    {
                        batchSize: 1000
                    }
                )
                YIELD failedOperations, errorMessages, failedBatches, batch
                CALL apoc.util.validate(failedOperations > 0, "At least one sub-operation failed: %s", [reduce(all_errors = "", error IN keys(errorMessages) | all_errors + ", " + error)])
                CALL apoc.util.validate(failedBatches > 0, "At least one batch failed: %s", [reduce(all_errors = "", error IN keys(batch.errors) | all_errors + ", " + error)])
                RETURN 0
            ]]>
        </query>
        <query>
            CALL apoc.log.info("Finished acr_cloud data ingest part 11 of 169 at %s", [datetime()]);
        </query>

        <query>
            <![CDATA[
                CALL apoc.periodic.iterate(
                     "
                        WITH 'snowflake_orchard' AS url_alias,
                        '
                            SELECT * FROM facts.qa.jsonified_track_mapping ORDER BY ACR_ID ASC LIMIT 100000 OFFSET 1100000
                        '
                        AS sql
                        CALL apoc.load.jdbc(url_alias, sql)
                        YIELD row
                        return apoc.convert.fromJsonMap(row.NODE) AS row;
                    ",
                    '
                        WITH *, "database/distro-4707" AS by
                        MERGE (acrId:ACRID { id: row.acr_id })
                            ON CREATE SET
                                acrId.createdAt = datetime(),
                                acrId.createdBy = by,
                                acrId.lastModifiedAt = datetime(),
                                acrId.lastModifiedBy = by
                        MERGE (acrId)<-[acrIdToOsr:CONTAINS_FINGERPRINT]-(osr:OrchardSoundRecording)
                            ON CREATE SET
                                osr.id = apoc.create.uuid(),
                                osr.createdAt = datetime(),
                                osr.createdBy = by,
                                osr.lastModifiedAt = datetime(),
                                osr.lastModifiedBy = by,
                                acrIdToOsr.createdAt = datetime(),
                                acrIdToOsr.createdBy = by,
                                acrIdToOsr.lastModifiedAt = datetime(),
                                acrIdToOsr.lastModifiedBy = by
                        WITH *
                        UNWIND row.assets AS source_asset
                        MERGE (asset:OrchardAsset {
                            filename: source_asset.filename,
                            extension: "mp3",
                            source: "direct-delivery-db"
                        })
                            ON CREATE SET
                                asset.id = apoc.create.uuid(),
                                asset.createdAt = datetime(),
                                asset.createdBy = by,
                                asset.lastModifiedAt = datetime(),
                                asset.lastModifiedBy = by
                        MERGE (asset)-[assetToAcrId:FINGERPRINTED_AS]->(acrId)
                            ON CREATE SET
                                assetToAcrId.createdAt = datetime(),
                                assetToAcrId.createdBy = by
                            SET
                                assetToAcrId.lastModifiedAt = datetime(),
                                assetToAcrId.lastModifiedBy = by
                        WITH *
                        OPTIONAL MATCH (asset)-[assetToOldAcrId:FINGERPRINTED_AS]->(oldAcrId:ACRID)
                            WHERE oldAcrId <> acrId
                        FOREACH (hasOldAcrId IN CASE WHEN oldAcrId IS NOT NULL THEN [1] ELSE [] END |
                            CREATE (asset)-[deletedRelationship:DELETED_FINGERPRINTED_AS]->(oldAcrId)
                            SET
                                deletedRelationship += assetToOldAcrId,
                                deletedRelationship.deletedAt = datetime(),
                                deletedRelationship.deletedBy = by
                            DELETE assetToOldAcrId
                        )
                        WITH DISTINCT source_asset, by, asset
                        OPTIONAL MATCH (track:Track { id: toInteger(source_asset.tuid) })
                        CALL apoc.util.validate(track IS NULL, "Could not find the track %s", [source_asset.tuid])
                        MERGE (track)-[trackHasAsset:HAS_ASSET]->(asset)
                            ON CREATE SET
                                trackHasAsset.createdAt = datetime(),
                                trackHasAsset.createdBy = by,
                                trackHasAsset.lastModifiedAt = datetime(),
                                trackHasAsset.lastModifiedBy = by
                    ',
                    {
                        batchSize: 1000
                    }
                )
                YIELD failedOperations, errorMessages, failedBatches, batch
                CALL apoc.util.validate(failedOperations > 0, "At least one sub-operation failed: %s", [reduce(all_errors = "", error IN keys(errorMessages) | all_errors + ", " + error)])
                CALL apoc.util.validate(failedBatches > 0, "At least one batch failed: %s", [reduce(all_errors = "", error IN keys(batch.errors) | all_errors + ", " + error)])
                RETURN 0
            ]]>
        </query>
        <query>
            CALL apoc.log.info("Finished acr_cloud data ingest part 12 of 169 at %s", [datetime()]);
        </query>

        <query>
            <![CDATA[
                CALL apoc.periodic.iterate(
                     "
                        WITH 'snowflake_orchard' AS url_alias,
                        '
                            SELECT * FROM facts.qa.jsonified_track_mapping ORDER BY ACR_ID ASC LIMIT 100000 OFFSET 1200000
                        '
                        AS sql
                        CALL apoc.load.jdbc(url_alias, sql)
                        YIELD row
                        return apoc.convert.fromJsonMap(row.NODE) AS row;
                    ",
                    '
                        WITH *, "database/distro-4707" AS by
                        MERGE (acrId:ACRID { id: row.acr_id })
                            ON CREATE SET
                                acrId.createdAt = datetime(),
                                acrId.createdBy = by,
                                acrId.lastModifiedAt = datetime(),
                                acrId.lastModifiedBy = by
                        MERGE (acrId)<-[acrIdToOsr:CONTAINS_FINGERPRINT]-(osr:OrchardSoundRecording)
                            ON CREATE SET
                                osr.id = apoc.create.uuid(),
                                osr.createdAt = datetime(),
                                osr.createdBy = by,
                                osr.lastModifiedAt = datetime(),
                                osr.lastModifiedBy = by,
                                acrIdToOsr.createdAt = datetime(),
                                acrIdToOsr.createdBy = by,
                                acrIdToOsr.lastModifiedAt = datetime(),
                                acrIdToOsr.lastModifiedBy = by
                        WITH *
                        UNWIND row.assets AS source_asset
                        MERGE (asset:OrchardAsset {
                            filename: source_asset.filename,
                            extension: "mp3",
                            source: "direct-delivery-db"
                        })
                            ON CREATE SET
                                asset.id = apoc.create.uuid(),
                                asset.createdAt = datetime(),
                                asset.createdBy = by,
                                asset.lastModifiedAt = datetime(),
                                asset.lastModifiedBy = by
                        MERGE (asset)-[assetToAcrId:FINGERPRINTED_AS]->(acrId)
                            ON CREATE SET
                                assetToAcrId.createdAt = datetime(),
                                assetToAcrId.createdBy = by
                            SET
                                assetToAcrId.lastModifiedAt = datetime(),
                                assetToAcrId.lastModifiedBy = by
                        WITH *
                        OPTIONAL MATCH (asset)-[assetToOldAcrId:FINGERPRINTED_AS]->(oldAcrId:ACRID)
                            WHERE oldAcrId <> acrId
                        FOREACH (hasOldAcrId IN CASE WHEN oldAcrId IS NOT NULL THEN [1] ELSE [] END |
                            CREATE (asset)-[deletedRelationship:DELETED_FINGERPRINTED_AS]->(oldAcrId)
                            SET
                                deletedRelationship += assetToOldAcrId,
                                deletedRelationship.deletedAt = datetime(),
                                deletedRelationship.deletedBy = by
                            DELETE assetToOldAcrId
                        )
                        WITH DISTINCT source_asset, by, asset
                        OPTIONAL MATCH (track:Track { id: toInteger(source_asset.tuid) })
                        CALL apoc.util.validate(track IS NULL, "Could not find the track %s", [source_asset.tuid])
                        MERGE (track)-[trackHasAsset:HAS_ASSET]->(asset)
                            ON CREATE SET
                                trackHasAsset.createdAt = datetime(),
                                trackHasAsset.createdBy = by,
                                trackHasAsset.lastModifiedAt = datetime(),
                                trackHasAsset.lastModifiedBy = by
                    ',
                    {
                        batchSize: 1000
                    }
                )
                YIELD failedOperations, errorMessages, failedBatches, batch
                CALL apoc.util.validate(failedOperations > 0, "At least one sub-operation failed: %s", [reduce(all_errors = "", error IN keys(errorMessages) | all_errors + ", " + error)])
                CALL apoc.util.validate(failedBatches > 0, "At least one batch failed: %s", [reduce(all_errors = "", error IN keys(batch.errors) | all_errors + ", " + error)])
                RETURN 0
            ]]>
        </query>
        <query>
            CALL apoc.log.info("Finished acr_cloud data ingest part 13 of 169 at %s", [datetime()]);
        </query>

        <query>
            <![CDATA[
                CALL apoc.periodic.iterate(
                     "
                        WITH 'snowflake_orchard' AS url_alias,
                        '
                            SELECT * FROM facts.qa.jsonified_track_mapping ORDER BY ACR_ID ASC LIMIT 100000 OFFSET 1300000
                        '
                        AS sql
                        CALL apoc.load.jdbc(url_alias, sql)
                        YIELD row
                        return apoc.convert.fromJsonMap(row.NODE) AS row;
                    ",
                    '
                        WITH *, "database/distro-4707" AS by
                        MERGE (acrId:ACRID { id: row.acr_id })
                            ON CREATE SET
                                acrId.createdAt = datetime(),
                                acrId.createdBy = by,
                                acrId.lastModifiedAt = datetime(),
                                acrId.lastModifiedBy = by
                        MERGE (acrId)<-[acrIdToOsr:CONTAINS_FINGERPRINT]-(osr:OrchardSoundRecording)
                            ON CREATE SET
                                osr.id = apoc.create.uuid(),
                                osr.createdAt = datetime(),
                                osr.createdBy = by,
                                osr.lastModifiedAt = datetime(),
                                osr.lastModifiedBy = by,
                                acrIdToOsr.createdAt = datetime(),
                                acrIdToOsr.createdBy = by,
                                acrIdToOsr.lastModifiedAt = datetime(),
                                acrIdToOsr.lastModifiedBy = by
                        WITH *
                        UNWIND row.assets AS source_asset
                        MERGE (asset:OrchardAsset {
                            filename: source_asset.filename,
                            extension: "mp3",
                            source: "direct-delivery-db"
                        })
                            ON CREATE SET
                                asset.id = apoc.create.uuid(),
                                asset.createdAt = datetime(),
                                asset.createdBy = by,
                                asset.lastModifiedAt = datetime(),
                                asset.lastModifiedBy = by
                        MERGE (asset)-[assetToAcrId:FINGERPRINTED_AS]->(acrId)
                            ON CREATE SET
                                assetToAcrId.createdAt = datetime(),
                                assetToAcrId.createdBy = by
                            SET
                                assetToAcrId.lastModifiedAt = datetime(),
                                assetToAcrId.lastModifiedBy = by
                        WITH *
                        OPTIONAL MATCH (asset)-[assetToOldAcrId:FINGERPRINTED_AS]->(oldAcrId:ACRID)
                            WHERE oldAcrId <> acrId
                        FOREACH (hasOldAcrId IN CASE WHEN oldAcrId IS NOT NULL THEN [1] ELSE [] END |
                            CREATE (asset)-[deletedRelationship:DELETED_FINGERPRINTED_AS]->(oldAcrId)
                            SET
                                deletedRelationship += assetToOldAcrId,
                                deletedRelationship.deletedAt = datetime(),
                                deletedRelationship.deletedBy = by
                            DELETE assetToOldAcrId
                        )
                        WITH DISTINCT source_asset, by, asset
                        OPTIONAL MATCH (track:Track { id: toInteger(source_asset.tuid) })
                        CALL apoc.util.validate(track IS NULL, "Could not find the track %s", [source_asset.tuid])
                        MERGE (track)-[trackHasAsset:HAS_ASSET]->(asset)
                            ON CREATE SET
                                trackHasAsset.createdAt = datetime(),
                                trackHasAsset.createdBy = by,
                                trackHasAsset.lastModifiedAt = datetime(),
                                trackHasAsset.lastModifiedBy = by
                    ',
                    {
                        batchSize: 1000
                    }
                )
                YIELD failedOperations, errorMessages, failedBatches, batch
                CALL apoc.util.validate(failedOperations > 0, "At least one sub-operation failed: %s", [reduce(all_errors = "", error IN keys(errorMessages) | all_errors + ", " + error)])
                CALL apoc.util.validate(failedBatches > 0, "At least one batch failed: %s", [reduce(all_errors = "", error IN keys(batch.errors) | all_errors + ", " + error)])
                RETURN 0
            ]]>
        </query>
        <query>
            CALL apoc.log.info("Finished acr_cloud data ingest part 14 of 169 at %s", [datetime()]);
        </query>

        <query>
            <![CDATA[
                CALL apoc.periodic.iterate(
                     "
                        WITH 'snowflake_orchard' AS url_alias,
                        '
                            SELECT * FROM facts.qa.jsonified_track_mapping ORDER BY ACR_ID ASC LIMIT 100000 OFFSET 1400000
                        '
                        AS sql
                        CALL apoc.load.jdbc(url_alias, sql)
                        YIELD row
                        return apoc.convert.fromJsonMap(row.NODE) AS row;
                    ",
                    '
                        WITH *, "database/distro-4707" AS by
                        MERGE (acrId:ACRID { id: row.acr_id })
                            ON CREATE SET
                                acrId.createdAt = datetime(),
                                acrId.createdBy = by,
                                acrId.lastModifiedAt = datetime(),
                                acrId.lastModifiedBy = by
                        MERGE (acrId)<-[acrIdToOsr:CONTAINS_FINGERPRINT]-(osr:OrchardSoundRecording)
                            ON CREATE SET
                                osr.id = apoc.create.uuid(),
                                osr.createdAt = datetime(),
                                osr.createdBy = by,
                                osr.lastModifiedAt = datetime(),
                                osr.lastModifiedBy = by,
                                acrIdToOsr.createdAt = datetime(),
                                acrIdToOsr.createdBy = by,
                                acrIdToOsr.lastModifiedAt = datetime(),
                                acrIdToOsr.lastModifiedBy = by
                        WITH *
                        UNWIND row.assets AS source_asset
                        MERGE (asset:OrchardAsset {
                            filename: source_asset.filename,
                            extension: "mp3",
                            source: "direct-delivery-db"
                        })
                            ON CREATE SET
                                asset.id = apoc.create.uuid(),
                                asset.createdAt = datetime(),
                                asset.createdBy = by,
                                asset.lastModifiedAt = datetime(),
                                asset.lastModifiedBy = by
                        MERGE (asset)-[assetToAcrId:FINGERPRINTED_AS]->(acrId)
                            ON CREATE SET
                                assetToAcrId.createdAt = datetime(),
                                assetToAcrId.createdBy = by
                            SET
                                assetToAcrId.lastModifiedAt = datetime(),
                                assetToAcrId.lastModifiedBy = by
                        WITH *
                        OPTIONAL MATCH (asset)-[assetToOldAcrId:FINGERPRINTED_AS]->(oldAcrId:ACRID)
                            WHERE oldAcrId <> acrId
                        FOREACH (hasOldAcrId IN CASE WHEN oldAcrId IS NOT NULL THEN [1] ELSE [] END |
                            CREATE (asset)-[deletedRelationship:DELETED_FINGERPRINTED_AS]->(oldAcrId)
                            SET
                                deletedRelationship += assetToOldAcrId,
                                deletedRelationship.deletedAt = datetime(),
                                deletedRelationship.deletedBy = by
                            DELETE assetToOldAcrId
                        )
                        WITH DISTINCT source_asset, by, asset
                        OPTIONAL MATCH (track:Track { id: toInteger(source_asset.tuid) })
                        CALL apoc.util.validate(track IS NULL, "Could not find the track %s", [source_asset.tuid])
                        MERGE (track)-[trackHasAsset:HAS_ASSET]->(asset)
                            ON CREATE SET
                                trackHasAsset.createdAt = datetime(),
                                trackHasAsset.createdBy = by,
                                trackHasAsset.lastModifiedAt = datetime(),
                                trackHasAsset.lastModifiedBy = by
                    ',
                    {
                        batchSize: 1000
                    }
                )
                YIELD failedOperations, errorMessages, failedBatches, batch
                CALL apoc.util.validate(failedOperations > 0, "At least one sub-operation failed: %s", [reduce(all_errors = "", error IN keys(errorMessages) | all_errors + ", " + error)])
                CALL apoc.util.validate(failedBatches > 0, "At least one batch failed: %s", [reduce(all_errors = "", error IN keys(batch.errors) | all_errors + ", " + error)])
                RETURN 0
            ]]>
        </query>
        <query>
            CALL apoc.log.info("Finished acr_cloud data ingest part 15 of 169 at %s", [datetime()]);
        </query>

        <query>
            <![CDATA[
                CALL apoc.periodic.iterate(
                     "
                        WITH 'snowflake_orchard' AS url_alias,
                        '
                            SELECT * FROM facts.qa.jsonified_track_mapping ORDER BY ACR_ID ASC LIMIT 100000 OFFSET 1500000
                        '
                        AS sql
                        CALL apoc.load.jdbc(url_alias, sql)
                        YIELD row
                        return apoc.convert.fromJsonMap(row.NODE) AS row;
                    ",
                    '
                        WITH *, "database/distro-4707" AS by
                        MERGE (acrId:ACRID { id: row.acr_id })
                            ON CREATE SET
                                acrId.createdAt = datetime(),
                                acrId.createdBy = by,
                                acrId.lastModifiedAt = datetime(),
                                acrId.lastModifiedBy = by
                        MERGE (acrId)<-[acrIdToOsr:CONTAINS_FINGERPRINT]-(osr:OrchardSoundRecording)
                            ON CREATE SET
                                osr.id = apoc.create.uuid(),
                                osr.createdAt = datetime(),
                                osr.createdBy = by,
                                osr.lastModifiedAt = datetime(),
                                osr.lastModifiedBy = by,
                                acrIdToOsr.createdAt = datetime(),
                                acrIdToOsr.createdBy = by,
                                acrIdToOsr.lastModifiedAt = datetime(),
                                acrIdToOsr.lastModifiedBy = by
                        WITH *
                        UNWIND row.assets AS source_asset
                        MERGE (asset:OrchardAsset {
                            filename: source_asset.filename,
                            extension: "mp3",
                            source: "direct-delivery-db"
                        })
                            ON CREATE SET
                                asset.id = apoc.create.uuid(),
                                asset.createdAt = datetime(),
                                asset.createdBy = by,
                                asset.lastModifiedAt = datetime(),
                                asset.lastModifiedBy = by
                        MERGE (asset)-[assetToAcrId:FINGERPRINTED_AS]->(acrId)
                            ON CREATE SET
                                assetToAcrId.createdAt = datetime(),
                                assetToAcrId.createdBy = by
                            SET
                                assetToAcrId.lastModifiedAt = datetime(),
                                assetToAcrId.lastModifiedBy = by
                        WITH *
                        OPTIONAL MATCH (asset)-[assetToOldAcrId:FINGERPRINTED_AS]->(oldAcrId:ACRID)
                            WHERE oldAcrId <> acrId
                        FOREACH (hasOldAcrId IN CASE WHEN oldAcrId IS NOT NULL THEN [1] ELSE [] END |
                            CREATE (asset)-[deletedRelationship:DELETED_FINGERPRINTED_AS]->(oldAcrId)
                            SET
                                deletedRelationship += assetToOldAcrId,
                                deletedRelationship.deletedAt = datetime(),
                                deletedRelationship.deletedBy = by
                            DELETE assetToOldAcrId
                        )
                        WITH DISTINCT source_asset, by, asset
                        OPTIONAL MATCH (track:Track { id: toInteger(source_asset.tuid) })
                        CALL apoc.util.validate(track IS NULL, "Could not find the track %s", [source_asset.tuid])
                        MERGE (track)-[trackHasAsset:HAS_ASSET]->(asset)
                            ON CREATE SET
                                trackHasAsset.createdAt = datetime(),
                                trackHasAsset.createdBy = by,
                                trackHasAsset.lastModifiedAt = datetime(),
                                trackHasAsset.lastModifiedBy = by
                    ',
                    {
                        batchSize: 1000
                    }
                )
                YIELD failedOperations, errorMessages, failedBatches, batch
                CALL apoc.util.validate(failedOperations > 0, "At least one sub-operation failed: %s", [reduce(all_errors = "", error IN keys(errorMessages) | all_errors + ", " + error)])
                CALL apoc.util.validate(failedBatches > 0, "At least one batch failed: %s", [reduce(all_errors = "", error IN keys(batch.errors) | all_errors + ", " + error)])
                RETURN 0
            ]]>
        </query>
        <query>
            CALL apoc.log.info("Finished acr_cloud data ingest part 16 of 169 at %s", [datetime()]);
        </query>

        <query>
            <![CDATA[
                CALL apoc.periodic.iterate(
                     "
                        WITH 'snowflake_orchard' AS url_alias,
                        '
                            SELECT * FROM facts.qa.jsonified_track_mapping ORDER BY ACR_ID ASC LIMIT 100000 OFFSET 1600000
                        '
                        AS sql
                        CALL apoc.load.jdbc(url_alias, sql)
                        YIELD row
                        return apoc.convert.fromJsonMap(row.NODE) AS row;
                    ",
                    '
                        WITH *, "database/distro-4707" AS by
                        MERGE (acrId:ACRID { id: row.acr_id })
                            ON CREATE SET
                                acrId.createdAt = datetime(),
                                acrId.createdBy = by,
                                acrId.lastModifiedAt = datetime(),
                                acrId.lastModifiedBy = by
                        MERGE (acrId)<-[acrIdToOsr:CONTAINS_FINGERPRINT]-(osr:OrchardSoundRecording)
                            ON CREATE SET
                                osr.id = apoc.create.uuid(),
                                osr.createdAt = datetime(),
                                osr.createdBy = by,
                                osr.lastModifiedAt = datetime(),
                                osr.lastModifiedBy = by,
                                acrIdToOsr.createdAt = datetime(),
                                acrIdToOsr.createdBy = by,
                                acrIdToOsr.lastModifiedAt = datetime(),
                                acrIdToOsr.lastModifiedBy = by
                        WITH *
                        UNWIND row.assets AS source_asset
                        MERGE (asset:OrchardAsset {
                            filename: source_asset.filename,
                            extension: "mp3",
                            source: "direct-delivery-db"
                        })
                            ON CREATE SET
                                asset.id = apoc.create.uuid(),
                                asset.createdAt = datetime(),
                                asset.createdBy = by,
                                asset.lastModifiedAt = datetime(),
                                asset.lastModifiedBy = by
                        MERGE (asset)-[assetToAcrId:FINGERPRINTED_AS]->(acrId)
                            ON CREATE SET
                                assetToAcrId.createdAt = datetime(),
                                assetToAcrId.createdBy = by
                            SET
                                assetToAcrId.lastModifiedAt = datetime(),
                                assetToAcrId.lastModifiedBy = by
                        WITH *
                        OPTIONAL MATCH (asset)-[assetToOldAcrId:FINGERPRINTED_AS]->(oldAcrId:ACRID)
                            WHERE oldAcrId <> acrId
                        FOREACH (hasOldAcrId IN CASE WHEN oldAcrId IS NOT NULL THEN [1] ELSE [] END |
                            CREATE (asset)-[deletedRelationship:DELETED_FINGERPRINTED_AS]->(oldAcrId)
                            SET
                                deletedRelationship += assetToOldAcrId,
                                deletedRelationship.deletedAt = datetime(),
                                deletedRelationship.deletedBy = by
                            DELETE assetToOldAcrId
                        )
                        WITH DISTINCT source_asset, by, asset
                        OPTIONAL MATCH (track:Track { id: toInteger(source_asset.tuid) })
                        CALL apoc.util.validate(track IS NULL, "Could not find the track %s", [source_asset.tuid])
                        MERGE (track)-[trackHasAsset:HAS_ASSET]->(asset)
                            ON CREATE SET
                                trackHasAsset.createdAt = datetime(),
                                trackHasAsset.createdBy = by,
                                trackHasAsset.lastModifiedAt = datetime(),
                                trackHasAsset.lastModifiedBy = by
                    ',
                    {
                        batchSize: 1000
                    }
                )
                YIELD failedOperations, errorMessages, failedBatches, batch
                CALL apoc.util.validate(failedOperations > 0, "At least one sub-operation failed: %s", [reduce(all_errors = "", error IN keys(errorMessages) | all_errors + ", " + error)])
                CALL apoc.util.validate(failedBatches > 0, "At least one batch failed: %s", [reduce(all_errors = "", error IN keys(batch.errors) | all_errors + ", " + error)])
                RETURN 0
            ]]>
        </query>
        <query>
            CALL apoc.log.info("Finished acr_cloud data ingest part 17 of 169 at %s", [datetime()]);
        </query>

        <query>
            <![CDATA[
                CALL apoc.periodic.iterate(
                     "
                        WITH 'snowflake_orchard' AS url_alias,
                        '
                            SELECT * FROM facts.qa.jsonified_track_mapping ORDER BY ACR_ID ASC LIMIT 100000 OFFSET 1700000
                        '
                        AS sql
                        CALL apoc.load.jdbc(url_alias, sql)
                        YIELD row
                        return apoc.convert.fromJsonMap(row.NODE) AS row;
                    ",
                    '
                        WITH *, "database/distro-4707" AS by
                        MERGE (acrId:ACRID { id: row.acr_id })
                            ON CREATE SET
                                acrId.createdAt = datetime(),
                                acrId.createdBy = by,
                                acrId.lastModifiedAt = datetime(),
                                acrId.lastModifiedBy = by
                        MERGE (acrId)<-[acrIdToOsr:CONTAINS_FINGERPRINT]-(osr:OrchardSoundRecording)
                            ON CREATE SET
                                osr.id = apoc.create.uuid(),
                                osr.createdAt = datetime(),
                                osr.createdBy = by,
                                osr.lastModifiedAt = datetime(),
                                osr.lastModifiedBy = by,
                                acrIdToOsr.createdAt = datetime(),
                                acrIdToOsr.createdBy = by,
                                acrIdToOsr.lastModifiedAt = datetime(),
                                acrIdToOsr.lastModifiedBy = by
                        WITH *
                        UNWIND row.assets AS source_asset
                        MERGE (asset:OrchardAsset {
                            filename: source_asset.filename,
                            extension: "mp3",
                            source: "direct-delivery-db"
                        })
                            ON CREATE SET
                                asset.id = apoc.create.uuid(),
                                asset.createdAt = datetime(),
                                asset.createdBy = by,
                                asset.lastModifiedAt = datetime(),
                                asset.lastModifiedBy = by
                        MERGE (asset)-[assetToAcrId:FINGERPRINTED_AS]->(acrId)
                            ON CREATE SET
                                assetToAcrId.createdAt = datetime(),
                                assetToAcrId.createdBy = by
                            SET
                                assetToAcrId.lastModifiedAt = datetime(),
                                assetToAcrId.lastModifiedBy = by
                        WITH *
                        OPTIONAL MATCH (asset)-[assetToOldAcrId:FINGERPRINTED_AS]->(oldAcrId:ACRID)
                            WHERE oldAcrId <> acrId
                        FOREACH (hasOldAcrId IN CASE WHEN oldAcrId IS NOT NULL THEN [1] ELSE [] END |
                            CREATE (asset)-[deletedRelationship:DELETED_FINGERPRINTED_AS]->(oldAcrId)
                            SET
                                deletedRelationship += assetToOldAcrId,
                                deletedRelationship.deletedAt = datetime(),
                                deletedRelationship.deletedBy = by
                            DELETE assetToOldAcrId
                        )
                        WITH DISTINCT source_asset, by, asset
                        OPTIONAL MATCH (track:Track { id: toInteger(source_asset.tuid) })
                        CALL apoc.util.validate(track IS NULL, "Could not find the track %s", [source_asset.tuid])
                        MERGE (track)-[trackHasAsset:HAS_ASSET]->(asset)
                            ON CREATE SET
                                trackHasAsset.createdAt = datetime(),
                                trackHasAsset.createdBy = by,
                                trackHasAsset.lastModifiedAt = datetime(),
                                trackHasAsset.lastModifiedBy = by
                    ',
                    {
                        batchSize: 1000
                    }
                )
                YIELD failedOperations, errorMessages, failedBatches, batch
                CALL apoc.util.validate(failedOperations > 0, "At least one sub-operation failed: %s", [reduce(all_errors = "", error IN keys(errorMessages) | all_errors + ", " + error)])
                CALL apoc.util.validate(failedBatches > 0, "At least one batch failed: %s", [reduce(all_errors = "", error IN keys(batch.errors) | all_errors + ", " + error)])
                RETURN 0
            ]]>
        </query>
        <query>
            CALL apoc.log.info("Finished acr_cloud data ingest part 18 of 169 at %s", [datetime()]);
        </query>

        <query>
            <![CDATA[
                CALL apoc.periodic.iterate(
                     "
                        WITH 'snowflake_orchard' AS url_alias,
                        '
                            SELECT * FROM facts.qa.jsonified_track_mapping ORDER BY ACR_ID ASC LIMIT 100000 OFFSET 1800000
                        '
                        AS sql
                        CALL apoc.load.jdbc(url_alias, sql)
                        YIELD row
                        return apoc.convert.fromJsonMap(row.NODE) AS row;
                    ",
                    '
                        WITH *, "database/distro-4707" AS by
                        MERGE (acrId:ACRID { id: row.acr_id })
                            ON CREATE SET
                                acrId.createdAt = datetime(),
                                acrId.createdBy = by,
                                acrId.lastModifiedAt = datetime(),
                                acrId.lastModifiedBy = by
                        MERGE (acrId)<-[acrIdToOsr:CONTAINS_FINGERPRINT]-(osr:OrchardSoundRecording)
                            ON CREATE SET
                                osr.id = apoc.create.uuid(),
                                osr.createdAt = datetime(),
                                osr.createdBy = by,
                                osr.lastModifiedAt = datetime(),
                                osr.lastModifiedBy = by,
                                acrIdToOsr.createdAt = datetime(),
                                acrIdToOsr.createdBy = by,
                                acrIdToOsr.lastModifiedAt = datetime(),
                                acrIdToOsr.lastModifiedBy = by
                        WITH *
                        UNWIND row.assets AS source_asset
                        MERGE (asset:OrchardAsset {
                            filename: source_asset.filename,
                            extension: "mp3",
                            source: "direct-delivery-db"
                        })
                            ON CREATE SET
                                asset.id = apoc.create.uuid(),
                                asset.createdAt = datetime(),
                                asset.createdBy = by,
                                asset.lastModifiedAt = datetime(),
                                asset.lastModifiedBy = by
                        MERGE (asset)-[assetToAcrId:FINGERPRINTED_AS]->(acrId)
                            ON CREATE SET
                                assetToAcrId.createdAt = datetime(),
                                assetToAcrId.createdBy = by
                            SET
                                assetToAcrId.lastModifiedAt = datetime(),
                                assetToAcrId.lastModifiedBy = by
                        WITH *
                        OPTIONAL MATCH (asset)-[assetToOldAcrId:FINGERPRINTED_AS]->(oldAcrId:ACRID)
                            WHERE oldAcrId <> acrId
                        FOREACH (hasOldAcrId IN CASE WHEN oldAcrId IS NOT NULL THEN [1] ELSE [] END |
                            CREATE (asset)-[deletedRelationship:DELETED_FINGERPRINTED_AS]->(oldAcrId)
                            SET
                                deletedRelationship += assetToOldAcrId,
                                deletedRelationship.deletedAt = datetime(),
                                deletedRelationship.deletedBy = by
                            DELETE assetToOldAcrId
                        )
                        WITH DISTINCT source_asset, by, asset
                        OPTIONAL MATCH (track:Track { id: toInteger(source_asset.tuid) })
                        CALL apoc.util.validate(track IS NULL, "Could not find the track %s", [source_asset.tuid])
                        MERGE (track)-[trackHasAsset:HAS_ASSET]->(asset)
                            ON CREATE SET
                                trackHasAsset.createdAt = datetime(),
                                trackHasAsset.createdBy = by,
                                trackHasAsset.lastModifiedAt = datetime(),
                                trackHasAsset.lastModifiedBy = by
                    ',
                    {
                        batchSize: 1000
                    }
                )
                YIELD failedOperations, errorMessages, failedBatches, batch
                CALL apoc.util.validate(failedOperations > 0, "At least one sub-operation failed: %s", [reduce(all_errors = "", error IN keys(errorMessages) | all_errors + ", " + error)])
                CALL apoc.util.validate(failedBatches > 0, "At least one batch failed: %s", [reduce(all_errors = "", error IN keys(batch.errors) | all_errors + ", " + error)])
                RETURN 0
            ]]>
        </query>
        <query>
            CALL apoc.log.info("Finished acr_cloud data ingest part 19 of 169 at %s", [datetime()]);
        </query>

        <query>
            <![CDATA[
                CALL apoc.periodic.iterate(
                     "
                        WITH 'snowflake_orchard' AS url_alias,
                        '
                            SELECT * FROM facts.qa.jsonified_track_mapping ORDER BY ACR_ID ASC LIMIT 100000 OFFSET 1900000
                        '
                        AS sql
                        CALL apoc.load.jdbc(url_alias, sql)
                        YIELD row
                        return apoc.convert.fromJsonMap(row.NODE) AS row;
                    ",
                    '
                        WITH *, "database/distro-4707" AS by
                        MERGE (acrId:ACRID { id: row.acr_id })
                            ON CREATE SET
                                acrId.createdAt = datetime(),
                                acrId.createdBy = by,
                                acrId.lastModifiedAt = datetime(),
                                acrId.lastModifiedBy = by
                        MERGE (acrId)<-[acrIdToOsr:CONTAINS_FINGERPRINT]-(osr:OrchardSoundRecording)
                            ON CREATE SET
                                osr.id = apoc.create.uuid(),
                                osr.createdAt = datetime(),
                                osr.createdBy = by,
                                osr.lastModifiedAt = datetime(),
                                osr.lastModifiedBy = by,
                                acrIdToOsr.createdAt = datetime(),
                                acrIdToOsr.createdBy = by,
                                acrIdToOsr.lastModifiedAt = datetime(),
                                acrIdToOsr.lastModifiedBy = by
                        WITH *
                        UNWIND row.assets AS source_asset
                        MERGE (asset:OrchardAsset {
                            filename: source_asset.filename,
                            extension: "mp3",
                            source: "direct-delivery-db"
                        })
                            ON CREATE SET
                                asset.id = apoc.create.uuid(),
                                asset.createdAt = datetime(),
                                asset.createdBy = by,
                                asset.lastModifiedAt = datetime(),
                                asset.lastModifiedBy = by
                        MERGE (asset)-[assetToAcrId:FINGERPRINTED_AS]->(acrId)
                            ON CREATE SET
                                assetToAcrId.createdAt = datetime(),
                                assetToAcrId.createdBy = by
                            SET
                                assetToAcrId.lastModifiedAt = datetime(),
                                assetToAcrId.lastModifiedBy = by
                        WITH *
                        OPTIONAL MATCH (asset)-[assetToOldAcrId:FINGERPRINTED_AS]->(oldAcrId:ACRID)
                            WHERE oldAcrId <> acrId
                        FOREACH (hasOldAcrId IN CASE WHEN oldAcrId IS NOT NULL THEN [1] ELSE [] END |
                            CREATE (asset)-[deletedRelationship:DELETED_FINGERPRINTED_AS]->(oldAcrId)
                            SET
                                deletedRelationship += assetToOldAcrId,
                                deletedRelationship.deletedAt = datetime(),
                                deletedRelationship.deletedBy = by
                            DELETE assetToOldAcrId
                        )
                        WITH DISTINCT source_asset, by, asset
                        OPTIONAL MATCH (track:Track { id: toInteger(source_asset.tuid) })
                        CALL apoc.util.validate(track IS NULL, "Could not find the track %s", [source_asset.tuid])
                        MERGE (track)-[trackHasAsset:HAS_ASSET]->(asset)
                            ON CREATE SET
                                trackHasAsset.createdAt = datetime(),
                                trackHasAsset.createdBy = by,
                                trackHasAsset.lastModifiedAt = datetime(),
                                trackHasAsset.lastModifiedBy = by
                    ',
                    {
                        batchSize: 1000
                    }
                )
                YIELD failedOperations, errorMessages, failedBatches, batch
                CALL apoc.util.validate(failedOperations > 0, "At least one sub-operation failed: %s", [reduce(all_errors = "", error IN keys(errorMessages) | all_errors + ", " + error)])
                CALL apoc.util.validate(failedBatches > 0, "At least one batch failed: %s", [reduce(all_errors = "", error IN keys(batch.errors) | all_errors + ", " + error)])
                RETURN 0
            ]]>
        </query>
        <query>
            CALL apoc.log.info("Finished acr_cloud data ingest part 20 of 169 at %s", [datetime()]);
        </query>

        <query>
            <![CDATA[
                CALL apoc.periodic.iterate(
                     "
                        WITH 'snowflake_orchard' AS url_alias,
                        '
                            SELECT * FROM facts.qa.jsonified_track_mapping ORDER BY ACR_ID ASC LIMIT 100000 OFFSET 2000000
                        '
                        AS sql
                        CALL apoc.load.jdbc(url_alias, sql)
                        YIELD row
                        return apoc.convert.fromJsonMap(row.NODE) AS row;
                    ",
                    '
                        WITH *, "database/distro-4707" AS by
                        MERGE (acrId:ACRID { id: row.acr_id })
                            ON CREATE SET
                                acrId.createdAt = datetime(),
                                acrId.createdBy = by,
                                acrId.lastModifiedAt = datetime(),
                                acrId.lastModifiedBy = by
                        MERGE (acrId)<-[acrIdToOsr:CONTAINS_FINGERPRINT]-(osr:OrchardSoundRecording)
                            ON CREATE SET
                                osr.id = apoc.create.uuid(),
                                osr.createdAt = datetime(),
                                osr.createdBy = by,
                                osr.lastModifiedAt = datetime(),
                                osr.lastModifiedBy = by,
                                acrIdToOsr.createdAt = datetime(),
                                acrIdToOsr.createdBy = by,
                                acrIdToOsr.lastModifiedAt = datetime(),
                                acrIdToOsr.lastModifiedBy = by
                        WITH *
                        UNWIND row.assets AS source_asset
                        MERGE (asset:OrchardAsset {
                            filename: source_asset.filename,
                            extension: "mp3",
                            source: "direct-delivery-db"
                        })
                            ON CREATE SET
                                asset.id = apoc.create.uuid(),
                                asset.createdAt = datetime(),
                                asset.createdBy = by,
                                asset.lastModifiedAt = datetime(),
                                asset.lastModifiedBy = by
                        MERGE (asset)-[assetToAcrId:FINGERPRINTED_AS]->(acrId)
                            ON CREATE SET
                                assetToAcrId.createdAt = datetime(),
                                assetToAcrId.createdBy = by
                            SET
                                assetToAcrId.lastModifiedAt = datetime(),
                                assetToAcrId.lastModifiedBy = by
                        WITH *
                        OPTIONAL MATCH (asset)-[assetToOldAcrId:FINGERPRINTED_AS]->(oldAcrId:ACRID)
                            WHERE oldAcrId <> acrId
                        FOREACH (hasOldAcrId IN CASE WHEN oldAcrId IS NOT NULL THEN [1] ELSE [] END |
                            CREATE (asset)-[deletedRelationship:DELETED_FINGERPRINTED_AS]->(oldAcrId)
                            SET
                                deletedRelationship += assetToOldAcrId,
                                deletedRelationship.deletedAt = datetime(),
                                deletedRelationship.deletedBy = by
                            DELETE assetToOldAcrId
                        )
                        WITH DISTINCT source_asset, by, asset
                        OPTIONAL MATCH (track:Track { id: toInteger(source_asset.tuid) })
                        CALL apoc.util.validate(track IS NULL, "Could not find the track %s", [source_asset.tuid])
                        MERGE (track)-[trackHasAsset:HAS_ASSET]->(asset)
                            ON CREATE SET
                                trackHasAsset.createdAt = datetime(),
                                trackHasAsset.createdBy = by,
                                trackHasAsset.lastModifiedAt = datetime(),
                                trackHasAsset.lastModifiedBy = by
                    ',
                    {
                        batchSize: 1000
                    }
                )
                YIELD failedOperations, errorMessages, failedBatches, batch
                CALL apoc.util.validate(failedOperations > 0, "At least one sub-operation failed: %s", [reduce(all_errors = "", error IN keys(errorMessages) | all_errors + ", " + error)])
                CALL apoc.util.validate(failedBatches > 0, "At least one batch failed: %s", [reduce(all_errors = "", error IN keys(batch.errors) | all_errors + ", " + error)])
                RETURN 0
            ]]>
        </query>
        <query>
            CALL apoc.log.info("Finished acr_cloud data ingest part 21 of 169 at %s", [datetime()]);
        </query>

        <query>
            <![CDATA[
                CALL apoc.periodic.iterate(
                     "
                        WITH 'snowflake_orchard' AS url_alias,
                        '
                            SELECT * FROM facts.qa.jsonified_track_mapping ORDER BY ACR_ID ASC LIMIT 100000 OFFSET 2100000
                        '
                        AS sql
                        CALL apoc.load.jdbc(url_alias, sql)
                        YIELD row
                        return apoc.convert.fromJsonMap(row.NODE) AS row;
                    ",
                    '
                        WITH *, "database/distro-4707" AS by
                        MERGE (acrId:ACRID { id: row.acr_id })
                            ON CREATE SET
                                acrId.createdAt = datetime(),
                                acrId.createdBy = by,
                                acrId.lastModifiedAt = datetime(),
                                acrId.lastModifiedBy = by
                        MERGE (acrId)<-[acrIdToOsr:CONTAINS_FINGERPRINT]-(osr:OrchardSoundRecording)
                            ON CREATE SET
                                osr.id = apoc.create.uuid(),
                                osr.createdAt = datetime(),
                                osr.createdBy = by,
                                osr.lastModifiedAt = datetime(),
                                osr.lastModifiedBy = by,
                                acrIdToOsr.createdAt = datetime(),
                                acrIdToOsr.createdBy = by,
                                acrIdToOsr.lastModifiedAt = datetime(),
                                acrIdToOsr.lastModifiedBy = by
                        WITH *
                        UNWIND row.assets AS source_asset
                        MERGE (asset:OrchardAsset {
                            filename: source_asset.filename,
                            extension: "mp3",
                            source: "direct-delivery-db"
                        })
                            ON CREATE SET
                                asset.id = apoc.create.uuid(),
                                asset.createdAt = datetime(),
                                asset.createdBy = by,
                                asset.lastModifiedAt = datetime(),
                                asset.lastModifiedBy = by
                        MERGE (asset)-[assetToAcrId:FINGERPRINTED_AS]->(acrId)
                            ON CREATE SET
                                assetToAcrId.createdAt = datetime(),
                                assetToAcrId.createdBy = by
                            SET
                                assetToAcrId.lastModifiedAt = datetime(),
                                assetToAcrId.lastModifiedBy = by
                        WITH *
                        OPTIONAL MATCH (asset)-[assetToOldAcrId:FINGERPRINTED_AS]->(oldAcrId:ACRID)
                            WHERE oldAcrId <> acrId
                        FOREACH (hasOldAcrId IN CASE WHEN oldAcrId IS NOT NULL THEN [1] ELSE [] END |
                            CREATE (asset)-[deletedRelationship:DELETED_FINGERPRINTED_AS]->(oldAcrId)
                            SET
                                deletedRelationship += assetToOldAcrId,
                                deletedRelationship.deletedAt = datetime(),
                                deletedRelationship.deletedBy = by
                            DELETE assetToOldAcrId
                        )
                        WITH DISTINCT source_asset, by, asset
                        OPTIONAL MATCH (track:Track { id: toInteger(source_asset.tuid) })
                        CALL apoc.util.validate(track IS NULL, "Could not find the track %s", [source_asset.tuid])
                        MERGE (track)-[trackHasAsset:HAS_ASSET]->(asset)
                            ON CREATE SET
                                trackHasAsset.createdAt = datetime(),
                                trackHasAsset.createdBy = by,
                                trackHasAsset.lastModifiedAt = datetime(),
                                trackHasAsset.lastModifiedBy = by
                    ',
                    {
                        batchSize: 1000
                    }
                )
                YIELD failedOperations, errorMessages, failedBatches, batch
                CALL apoc.util.validate(failedOperations > 0, "At least one sub-operation failed: %s", [reduce(all_errors = "", error IN keys(errorMessages) | all_errors + ", " + error)])
                CALL apoc.util.validate(failedBatches > 0, "At least one batch failed: %s", [reduce(all_errors = "", error IN keys(batch.errors) | all_errors + ", " + error)])
                RETURN 0
            ]]>
        </query>
        <query>
            CALL apoc.log.info("Finished acr_cloud data ingest part 22 of 169 at %s", [datetime()]);
        </query>

        <query>
            <![CDATA[
                CALL apoc.periodic.iterate(
                     "
                        WITH 'snowflake_orchard' AS url_alias,
                        '
                            SELECT * FROM facts.qa.jsonified_track_mapping ORDER BY ACR_ID ASC LIMIT 100000 OFFSET 2200000
                        '
                        AS sql
                        CALL apoc.load.jdbc(url_alias, sql)
                        YIELD row
                        return apoc.convert.fromJsonMap(row.NODE) AS row;
                    ",
                    '
                        WITH *, "database/distro-4707" AS by
                        MERGE (acrId:ACRID { id: row.acr_id })
                            ON CREATE SET
                                acrId.createdAt = datetime(),
                                acrId.createdBy = by,
                                acrId.lastModifiedAt = datetime(),
                                acrId.lastModifiedBy = by
                        MERGE (acrId)<-[acrIdToOsr:CONTAINS_FINGERPRINT]-(osr:OrchardSoundRecording)
                            ON CREATE SET
                                osr.id = apoc.create.uuid(),
                                osr.createdAt = datetime(),
                                osr.createdBy = by,
                                osr.lastModifiedAt = datetime(),
                                osr.lastModifiedBy = by,
                                acrIdToOsr.createdAt = datetime(),
                                acrIdToOsr.createdBy = by,
                                acrIdToOsr.lastModifiedAt = datetime(),
                                acrIdToOsr.lastModifiedBy = by
                        WITH *
                        UNWIND row.assets AS source_asset
                        MERGE (asset:OrchardAsset {
                            filename: source_asset.filename,
                            extension: "mp3",
                            source: "direct-delivery-db"
                        })
                            ON CREATE SET
                                asset.id = apoc.create.uuid(),
                                asset.createdAt = datetime(),
                                asset.createdBy = by,
                                asset.lastModifiedAt = datetime(),
                                asset.lastModifiedBy = by
                        MERGE (asset)-[assetToAcrId:FINGERPRINTED_AS]->(acrId)
                            ON CREATE SET
                                assetToAcrId.createdAt = datetime(),
                                assetToAcrId.createdBy = by
                            SET
                                assetToAcrId.lastModifiedAt = datetime(),
                                assetToAcrId.lastModifiedBy = by
                        WITH *
                        OPTIONAL MATCH (asset)-[assetToOldAcrId:FINGERPRINTED_AS]->(oldAcrId:ACRID)
                            WHERE oldAcrId <> acrId
                        FOREACH (hasOldAcrId IN CASE WHEN oldAcrId IS NOT NULL THEN [1] ELSE [] END |
                            CREATE (asset)-[deletedRelationship:DELETED_FINGERPRINTED_AS]->(oldAcrId)
                            SET
                                deletedRelationship += assetToOldAcrId,
                                deletedRelationship.deletedAt = datetime(),
                                deletedRelationship.deletedBy = by
                            DELETE assetToOldAcrId
                        )
                        WITH DISTINCT source_asset, by, asset
                        OPTIONAL MATCH (track:Track { id: toInteger(source_asset.tuid) })
                        CALL apoc.util.validate(track IS NULL, "Could not find the track %s", [source_asset.tuid])
                        MERGE (track)-[trackHasAsset:HAS_ASSET]->(asset)
                            ON CREATE SET
                                trackHasAsset.createdAt = datetime(),
                                trackHasAsset.createdBy = by,
                                trackHasAsset.lastModifiedAt = datetime(),
                                trackHasAsset.lastModifiedBy = by
                    ',
                    {
                        batchSize: 1000
                    }
                )
                YIELD failedOperations, errorMessages, failedBatches, batch
                CALL apoc.util.validate(failedOperations > 0, "At least one sub-operation failed: %s", [reduce(all_errors = "", error IN keys(errorMessages) | all_errors + ", " + error)])
                CALL apoc.util.validate(failedBatches > 0, "At least one batch failed: %s", [reduce(all_errors = "", error IN keys(batch.errors) | all_errors + ", " + error)])
                RETURN 0
            ]]>
        </query>
        <query>
            CALL apoc.log.info("Finished acr_cloud data ingest part 23 of 169 at %s", [datetime()]);
        </query>

        <query>
            <![CDATA[
                CALL apoc.periodic.iterate(
                     "
                        WITH 'snowflake_orchard' AS url_alias,
                        '
                            SELECT * FROM facts.qa.jsonified_track_mapping ORDER BY ACR_ID ASC LIMIT 100000 OFFSET 2300000
                        '
                        AS sql
                        CALL apoc.load.jdbc(url_alias, sql)
                        YIELD row
                        return apoc.convert.fromJsonMap(row.NODE) AS row;
                    ",
                    '
                        WITH *, "database/distro-4707" AS by
                        MERGE (acrId:ACRID { id: row.acr_id })
                            ON CREATE SET
                                acrId.createdAt = datetime(),
                                acrId.createdBy = by,
                                acrId.lastModifiedAt = datetime(),
                                acrId.lastModifiedBy = by
                        MERGE (acrId)<-[acrIdToOsr:CONTAINS_FINGERPRINT]-(osr:OrchardSoundRecording)
                            ON CREATE SET
                                osr.id = apoc.create.uuid(),
                                osr.createdAt = datetime(),
                                osr.createdBy = by,
                                osr.lastModifiedAt = datetime(),
                                osr.lastModifiedBy = by,
                                acrIdToOsr.createdAt = datetime(),
                                acrIdToOsr.createdBy = by,
                                acrIdToOsr.lastModifiedAt = datetime(),
                                acrIdToOsr.lastModifiedBy = by
                        WITH *
                        UNWIND row.assets AS source_asset
                        MERGE (asset:OrchardAsset {
                            filename: source_asset.filename,
                            extension: "mp3",
                            source: "direct-delivery-db"
                        })
                            ON CREATE SET
                                asset.id = apoc.create.uuid(),
                                asset.createdAt = datetime(),
                                asset.createdBy = by,
                                asset.lastModifiedAt = datetime(),
                                asset.lastModifiedBy = by
                        MERGE (asset)-[assetToAcrId:FINGERPRINTED_AS]->(acrId)
                            ON CREATE SET
                                assetToAcrId.createdAt = datetime(),
                                assetToAcrId.createdBy = by
                            SET
                                assetToAcrId.lastModifiedAt = datetime(),
                                assetToAcrId.lastModifiedBy = by
                        WITH *
                        OPTIONAL MATCH (asset)-[assetToOldAcrId:FINGERPRINTED_AS]->(oldAcrId:ACRID)
                            WHERE oldAcrId <> acrId
                        FOREACH (hasOldAcrId IN CASE WHEN oldAcrId IS NOT NULL THEN [1] ELSE [] END |
                            CREATE (asset)-[deletedRelationship:DELETED_FINGERPRINTED_AS]->(oldAcrId)
                            SET
                                deletedRelationship += assetToOldAcrId,
                                deletedRelationship.deletedAt = datetime(),
                                deletedRelationship.deletedBy = by
                            DELETE assetToOldAcrId
                        )
                        WITH DISTINCT source_asset, by, asset
                        OPTIONAL MATCH (track:Track { id: toInteger(source_asset.tuid) })
                        CALL apoc.util.validate(track IS NULL, "Could not find the track %s", [source_asset.tuid])
                        MERGE (track)-[trackHasAsset:HAS_ASSET]->(asset)
                            ON CREATE SET
                                trackHasAsset.createdAt = datetime(),
                                trackHasAsset.createdBy = by,
                                trackHasAsset.lastModifiedAt = datetime(),
                                trackHasAsset.lastModifiedBy = by
                    ',
                    {
                        batchSize: 1000
                    }
                )
                YIELD failedOperations, errorMessages, failedBatches, batch
                CALL apoc.util.validate(failedOperations > 0, "At least one sub-operation failed: %s", [reduce(all_errors = "", error IN keys(errorMessages) | all_errors + ", " + error)])
                CALL apoc.util.validate(failedBatches > 0, "At least one batch failed: %s", [reduce(all_errors = "", error IN keys(batch.errors) | all_errors + ", " + error)])
                RETURN 0
            ]]>
        </query>
        <query>
            CALL apoc.log.info("Finished acr_cloud data ingest part 24 of 169 at %s", [datetime()]);
        </query>

        <query>
            <![CDATA[
                CALL apoc.periodic.iterate(
                     "
                        WITH 'snowflake_orchard' AS url_alias,
                        '
                            SELECT * FROM facts.qa.jsonified_track_mapping ORDER BY ACR_ID ASC LIMIT 100000 OFFSET 2400000
                        '
                        AS sql
                        CALL apoc.load.jdbc(url_alias, sql)
                        YIELD row
                        return apoc.convert.fromJsonMap(row.NODE) AS row;
                    ",
                    '
                        WITH *, "database/distro-4707" AS by
                        MERGE (acrId:ACRID { id: row.acr_id })
                            ON CREATE SET
                                acrId.createdAt = datetime(),
                                acrId.createdBy = by,
                                acrId.lastModifiedAt = datetime(),
                                acrId.lastModifiedBy = by
                        MERGE (acrId)<-[acrIdToOsr:CONTAINS_FINGERPRINT]-(osr:OrchardSoundRecording)
                            ON CREATE SET
                                osr.id = apoc.create.uuid(),
                                osr.createdAt = datetime(),
                                osr.createdBy = by,
                                osr.lastModifiedAt = datetime(),
                                osr.lastModifiedBy = by,
                                acrIdToOsr.createdAt = datetime(),
                                acrIdToOsr.createdBy = by,
                                acrIdToOsr.lastModifiedAt = datetime(),
                                acrIdToOsr.lastModifiedBy = by
                        WITH *
                        UNWIND row.assets AS source_asset
                        MERGE (asset:OrchardAsset {
                            filename: source_asset.filename,
                            extension: "mp3",
                            source: "direct-delivery-db"
                        })
                            ON CREATE SET
                                asset.id = apoc.create.uuid(),
                                asset.createdAt = datetime(),
                                asset.createdBy = by,
                                asset.lastModifiedAt = datetime(),
                                asset.lastModifiedBy = by
                        MERGE (asset)-[assetToAcrId:FINGERPRINTED_AS]->(acrId)
                            ON CREATE SET
                                assetToAcrId.createdAt = datetime(),
                                assetToAcrId.createdBy = by
                            SET
                                assetToAcrId.lastModifiedAt = datetime(),
                                assetToAcrId.lastModifiedBy = by
                        WITH *
                        OPTIONAL MATCH (asset)-[assetToOldAcrId:FINGERPRINTED_AS]->(oldAcrId:ACRID)
                            WHERE oldAcrId <> acrId
                        FOREACH (hasOldAcrId IN CASE WHEN oldAcrId IS NOT NULL THEN [1] ELSE [] END |
                            CREATE (asset)-[deletedRelationship:DELETED_FINGERPRINTED_AS]->(oldAcrId)
                            SET
                                deletedRelationship += assetToOldAcrId,
                                deletedRelationship.deletedAt = datetime(),
                                deletedRelationship.deletedBy = by
                            DELETE assetToOldAcrId
                        )
                        WITH DISTINCT source_asset, by, asset
                        OPTIONAL MATCH (track:Track { id: toInteger(source_asset.tuid) })
                        CALL apoc.util.validate(track IS NULL, "Could not find the track %s", [source_asset.tuid])
                        MERGE (track)-[trackHasAsset:HAS_ASSET]->(asset)
                            ON CREATE SET
                                trackHasAsset.createdAt = datetime(),
                                trackHasAsset.createdBy = by,
                                trackHasAsset.lastModifiedAt = datetime(),
                                trackHasAsset.lastModifiedBy = by
                    ',
                    {
                        batchSize: 1000
                    }
                )
                YIELD failedOperations, errorMessages, failedBatches, batch
                CALL apoc.util.validate(failedOperations > 0, "At least one sub-operation failed: %s", [reduce(all_errors = "", error IN keys(errorMessages) | all_errors + ", " + error)])
                CALL apoc.util.validate(failedBatches > 0, "At least one batch failed: %s", [reduce(all_errors = "", error IN keys(batch.errors) | all_errors + ", " + error)])
                RETURN 0
            ]]>
        </query>
        <query>
            CALL apoc.log.info("Finished acr_cloud data ingest part 25 of 169 at %s", [datetime()]);
        </query>

        <query>
            <![CDATA[
                CALL apoc.periodic.iterate(
                     "
                        WITH 'snowflake_orchard' AS url_alias,
                        '
                            SELECT * FROM facts.qa.jsonified_track_mapping ORDER BY ACR_ID ASC LIMIT 100000 OFFSET 2500000
                        '
                        AS sql
                        CALL apoc.load.jdbc(url_alias, sql)
                        YIELD row
                        return apoc.convert.fromJsonMap(row.NODE) AS row;
                    ",
                    '
                        WITH *, "database/distro-4707" AS by
                        MERGE (acrId:ACRID { id: row.acr_id })
                            ON CREATE SET
                                acrId.createdAt = datetime(),
                                acrId.createdBy = by,
                                acrId.lastModifiedAt = datetime(),
                                acrId.lastModifiedBy = by
                        MERGE (acrId)<-[acrIdToOsr:CONTAINS_FINGERPRINT]-(osr:OrchardSoundRecording)
                            ON CREATE SET
                                osr.id = apoc.create.uuid(),
                                osr.createdAt = datetime(),
                                osr.createdBy = by,
                                osr.lastModifiedAt = datetime(),
                                osr.lastModifiedBy = by,
                                acrIdToOsr.createdAt = datetime(),
                                acrIdToOsr.createdBy = by,
                                acrIdToOsr.lastModifiedAt = datetime(),
                                acrIdToOsr.lastModifiedBy = by
                        WITH *
                        UNWIND row.assets AS source_asset
                        MERGE (asset:OrchardAsset {
                            filename: source_asset.filename,
                            extension: "mp3",
                            source: "direct-delivery-db"
                        })
                            ON CREATE SET
                                asset.id = apoc.create.uuid(),
                                asset.createdAt = datetime(),
                                asset.createdBy = by,
                                asset.lastModifiedAt = datetime(),
                                asset.lastModifiedBy = by
                        MERGE (asset)-[assetToAcrId:FINGERPRINTED_AS]->(acrId)
                            ON CREATE SET
                                assetToAcrId.createdAt = datetime(),
                                assetToAcrId.createdBy = by
                            SET
                                assetToAcrId.lastModifiedAt = datetime(),
                                assetToAcrId.lastModifiedBy = by
                        WITH *
                        OPTIONAL MATCH (asset)-[assetToOldAcrId:FINGERPRINTED_AS]->(oldAcrId:ACRID)
                            WHERE oldAcrId <> acrId
                        FOREACH (hasOldAcrId IN CASE WHEN oldAcrId IS NOT NULL THEN [1] ELSE [] END |
                            CREATE (asset)-[deletedRelationship:DELETED_FINGERPRINTED_AS]->(oldAcrId)
                            SET
                                deletedRelationship += assetToOldAcrId,
                                deletedRelationship.deletedAt = datetime(),
                                deletedRelationship.deletedBy = by
                            DELETE assetToOldAcrId
                        )
                        WITH DISTINCT source_asset, by, asset
                        OPTIONAL MATCH (track:Track { id: toInteger(source_asset.tuid) })
                        CALL apoc.util.validate(track IS NULL, "Could not find the track %s", [source_asset.tuid])
                        MERGE (track)-[trackHasAsset:HAS_ASSET]->(asset)
                            ON CREATE SET
                                trackHasAsset.createdAt = datetime(),
                                trackHasAsset.createdBy = by,
                                trackHasAsset.lastModifiedAt = datetime(),
                                trackHasAsset.lastModifiedBy = by
                    ',
                    {
                        batchSize: 1000
                    }
                )
                YIELD failedOperations, errorMessages, failedBatches, batch
                CALL apoc.util.validate(failedOperations > 0, "At least one sub-operation failed: %s", [reduce(all_errors = "", error IN keys(errorMessages) | all_errors + ", " + error)])
                CALL apoc.util.validate(failedBatches > 0, "At least one batch failed: %s", [reduce(all_errors = "", error IN keys(batch.errors) | all_errors + ", " + error)])
                RETURN 0
            ]]>
        </query>
        <query>
            CALL apoc.log.info("Finished acr_cloud data ingest part 26 of 169 at %s", [datetime()]);
        </query>

        <query>
            <![CDATA[
                CALL apoc.periodic.iterate(
                     "
                        WITH 'snowflake_orchard' AS url_alias,
                        '
                            SELECT * FROM facts.qa.jsonified_track_mapping ORDER BY ACR_ID ASC LIMIT 100000 OFFSET 2600000
                        '
                        AS sql
                        CALL apoc.load.jdbc(url_alias, sql)
                        YIELD row
                        return apoc.convert.fromJsonMap(row.NODE) AS row;
                    ",
                    '
                        WITH *, "database/distro-4707" AS by
                        MERGE (acrId:ACRID { id: row.acr_id })
                            ON CREATE SET
                                acrId.createdAt = datetime(),
                                acrId.createdBy = by,
                                acrId.lastModifiedAt = datetime(),
                                acrId.lastModifiedBy = by
                        MERGE (acrId)<-[acrIdToOsr:CONTAINS_FINGERPRINT]-(osr:OrchardSoundRecording)
                            ON CREATE SET
                                osr.id = apoc.create.uuid(),
                                osr.createdAt = datetime(),
                                osr.createdBy = by,
                                osr.lastModifiedAt = datetime(),
                                osr.lastModifiedBy = by,
                                acrIdToOsr.createdAt = datetime(),
                                acrIdToOsr.createdBy = by,
                                acrIdToOsr.lastModifiedAt = datetime(),
                                acrIdToOsr.lastModifiedBy = by
                        WITH *
                        UNWIND row.assets AS source_asset
                        MERGE (asset:OrchardAsset {
                            filename: source_asset.filename,
                            extension: "mp3",
                            source: "direct-delivery-db"
                        })
                            ON CREATE SET
                                asset.id = apoc.create.uuid(),
                                asset.createdAt = datetime(),
                                asset.createdBy = by,
                                asset.lastModifiedAt = datetime(),
                                asset.lastModifiedBy = by
                        MERGE (asset)-[assetToAcrId:FINGERPRINTED_AS]->(acrId)
                            ON CREATE SET
                                assetToAcrId.createdAt = datetime(),
                                assetToAcrId.createdBy = by
                            SET
                                assetToAcrId.lastModifiedAt = datetime(),
                                assetToAcrId.lastModifiedBy = by
                        WITH *
                        OPTIONAL MATCH (asset)-[assetToOldAcrId:FINGERPRINTED_AS]->(oldAcrId:ACRID)
                            WHERE oldAcrId <> acrId
                        FOREACH (hasOldAcrId IN CASE WHEN oldAcrId IS NOT NULL THEN [1] ELSE [] END |
                            CREATE (asset)-[deletedRelationship:DELETED_FINGERPRINTED_AS]->(oldAcrId)
                            SET
                                deletedRelationship += assetToOldAcrId,
                                deletedRelationship.deletedAt = datetime(),
                                deletedRelationship.deletedBy = by
                            DELETE assetToOldAcrId
                        )
                        WITH DISTINCT source_asset, by, asset
                        OPTIONAL MATCH (track:Track { id: toInteger(source_asset.tuid) })
                        CALL apoc.util.validate(track IS NULL, "Could not find the track %s", [source_asset.tuid])
                        MERGE (track)-[trackHasAsset:HAS_ASSET]->(asset)
                            ON CREATE SET
                                trackHasAsset.createdAt = datetime(),
                                trackHasAsset.createdBy = by,
                                trackHasAsset.lastModifiedAt = datetime(),
                                trackHasAsset.lastModifiedBy = by
                    ',
                    {
                        batchSize: 1000
                    }
                )
                YIELD failedOperations, errorMessages, failedBatches, batch
                CALL apoc.util.validate(failedOperations > 0, "At least one sub-operation failed: %s", [reduce(all_errors = "", error IN keys(errorMessages) | all_errors + ", " + error)])
                CALL apoc.util.validate(failedBatches > 0, "At least one batch failed: %s", [reduce(all_errors = "", error IN keys(batch.errors) | all_errors + ", " + error)])
                RETURN 0
            ]]>
        </query>
        <query>
            CALL apoc.log.info("Finished acr_cloud data ingest part 27 of 169 at %s", [datetime()]);
        </query>

        <query>
            <![CDATA[
                CALL apoc.periodic.iterate(
                     "
                        WITH 'snowflake_orchard' AS url_alias,
                        '
                            SELECT * FROM facts.qa.jsonified_track_mapping ORDER BY ACR_ID ASC LIMIT 100000 OFFSET 2700000
                        '
                        AS sql
                        CALL apoc.load.jdbc(url_alias, sql)
                        YIELD row
                        return apoc.convert.fromJsonMap(row.NODE) AS row;
                    ",
                    '
                        WITH *, "database/distro-4707" AS by
                        MERGE (acrId:ACRID { id: row.acr_id })
                            ON CREATE SET
                                acrId.createdAt = datetime(),
                                acrId.createdBy = by,
                                acrId.lastModifiedAt = datetime(),
                                acrId.lastModifiedBy = by
                        MERGE (acrId)<-[acrIdToOsr:CONTAINS_FINGERPRINT]-(osr:OrchardSoundRecording)
                            ON CREATE SET
                                osr.id = apoc.create.uuid(),
                                osr.createdAt = datetime(),
                                osr.createdBy = by,
                                osr.lastModifiedAt = datetime(),
                                osr.lastModifiedBy = by,
                                acrIdToOsr.createdAt = datetime(),
                                acrIdToOsr.createdBy = by,
                                acrIdToOsr.lastModifiedAt = datetime(),
                                acrIdToOsr.lastModifiedBy = by
                        WITH *
                        UNWIND row.assets AS source_asset
                        MERGE (asset:OrchardAsset {
                            filename: source_asset.filename,
                            extension: "mp3",
                            source: "direct-delivery-db"
                        })
                            ON CREATE SET
                                asset.id = apoc.create.uuid(),
                                asset.createdAt = datetime(),
                                asset.createdBy = by,
                                asset.lastModifiedAt = datetime(),
                                asset.lastModifiedBy = by
                        MERGE (asset)-[assetToAcrId:FINGERPRINTED_AS]->(acrId)
                            ON CREATE SET
                                assetToAcrId.createdAt = datetime(),
                                assetToAcrId.createdBy = by
                            SET
                                assetToAcrId.lastModifiedAt = datetime(),
                                assetToAcrId.lastModifiedBy = by
                        WITH *
                        OPTIONAL MATCH (asset)-[assetToOldAcrId:FINGERPRINTED_AS]->(oldAcrId:ACRID)
                            WHERE oldAcrId <> acrId
                        FOREACH (hasOldAcrId IN CASE WHEN oldAcrId IS NOT NULL THEN [1] ELSE [] END |
                            CREATE (asset)-[deletedRelationship:DELETED_FINGERPRINTED_AS]->(oldAcrId)
                            SET
                                deletedRelationship += assetToOldAcrId,
                                deletedRelationship.deletedAt = datetime(),
                                deletedRelationship.deletedBy = by
                            DELETE assetToOldAcrId
                        )
                        WITH DISTINCT source_asset, by, asset
                        OPTIONAL MATCH (track:Track { id: toInteger(source_asset.tuid) })
                        CALL apoc.util.validate(track IS NULL, "Could not find the track %s", [source_asset.tuid])
                        MERGE (track)-[trackHasAsset:HAS_ASSET]->(asset)
                            ON CREATE SET
                                trackHasAsset.createdAt = datetime(),
                                trackHasAsset.createdBy = by,
                                trackHasAsset.lastModifiedAt = datetime(),
                                trackHasAsset.lastModifiedBy = by
                    ',
                    {
                        batchSize: 1000
                    }
                )
                YIELD failedOperations, errorMessages, failedBatches, batch
                CALL apoc.util.validate(failedOperations > 0, "At least one sub-operation failed: %s", [reduce(all_errors = "", error IN keys(errorMessages) | all_errors + ", " + error)])
                CALL apoc.util.validate(failedBatches > 0, "At least one batch failed: %s", [reduce(all_errors = "", error IN keys(batch.errors) | all_errors + ", " + error)])
                RETURN 0
            ]]>
        </query>
        <query>
            CALL apoc.log.info("Finished acr_cloud data ingest part 28 of 169 at %s", [datetime()]);
        </query>

        <query>
            <![CDATA[
                CALL apoc.periodic.iterate(
                     "
                        WITH 'snowflake_orchard' AS url_alias,
                        '
                            SELECT * FROM facts.qa.jsonified_track_mapping ORDER BY ACR_ID ASC LIMIT 100000 OFFSET 2800000
                        '
                        AS sql
                        CALL apoc.load.jdbc(url_alias, sql)
                        YIELD row
                        return apoc.convert.fromJsonMap(row.NODE) AS row;
                    ",
                    '
                        WITH *, "database/distro-4707" AS by
                        MERGE (acrId:ACRID { id: row.acr_id })
                            ON CREATE SET
                                acrId.createdAt = datetime(),
                                acrId.createdBy = by,
                                acrId.lastModifiedAt = datetime(),
                                acrId.lastModifiedBy = by
                        MERGE (acrId)<-[acrIdToOsr:CONTAINS_FINGERPRINT]-(osr:OrchardSoundRecording)
                            ON CREATE SET
                                osr.id = apoc.create.uuid(),
                                osr.createdAt = datetime(),
                                osr.createdBy = by,
                                osr.lastModifiedAt = datetime(),
                                osr.lastModifiedBy = by,
                                acrIdToOsr.createdAt = datetime(),
                                acrIdToOsr.createdBy = by,
                                acrIdToOsr.lastModifiedAt = datetime(),
                                acrIdToOsr.lastModifiedBy = by
                        WITH *
                        UNWIND row.assets AS source_asset
                        MERGE (asset:OrchardAsset {
                            filename: source_asset.filename,
                            extension: "mp3",
                            source: "direct-delivery-db"
                        })
                            ON CREATE SET
                                asset.id = apoc.create.uuid(),
                                asset.createdAt = datetime(),
                                asset.createdBy = by,
                                asset.lastModifiedAt = datetime(),
                                asset.lastModifiedBy = by
                        MERGE (asset)-[assetToAcrId:FINGERPRINTED_AS]->(acrId)
                            ON CREATE SET
                                assetToAcrId.createdAt = datetime(),
                                assetToAcrId.createdBy = by
                            SET
                                assetToAcrId.lastModifiedAt = datetime(),
                                assetToAcrId.lastModifiedBy = by
                        WITH *
                        OPTIONAL MATCH (asset)-[assetToOldAcrId:FINGERPRINTED_AS]->(oldAcrId:ACRID)
                            WHERE oldAcrId <> acrId
                        FOREACH (hasOldAcrId IN CASE WHEN oldAcrId IS NOT NULL THEN [1] ELSE [] END |
                            CREATE (asset)-[deletedRelationship:DELETED_FINGERPRINTED_AS]->(oldAcrId)
                            SET
                                deletedRelationship += assetToOldAcrId,
                                deletedRelationship.deletedAt = datetime(),
                                deletedRelationship.deletedBy = by
                            DELETE assetToOldAcrId
                        )
                        WITH DISTINCT source_asset, by, asset
                        OPTIONAL MATCH (track:Track { id: toInteger(source_asset.tuid) })
                        CALL apoc.util.validate(track IS NULL, "Could not find the track %s", [source_asset.tuid])
                        MERGE (track)-[trackHasAsset:HAS_ASSET]->(asset)
                            ON CREATE SET
                                trackHasAsset.createdAt = datetime(),
                                trackHasAsset.createdBy = by,
                                trackHasAsset.lastModifiedAt = datetime(),
                                trackHasAsset.lastModifiedBy = by
                    ',
                    {
                        batchSize: 1000
                    }
                )
                YIELD failedOperations, errorMessages, failedBatches, batch
                CALL apoc.util.validate(failedOperations > 0, "At least one sub-operation failed: %s", [reduce(all_errors = "", error IN keys(errorMessages) | all_errors + ", " + error)])
                CALL apoc.util.validate(failedBatches > 0, "At least one batch failed: %s", [reduce(all_errors = "", error IN keys(batch.errors) | all_errors + ", " + error)])
                RETURN 0
            ]]>
        </query>
        <query>
            CALL apoc.log.info("Finished acr_cloud data ingest part 29 of 169 at %s", [datetime()]);
        </query>

        <query>
            <![CDATA[
                CALL apoc.periodic.iterate(
                     "
                        WITH 'snowflake_orchard' AS url_alias,
                        '
                            SELECT * FROM facts.qa.jsonified_track_mapping ORDER BY ACR_ID ASC LIMIT 100000 OFFSET 2900000
                        '
                        AS sql
                        CALL apoc.load.jdbc(url_alias, sql)
                        YIELD row
                        return apoc.convert.fromJsonMap(row.NODE) AS row;
                    ",
                    '
                        WITH *, "database/distro-4707" AS by
                        MERGE (acrId:ACRID { id: row.acr_id })
                            ON CREATE SET
                                acrId.createdAt = datetime(),
                                acrId.createdBy = by,
                                acrId.lastModifiedAt = datetime(),
                                acrId.lastModifiedBy = by
                        MERGE (acrId)<-[acrIdToOsr:CONTAINS_FINGERPRINT]-(osr:OrchardSoundRecording)
                            ON CREATE SET
                                osr.id = apoc.create.uuid(),
                                osr.createdAt = datetime(),
                                osr.createdBy = by,
                                osr.lastModifiedAt = datetime(),
                                osr.lastModifiedBy = by,
                                acrIdToOsr.createdAt = datetime(),
                                acrIdToOsr.createdBy = by,
                                acrIdToOsr.lastModifiedAt = datetime(),
                                acrIdToOsr.lastModifiedBy = by
                        WITH *
                        UNWIND row.assets AS source_asset
                        MERGE (asset:OrchardAsset {
                            filename: source_asset.filename,
                            extension: "mp3",
                            source: "direct-delivery-db"
                        })
                            ON CREATE SET
                                asset.id = apoc.create.uuid(),
                                asset.createdAt = datetime(),
                                asset.createdBy = by,
                                asset.lastModifiedAt = datetime(),
                                asset.lastModifiedBy = by
                        MERGE (asset)-[assetToAcrId:FINGERPRINTED_AS]->(acrId)
                            ON CREATE SET
                                assetToAcrId.createdAt = datetime(),
                                assetToAcrId.createdBy = by
                            SET
                                assetToAcrId.lastModifiedAt = datetime(),
                                assetToAcrId.lastModifiedBy = by
                        WITH *
                        OPTIONAL MATCH (asset)-[assetToOldAcrId:FINGERPRINTED_AS]->(oldAcrId:ACRID)
                            WHERE oldAcrId <> acrId
                        FOREACH (hasOldAcrId IN CASE WHEN oldAcrId IS NOT NULL THEN [1] ELSE [] END |
                            CREATE (asset)-[deletedRelationship:DELETED_FINGERPRINTED_AS]->(oldAcrId)
                            SET
                                deletedRelationship += assetToOldAcrId,
                                deletedRelationship.deletedAt = datetime(),
                                deletedRelationship.deletedBy = by
                            DELETE assetToOldAcrId
                        )
                        WITH DISTINCT source_asset, by, asset
                        OPTIONAL MATCH (track:Track { id: toInteger(source_asset.tuid) })
                        CALL apoc.util.validate(track IS NULL, "Could not find the track %s", [source_asset.tuid])
                        MERGE (track)-[trackHasAsset:HAS_ASSET]->(asset)
                            ON CREATE SET
                                trackHasAsset.createdAt = datetime(),
                                trackHasAsset.createdBy = by,
                                trackHasAsset.lastModifiedAt = datetime(),
                                trackHasAsset.lastModifiedBy = by
                    ',
                    {
                        batchSize: 1000
                    }
                )
                YIELD failedOperations, errorMessages, failedBatches, batch
                CALL apoc.util.validate(failedOperations > 0, "At least one sub-operation failed: %s", [reduce(all_errors = "", error IN keys(errorMessages) | all_errors + ", " + error)])
                CALL apoc.util.validate(failedBatches > 0, "At least one batch failed: %s", [reduce(all_errors = "", error IN keys(batch.errors) | all_errors + ", " + error)])
                RETURN 0
            ]]>
        </query>
        <query>
            CALL apoc.log.info("Finished acr_cloud data ingest part 30 of 169 at %s", [datetime()]);
        </query>

        <query>
            <![CDATA[
                CALL apoc.periodic.iterate(
                     "
                        WITH 'snowflake_orchard' AS url_alias,
                        '
                            SELECT * FROM facts.qa.jsonified_track_mapping ORDER BY ACR_ID ASC LIMIT 100000 OFFSET 3000000
                        '
                        AS sql
                        CALL apoc.load.jdbc(url_alias, sql)
                        YIELD row
                        return apoc.convert.fromJsonMap(row.NODE) AS row;
                    ",
                    '
                        WITH *, "database/distro-4707" AS by
                        MERGE (acrId:ACRID { id: row.acr_id })
                            ON CREATE SET
                                acrId.createdAt = datetime(),
                                acrId.createdBy = by,
                                acrId.lastModifiedAt = datetime(),
                                acrId.lastModifiedBy = by
                        MERGE (acrId)<-[acrIdToOsr:CONTAINS_FINGERPRINT]-(osr:OrchardSoundRecording)
                            ON CREATE SET
                                osr.id = apoc.create.uuid(),
                                osr.createdAt = datetime(),
                                osr.createdBy = by,
                                osr.lastModifiedAt = datetime(),
                                osr.lastModifiedBy = by,
                                acrIdToOsr.createdAt = datetime(),
                                acrIdToOsr.createdBy = by,
                                acrIdToOsr.lastModifiedAt = datetime(),
                                acrIdToOsr.lastModifiedBy = by
                        WITH *
                        UNWIND row.assets AS source_asset
                        MERGE (asset:OrchardAsset {
                            filename: source_asset.filename,
                            extension: "mp3",
                            source: "direct-delivery-db"
                        })
                            ON CREATE SET
                                asset.id = apoc.create.uuid(),
                                asset.createdAt = datetime(),
                                asset.createdBy = by,
                                asset.lastModifiedAt = datetime(),
                                asset.lastModifiedBy = by
                        MERGE (asset)-[assetToAcrId:FINGERPRINTED_AS]->(acrId)
                            ON CREATE SET
                                assetToAcrId.createdAt = datetime(),
                                assetToAcrId.createdBy = by
                            SET
                                assetToAcrId.lastModifiedAt = datetime(),
                                assetToAcrId.lastModifiedBy = by
                        WITH *
                        OPTIONAL MATCH (asset)-[assetToOldAcrId:FINGERPRINTED_AS]->(oldAcrId:ACRID)
                            WHERE oldAcrId <> acrId
                        FOREACH (hasOldAcrId IN CASE WHEN oldAcrId IS NOT NULL THEN [1] ELSE [] END |
                            CREATE (asset)-[deletedRelationship:DELETED_FINGERPRINTED_AS]->(oldAcrId)
                            SET
                                deletedRelationship += assetToOldAcrId,
                                deletedRelationship.deletedAt = datetime(),
                                deletedRelationship.deletedBy = by
                            DELETE assetToOldAcrId
                        )
                        WITH DISTINCT source_asset, by, asset
                        OPTIONAL MATCH (track:Track { id: toInteger(source_asset.tuid) })
                        CALL apoc.util.validate(track IS NULL, "Could not find the track %s", [source_asset.tuid])
                        MERGE (track)-[trackHasAsset:HAS_ASSET]->(asset)
                            ON CREATE SET
                                trackHasAsset.createdAt = datetime(),
                                trackHasAsset.createdBy = by,
                                trackHasAsset.lastModifiedAt = datetime(),
                                trackHasAsset.lastModifiedBy = by
                    ',
                    {
                        batchSize: 1000
                    }
                )
                YIELD failedOperations, errorMessages, failedBatches, batch
                CALL apoc.util.validate(failedOperations > 0, "At least one sub-operation failed: %s", [reduce(all_errors = "", error IN keys(errorMessages) | all_errors + ", " + error)])
                CALL apoc.util.validate(failedBatches > 0, "At least one batch failed: %s", [reduce(all_errors = "", error IN keys(batch.errors) | all_errors + ", " + error)])
                RETURN 0
            ]]>
        </query>
        <query>
            CALL apoc.log.info("Finished acr_cloud data ingest part 31 of 169 at %s", [datetime()]);
        </query>

        <query>
            <![CDATA[
                CALL apoc.periodic.iterate(
                     "
                        WITH 'snowflake_orchard' AS url_alias,
                        '
                            SELECT * FROM facts.qa.jsonified_track_mapping ORDER BY ACR_ID ASC LIMIT 100000 OFFSET 3100000
                        '
                        AS sql
                        CALL apoc.load.jdbc(url_alias, sql)
                        YIELD row
                        return apoc.convert.fromJsonMap(row.NODE) AS row;
                    ",
                    '
                        WITH *, "database/distro-4707" AS by
                        MERGE (acrId:ACRID { id: row.acr_id })
                            ON CREATE SET
                                acrId.createdAt = datetime(),
                                acrId.createdBy = by,
                                acrId.lastModifiedAt = datetime(),
                                acrId.lastModifiedBy = by
                        MERGE (acrId)<-[acrIdToOsr:CONTAINS_FINGERPRINT]-(osr:OrchardSoundRecording)
                            ON CREATE SET
                                osr.id = apoc.create.uuid(),
                                osr.createdAt = datetime(),
                                osr.createdBy = by,
                                osr.lastModifiedAt = datetime(),
                                osr.lastModifiedBy = by,
                                acrIdToOsr.createdAt = datetime(),
                                acrIdToOsr.createdBy = by,
                                acrIdToOsr.lastModifiedAt = datetime(),
                                acrIdToOsr.lastModifiedBy = by
                        WITH *
                        UNWIND row.assets AS source_asset
                        MERGE (asset:OrchardAsset {
                            filename: source_asset.filename,
                            extension: "mp3",
                            source: "direct-delivery-db"
                        })
                            ON CREATE SET
                                asset.id = apoc.create.uuid(),
                                asset.createdAt = datetime(),
                                asset.createdBy = by,
                                asset.lastModifiedAt = datetime(),
                                asset.lastModifiedBy = by
                        MERGE (asset)-[assetToAcrId:FINGERPRINTED_AS]->(acrId)
                            ON CREATE SET
                                assetToAcrId.createdAt = datetime(),
                                assetToAcrId.createdBy = by
                            SET
                                assetToAcrId.lastModifiedAt = datetime(),
                                assetToAcrId.lastModifiedBy = by
                        WITH *
                        OPTIONAL MATCH (asset)-[assetToOldAcrId:FINGERPRINTED_AS]->(oldAcrId:ACRID)
                            WHERE oldAcrId <> acrId
                        FOREACH (hasOldAcrId IN CASE WHEN oldAcrId IS NOT NULL THEN [1] ELSE [] END |
                            CREATE (asset)-[deletedRelationship:DELETED_FINGERPRINTED_AS]->(oldAcrId)
                            SET
                                deletedRelationship += assetToOldAcrId,
                                deletedRelationship.deletedAt = datetime(),
                                deletedRelationship.deletedBy = by
                            DELETE assetToOldAcrId
                        )
                        WITH DISTINCT source_asset, by, asset
                        OPTIONAL MATCH (track:Track { id: toInteger(source_asset.tuid) })
                        CALL apoc.util.validate(track IS NULL, "Could not find the track %s", [source_asset.tuid])
                        MERGE (track)-[trackHasAsset:HAS_ASSET]->(asset)
                            ON CREATE SET
                                trackHasAsset.createdAt = datetime(),
                                trackHasAsset.createdBy = by,
                                trackHasAsset.lastModifiedAt = datetime(),
                                trackHasAsset.lastModifiedBy = by
                    ',
                    {
                        batchSize: 1000
                    }
                )
                YIELD failedOperations, errorMessages, failedBatches, batch
                CALL apoc.util.validate(failedOperations > 0, "At least one sub-operation failed: %s", [reduce(all_errors = "", error IN keys(errorMessages) | all_errors + ", " + error)])
                CALL apoc.util.validate(failedBatches > 0, "At least one batch failed: %s", [reduce(all_errors = "", error IN keys(batch.errors) | all_errors + ", " + error)])
                RETURN 0
            ]]>
        </query>
        <query>
            CALL apoc.log.info("Finished acr_cloud data ingest part 32 of 169 at %s", [datetime()]);
        </query>

        <query>
            <![CDATA[
                CALL apoc.periodic.iterate(
                     "
                        WITH 'snowflake_orchard' AS url_alias,
                        '
                            SELECT * FROM facts.qa.jsonified_track_mapping ORDER BY ACR_ID ASC LIMIT 100000 OFFSET 3200000
                        '
                        AS sql
                        CALL apoc.load.jdbc(url_alias, sql)
                        YIELD row
                        return apoc.convert.fromJsonMap(row.NODE) AS row;
                    ",
                    '
                        WITH *, "database/distro-4707" AS by
                        MERGE (acrId:ACRID { id: row.acr_id })
                            ON CREATE SET
                                acrId.createdAt = datetime(),
                                acrId.createdBy = by,
                                acrId.lastModifiedAt = datetime(),
                                acrId.lastModifiedBy = by
                        MERGE (acrId)<-[acrIdToOsr:CONTAINS_FINGERPRINT]-(osr:OrchardSoundRecording)
                            ON CREATE SET
                                osr.id = apoc.create.uuid(),
                                osr.createdAt = datetime(),
                                osr.createdBy = by,
                                osr.lastModifiedAt = datetime(),
                                osr.lastModifiedBy = by,
                                acrIdToOsr.createdAt = datetime(),
                                acrIdToOsr.createdBy = by,
                                acrIdToOsr.lastModifiedAt = datetime(),
                                acrIdToOsr.lastModifiedBy = by
                        WITH *
                        UNWIND row.assets AS source_asset
                        MERGE (asset:OrchardAsset {
                            filename: source_asset.filename,
                            extension: "mp3",
                            source: "direct-delivery-db"
                        })
                            ON CREATE SET
                                asset.id = apoc.create.uuid(),
                                asset.createdAt = datetime(),
                                asset.createdBy = by,
                                asset.lastModifiedAt = datetime(),
                                asset.lastModifiedBy = by
                        MERGE (asset)-[assetToAcrId:FINGERPRINTED_AS]->(acrId)
                            ON CREATE SET
                                assetToAcrId.createdAt = datetime(),
                                assetToAcrId.createdBy = by
                            SET
                                assetToAcrId.lastModifiedAt = datetime(),
                                assetToAcrId.lastModifiedBy = by
                        WITH *
                        OPTIONAL MATCH (asset)-[assetToOldAcrId:FINGERPRINTED_AS]->(oldAcrId:ACRID)
                            WHERE oldAcrId <> acrId
                        FOREACH (hasOldAcrId IN CASE WHEN oldAcrId IS NOT NULL THEN [1] ELSE [] END |
                            CREATE (asset)-[deletedRelationship:DELETED_FINGERPRINTED_AS]->(oldAcrId)
                            SET
                                deletedRelationship += assetToOldAcrId,
                                deletedRelationship.deletedAt = datetime(),
                                deletedRelationship.deletedBy = by
                            DELETE assetToOldAcrId
                        )
                        WITH DISTINCT source_asset, by, asset
                        OPTIONAL MATCH (track:Track { id: toInteger(source_asset.tuid) })
                        CALL apoc.util.validate(track IS NULL, "Could not find the track %s", [source_asset.tuid])
                        MERGE (track)-[trackHasAsset:HAS_ASSET]->(asset)
                            ON CREATE SET
                                trackHasAsset.createdAt = datetime(),
                                trackHasAsset.createdBy = by,
                                trackHasAsset.lastModifiedAt = datetime(),
                                trackHasAsset.lastModifiedBy = by
                    ',
                    {
                        batchSize: 1000
                    }
                )
                YIELD failedOperations, errorMessages, failedBatches, batch
                CALL apoc.util.validate(failedOperations > 0, "At least one sub-operation failed: %s", [reduce(all_errors = "", error IN keys(errorMessages) | all_errors + ", " + error)])
                CALL apoc.util.validate(failedBatches > 0, "At least one batch failed: %s", [reduce(all_errors = "", error IN keys(batch.errors) | all_errors + ", " + error)])
                RETURN 0
            ]]>
        </query>
        <query>
            CALL apoc.log.info("Finished acr_cloud data ingest part 33 of 169 at %s", [datetime()]);
        </query>

        <query>
            <![CDATA[
                CALL apoc.periodic.iterate(
                     "
                        WITH 'snowflake_orchard' AS url_alias,
                        '
                            SELECT * FROM facts.qa.jsonified_track_mapping ORDER BY ACR_ID ASC LIMIT 100000 OFFSET 3300000
                        '
                        AS sql
                        CALL apoc.load.jdbc(url_alias, sql)
                        YIELD row
                        return apoc.convert.fromJsonMap(row.NODE) AS row;
                    ",
                    '
                        WITH *, "database/distro-4707" AS by
                        MERGE (acrId:ACRID { id: row.acr_id })
                            ON CREATE SET
                                acrId.createdAt = datetime(),
                                acrId.createdBy = by,
                                acrId.lastModifiedAt = datetime(),
                                acrId.lastModifiedBy = by
                        MERGE (acrId)<-[acrIdToOsr:CONTAINS_FINGERPRINT]-(osr:OrchardSoundRecording)
                            ON CREATE SET
                                osr.id = apoc.create.uuid(),
                                osr.createdAt = datetime(),
                                osr.createdBy = by,
                                osr.lastModifiedAt = datetime(),
                                osr.lastModifiedBy = by,
                                acrIdToOsr.createdAt = datetime(),
                                acrIdToOsr.createdBy = by,
                                acrIdToOsr.lastModifiedAt = datetime(),
                                acrIdToOsr.lastModifiedBy = by
                        WITH *
                        UNWIND row.assets AS source_asset
                        MERGE (asset:OrchardAsset {
                            filename: source_asset.filename,
                            extension: "mp3",
                            source: "direct-delivery-db"
                        })
                            ON CREATE SET
                                asset.id = apoc.create.uuid(),
                                asset.createdAt = datetime(),
                                asset.createdBy = by,
                                asset.lastModifiedAt = datetime(),
                                asset.lastModifiedBy = by
                        MERGE (asset)-[assetToAcrId:FINGERPRINTED_AS]->(acrId)
                            ON CREATE SET
                                assetToAcrId.createdAt = datetime(),
                                assetToAcrId.createdBy = by
                            SET
                                assetToAcrId.lastModifiedAt = datetime(),
                                assetToAcrId.lastModifiedBy = by
                        WITH *
                        OPTIONAL MATCH (asset)-[assetToOldAcrId:FINGERPRINTED_AS]->(oldAcrId:ACRID)
                            WHERE oldAcrId <> acrId
                        FOREACH (hasOldAcrId IN CASE WHEN oldAcrId IS NOT NULL THEN [1] ELSE [] END |
                            CREATE (asset)-[deletedRelationship:DELETED_FINGERPRINTED_AS]->(oldAcrId)
                            SET
                                deletedRelationship += assetToOldAcrId,
                                deletedRelationship.deletedAt = datetime(),
                                deletedRelationship.deletedBy = by
                            DELETE assetToOldAcrId
                        )
                        WITH DISTINCT source_asset, by, asset
                        OPTIONAL MATCH (track:Track { id: toInteger(source_asset.tuid) })
                        CALL apoc.util.validate(track IS NULL, "Could not find the track %s", [source_asset.tuid])
                        MERGE (track)-[trackHasAsset:HAS_ASSET]->(asset)
                            ON CREATE SET
                                trackHasAsset.createdAt = datetime(),
                                trackHasAsset.createdBy = by,
                                trackHasAsset.lastModifiedAt = datetime(),
                                trackHasAsset.lastModifiedBy = by
                    ',
                    {
                        batchSize: 1000
                    }
                )
                YIELD failedOperations, errorMessages, failedBatches, batch
                CALL apoc.util.validate(failedOperations > 0, "At least one sub-operation failed: %s", [reduce(all_errors = "", error IN keys(errorMessages) | all_errors + ", " + error)])
                CALL apoc.util.validate(failedBatches > 0, "At least one batch failed: %s", [reduce(all_errors = "", error IN keys(batch.errors) | all_errors + ", " + error)])
                RETURN 0
            ]]>
        </query>
        <query>
            CALL apoc.log.info("Finished acr_cloud data ingest part 34 of 169 at %s", [datetime()]);
        </query>

        <query>
            <![CDATA[
                CALL apoc.periodic.iterate(
                     "
                        WITH 'snowflake_orchard' AS url_alias,
                        '
                            SELECT * FROM facts.qa.jsonified_track_mapping ORDER BY ACR_ID ASC LIMIT 100000 OFFSET 3400000
                        '
                        AS sql
                        CALL apoc.load.jdbc(url_alias, sql)
                        YIELD row
                        return apoc.convert.fromJsonMap(row.NODE) AS row;
                    ",
                    '
                        WITH *, "database/distro-4707" AS by
                        MERGE (acrId:ACRID { id: row.acr_id })
                            ON CREATE SET
                                acrId.createdAt = datetime(),
                                acrId.createdBy = by,
                                acrId.lastModifiedAt = datetime(),
                                acrId.lastModifiedBy = by
                        MERGE (acrId)<-[acrIdToOsr:CONTAINS_FINGERPRINT]-(osr:OrchardSoundRecording)
                            ON CREATE SET
                                osr.id = apoc.create.uuid(),
                                osr.createdAt = datetime(),
                                osr.createdBy = by,
                                osr.lastModifiedAt = datetime(),
                                osr.lastModifiedBy = by,
                                acrIdToOsr.createdAt = datetime(),
                                acrIdToOsr.createdBy = by,
                                acrIdToOsr.lastModifiedAt = datetime(),
                                acrIdToOsr.lastModifiedBy = by
                        WITH *
                        UNWIND row.assets AS source_asset
                        MERGE (asset:OrchardAsset {
                            filename: source_asset.filename,
                            extension: "mp3",
                            source: "direct-delivery-db"
                        })
                            ON CREATE SET
                                asset.id = apoc.create.uuid(),
                                asset.createdAt = datetime(),
                                asset.createdBy = by,
                                asset.lastModifiedAt = datetime(),
                                asset.lastModifiedBy = by
                        MERGE (asset)-[assetToAcrId:FINGERPRINTED_AS]->(acrId)
                            ON CREATE SET
                                assetToAcrId.createdAt = datetime(),
                                assetToAcrId.createdBy = by
                            SET
                                assetToAcrId.lastModifiedAt = datetime(),
                                assetToAcrId.lastModifiedBy = by
                        WITH *
                        OPTIONAL MATCH (asset)-[assetToOldAcrId:FINGERPRINTED_AS]->(oldAcrId:ACRID)
                            WHERE oldAcrId <> acrId
                        FOREACH (hasOldAcrId IN CASE WHEN oldAcrId IS NOT NULL THEN [1] ELSE [] END |
                            CREATE (asset)-[deletedRelationship:DELETED_FINGERPRINTED_AS]->(oldAcrId)
                            SET
                                deletedRelationship += assetToOldAcrId,
                                deletedRelationship.deletedAt = datetime(),
                                deletedRelationship.deletedBy = by
                            DELETE assetToOldAcrId
                        )
                        WITH DISTINCT source_asset, by, asset
                        OPTIONAL MATCH (track:Track { id: toInteger(source_asset.tuid) })
                        CALL apoc.util.validate(track IS NULL, "Could not find the track %s", [source_asset.tuid])
                        MERGE (track)-[trackHasAsset:HAS_ASSET]->(asset)
                            ON CREATE SET
                                trackHasAsset.createdAt = datetime(),
                                trackHasAsset.createdBy = by,
                                trackHasAsset.lastModifiedAt = datetime(),
                                trackHasAsset.lastModifiedBy = by
                    ',
                    {
                        batchSize: 1000
                    }
                )
                YIELD failedOperations, errorMessages, failedBatches, batch
                CALL apoc.util.validate(failedOperations > 0, "At least one sub-operation failed: %s", [reduce(all_errors = "", error IN keys(errorMessages) | all_errors + ", " + error)])
                CALL apoc.util.validate(failedBatches > 0, "At least one batch failed: %s", [reduce(all_errors = "", error IN keys(batch.errors) | all_errors + ", " + error)])
                RETURN 0
            ]]>
        </query>
        <query>
            CALL apoc.log.info("Finished acr_cloud data ingest part 35 of 169 at %s", [datetime()]);
        </query>

        <query>
            <![CDATA[
                CALL apoc.periodic.iterate(
                     "
                        WITH 'snowflake_orchard' AS url_alias,
                        '
                            SELECT * FROM facts.qa.jsonified_track_mapping ORDER BY ACR_ID ASC LIMIT 100000 OFFSET 3500000
                        '
                        AS sql
                        CALL apoc.load.jdbc(url_alias, sql)
                        YIELD row
                        return apoc.convert.fromJsonMap(row.NODE) AS row;
                    ",
                    '
                        WITH *, "database/distro-4707" AS by
                        MERGE (acrId:ACRID { id: row.acr_id })
                            ON CREATE SET
                                acrId.createdAt = datetime(),
                                acrId.createdBy = by,
                                acrId.lastModifiedAt = datetime(),
                                acrId.lastModifiedBy = by
                        MERGE (acrId)<-[acrIdToOsr:CONTAINS_FINGERPRINT]-(osr:OrchardSoundRecording)
                            ON CREATE SET
                                osr.id = apoc.create.uuid(),
                                osr.createdAt = datetime(),
                                osr.createdBy = by,
                                osr.lastModifiedAt = datetime(),
                                osr.lastModifiedBy = by,
                                acrIdToOsr.createdAt = datetime(),
                                acrIdToOsr.createdBy = by,
                                acrIdToOsr.lastModifiedAt = datetime(),
                                acrIdToOsr.lastModifiedBy = by
                        WITH *
                        UNWIND row.assets AS source_asset
                        MERGE (asset:OrchardAsset {
                            filename: source_asset.filename,
                            extension: "mp3",
                            source: "direct-delivery-db"
                        })
                            ON CREATE SET
                                asset.id = apoc.create.uuid(),
                                asset.createdAt = datetime(),
                                asset.createdBy = by,
                                asset.lastModifiedAt = datetime(),
                                asset.lastModifiedBy = by
                        MERGE (asset)-[assetToAcrId:FINGERPRINTED_AS]->(acrId)
                            ON CREATE SET
                                assetToAcrId.createdAt = datetime(),
                                assetToAcrId.createdBy = by
                            SET
                                assetToAcrId.lastModifiedAt = datetime(),
                                assetToAcrId.lastModifiedBy = by
                        WITH *
                        OPTIONAL MATCH (asset)-[assetToOldAcrId:FINGERPRINTED_AS]->(oldAcrId:ACRID)
                            WHERE oldAcrId <> acrId
                        FOREACH (hasOldAcrId IN CASE WHEN oldAcrId IS NOT NULL THEN [1] ELSE [] END |
                            CREATE (asset)-[deletedRelationship:DELETED_FINGERPRINTED_AS]->(oldAcrId)
                            SET
                                deletedRelationship += assetToOldAcrId,
                                deletedRelationship.deletedAt = datetime(),
                                deletedRelationship.deletedBy = by
                            DELETE assetToOldAcrId
                        )
                        WITH DISTINCT source_asset, by, asset
                        OPTIONAL MATCH (track:Track { id: toInteger(source_asset.tuid) })
                        CALL apoc.util.validate(track IS NULL, "Could not find the track %s", [source_asset.tuid])
                        MERGE (track)-[trackHasAsset:HAS_ASSET]->(asset)
                            ON CREATE SET
                                trackHasAsset.createdAt = datetime(),
                                trackHasAsset.createdBy = by,
                                trackHasAsset.lastModifiedAt = datetime(),
                                trackHasAsset.lastModifiedBy = by
                    ',
                    {
                        batchSize: 1000
                    }
                )
                YIELD failedOperations, errorMessages, failedBatches, batch
                CALL apoc.util.validate(failedOperations > 0, "At least one sub-operation failed: %s", [reduce(all_errors = "", error IN keys(errorMessages) | all_errors + ", " + error)])
                CALL apoc.util.validate(failedBatches > 0, "At least one batch failed: %s", [reduce(all_errors = "", error IN keys(batch.errors) | all_errors + ", " + error)])
                RETURN 0
            ]]>
        </query>
        <query>
            CALL apoc.log.info("Finished acr_cloud data ingest part 36 of 169 at %s", [datetime()]);
        </query>

        <query>
            <![CDATA[
                CALL apoc.periodic.iterate(
                     "
                        WITH 'snowflake_orchard' AS url_alias,
                        '
                            SELECT * FROM facts.qa.jsonified_track_mapping ORDER BY ACR_ID ASC LIMIT 100000 OFFSET 3600000
                        '
                        AS sql
                        CALL apoc.load.jdbc(url_alias, sql)
                        YIELD row
                        return apoc.convert.fromJsonMap(row.NODE) AS row;
                    ",
                    '
                        WITH *, "database/distro-4707" AS by
                        MERGE (acrId:ACRID { id: row.acr_id })
                            ON CREATE SET
                                acrId.createdAt = datetime(),
                                acrId.createdBy = by,
                                acrId.lastModifiedAt = datetime(),
                                acrId.lastModifiedBy = by
                        MERGE (acrId)<-[acrIdToOsr:CONTAINS_FINGERPRINT]-(osr:OrchardSoundRecording)
                            ON CREATE SET
                                osr.id = apoc.create.uuid(),
                                osr.createdAt = datetime(),
                                osr.createdBy = by,
                                osr.lastModifiedAt = datetime(),
                                osr.lastModifiedBy = by,
                                acrIdToOsr.createdAt = datetime(),
                                acrIdToOsr.createdBy = by,
                                acrIdToOsr.lastModifiedAt = datetime(),
                                acrIdToOsr.lastModifiedBy = by
                        WITH *
                        UNWIND row.assets AS source_asset
                        MERGE (asset:OrchardAsset {
                            filename: source_asset.filename,
                            extension: "mp3",
                            source: "direct-delivery-db"
                        })
                            ON CREATE SET
                                asset.id = apoc.create.uuid(),
                                asset.createdAt = datetime(),
                                asset.createdBy = by,
                                asset.lastModifiedAt = datetime(),
                                asset.lastModifiedBy = by
                        MERGE (asset)-[assetToAcrId:FINGERPRINTED_AS]->(acrId)
                            ON CREATE SET
                                assetToAcrId.createdAt = datetime(),
                                assetToAcrId.createdBy = by
                            SET
                                assetToAcrId.lastModifiedAt = datetime(),
                                assetToAcrId.lastModifiedBy = by
                        WITH *
                        OPTIONAL MATCH (asset)-[assetToOldAcrId:FINGERPRINTED_AS]->(oldAcrId:ACRID)
                            WHERE oldAcrId <> acrId
                        FOREACH (hasOldAcrId IN CASE WHEN oldAcrId IS NOT NULL THEN [1] ELSE [] END |
                            CREATE (asset)-[deletedRelationship:DELETED_FINGERPRINTED_AS]->(oldAcrId)
                            SET
                                deletedRelationship += assetToOldAcrId,
                                deletedRelationship.deletedAt = datetime(),
                                deletedRelationship.deletedBy = by
                            DELETE assetToOldAcrId
                        )
                        WITH DISTINCT source_asset, by, asset
                        OPTIONAL MATCH (track:Track { id: toInteger(source_asset.tuid) })
                        CALL apoc.util.validate(track IS NULL, "Could not find the track %s", [source_asset.tuid])
                        MERGE (track)-[trackHasAsset:HAS_ASSET]->(asset)
                            ON CREATE SET
                                trackHasAsset.createdAt = datetime(),
                                trackHasAsset.createdBy = by,
                                trackHasAsset.lastModifiedAt = datetime(),
                                trackHasAsset.lastModifiedBy = by
                    ',
                    {
                        batchSize: 1000
                    }
                )
                YIELD failedOperations, errorMessages, failedBatches, batch
                CALL apoc.util.validate(failedOperations > 0, "At least one sub-operation failed: %s", [reduce(all_errors = "", error IN keys(errorMessages) | all_errors + ", " + error)])
                CALL apoc.util.validate(failedBatches > 0, "At least one batch failed: %s", [reduce(all_errors = "", error IN keys(batch.errors) | all_errors + ", " + error)])
                RETURN 0
            ]]>
        </query>
        <query>
            CALL apoc.log.info("Finished acr_cloud data ingest part 37 of 169 at %s", [datetime()]);
        </query>

        <query>
            <![CDATA[
                CALL apoc.periodic.iterate(
                     "
                        WITH 'snowflake_orchard' AS url_alias,
                        '
                            SELECT * FROM facts.qa.jsonified_track_mapping ORDER BY ACR_ID ASC LIMIT 100000 OFFSET 3700000
                        '
                        AS sql
                        CALL apoc.load.jdbc(url_alias, sql)
                        YIELD row
                        return apoc.convert.fromJsonMap(row.NODE) AS row;
                    ",
                    '
                        WITH *, "database/distro-4707" AS by
                        MERGE (acrId:ACRID { id: row.acr_id })
                            ON CREATE SET
                                acrId.createdAt = datetime(),
                                acrId.createdBy = by,
                                acrId.lastModifiedAt = datetime(),
                                acrId.lastModifiedBy = by
                        MERGE (acrId)<-[acrIdToOsr:CONTAINS_FINGERPRINT]-(osr:OrchardSoundRecording)
                            ON CREATE SET
                                osr.id = apoc.create.uuid(),
                                osr.createdAt = datetime(),
                                osr.createdBy = by,
                                osr.lastModifiedAt = datetime(),
                                osr.lastModifiedBy = by,
                                acrIdToOsr.createdAt = datetime(),
                                acrIdToOsr.createdBy = by,
                                acrIdToOsr.lastModifiedAt = datetime(),
                                acrIdToOsr.lastModifiedBy = by
                        WITH *
                        UNWIND row.assets AS source_asset
                        MERGE (asset:OrchardAsset {
                            filename: source_asset.filename,
                            extension: "mp3",
                            source: "direct-delivery-db"
                        })
                            ON CREATE SET
                                asset.id = apoc.create.uuid(),
                                asset.createdAt = datetime(),
                                asset.createdBy = by,
                                asset.lastModifiedAt = datetime(),
                                asset.lastModifiedBy = by
                        MERGE (asset)-[assetToAcrId:FINGERPRINTED_AS]->(acrId)
                            ON CREATE SET
                                assetToAcrId.createdAt = datetime(),
                                assetToAcrId.createdBy = by
                            SET
                                assetToAcrId.lastModifiedAt = datetime(),
                                assetToAcrId.lastModifiedBy = by
                        WITH *
                        OPTIONAL MATCH (asset)-[assetToOldAcrId:FINGERPRINTED_AS]->(oldAcrId:ACRID)
                            WHERE oldAcrId <> acrId
                        FOREACH (hasOldAcrId IN CASE WHEN oldAcrId IS NOT NULL THEN [1] ELSE [] END |
                            CREATE (asset)-[deletedRelationship:DELETED_FINGERPRINTED_AS]->(oldAcrId)
                            SET
                                deletedRelationship += assetToOldAcrId,
                                deletedRelationship.deletedAt = datetime(),
                                deletedRelationship.deletedBy = by
                            DELETE assetToOldAcrId
                        )
                        WITH DISTINCT source_asset, by, asset
                        OPTIONAL MATCH (track:Track { id: toInteger(source_asset.tuid) })
                        CALL apoc.util.validate(track IS NULL, "Could not find the track %s", [source_asset.tuid])
                        MERGE (track)-[trackHasAsset:HAS_ASSET]->(asset)
                            ON CREATE SET
                                trackHasAsset.createdAt = datetime(),
                                trackHasAsset.createdBy = by,
                                trackHasAsset.lastModifiedAt = datetime(),
                                trackHasAsset.lastModifiedBy = by
                    ',
                    {
                        batchSize: 1000
                    }
                )
                YIELD failedOperations, errorMessages, failedBatches, batch
                CALL apoc.util.validate(failedOperations > 0, "At least one sub-operation failed: %s", [reduce(all_errors = "", error IN keys(errorMessages) | all_errors + ", " + error)])
                CALL apoc.util.validate(failedBatches > 0, "At least one batch failed: %s", [reduce(all_errors = "", error IN keys(batch.errors) | all_errors + ", " + error)])
                RETURN 0
            ]]>
        </query>
        <query>
            CALL apoc.log.info("Finished acr_cloud data ingest part 38 of 169 at %s", [datetime()]);
        </query>

        <query>
            <![CDATA[
                CALL apoc.periodic.iterate(
                     "
                        WITH 'snowflake_orchard' AS url_alias,
                        '
                            SELECT * FROM facts.qa.jsonified_track_mapping ORDER BY ACR_ID ASC LIMIT 100000 OFFSET 3800000
                        '
                        AS sql
                        CALL apoc.load.jdbc(url_alias, sql)
                        YIELD row
                        return apoc.convert.fromJsonMap(row.NODE) AS row;
                    ",
                    '
                        WITH *, "database/distro-4707" AS by
                        MERGE (acrId:ACRID { id: row.acr_id })
                            ON CREATE SET
                                acrId.createdAt = datetime(),
                                acrId.createdBy = by,
                                acrId.lastModifiedAt = datetime(),
                                acrId.lastModifiedBy = by
                        MERGE (acrId)<-[acrIdToOsr:CONTAINS_FINGERPRINT]-(osr:OrchardSoundRecording)
                            ON CREATE SET
                                osr.id = apoc.create.uuid(),
                                osr.createdAt = datetime(),
                                osr.createdBy = by,
                                osr.lastModifiedAt = datetime(),
                                osr.lastModifiedBy = by,
                                acrIdToOsr.createdAt = datetime(),
                                acrIdToOsr.createdBy = by,
                                acrIdToOsr.lastModifiedAt = datetime(),
                                acrIdToOsr.lastModifiedBy = by
                        WITH *
                        UNWIND row.assets AS source_asset
                        MERGE (asset:OrchardAsset {
                            filename: source_asset.filename,
                            extension: "mp3",
                            source: "direct-delivery-db"
                        })
                            ON CREATE SET
                                asset.id = apoc.create.uuid(),
                                asset.createdAt = datetime(),
                                asset.createdBy = by,
                                asset.lastModifiedAt = datetime(),
                                asset.lastModifiedBy = by
                        MERGE (asset)-[assetToAcrId:FINGERPRINTED_AS]->(acrId)
                            ON CREATE SET
                                assetToAcrId.createdAt = datetime(),
                                assetToAcrId.createdBy = by
                            SET
                                assetToAcrId.lastModifiedAt = datetime(),
                                assetToAcrId.lastModifiedBy = by
                        WITH *
                        OPTIONAL MATCH (asset)-[assetToOldAcrId:FINGERPRINTED_AS]->(oldAcrId:ACRID)
                            WHERE oldAcrId <> acrId
                        FOREACH (hasOldAcrId IN CASE WHEN oldAcrId IS NOT NULL THEN [1] ELSE [] END |
                            CREATE (asset)-[deletedRelationship:DELETED_FINGERPRINTED_AS]->(oldAcrId)
                            SET
                                deletedRelationship += assetToOldAcrId,
                                deletedRelationship.deletedAt = datetime(),
                                deletedRelationship.deletedBy = by
                            DELETE assetToOldAcrId
                        )
                        WITH DISTINCT source_asset, by, asset
                        OPTIONAL MATCH (track:Track { id: toInteger(source_asset.tuid) })
                        CALL apoc.util.validate(track IS NULL, "Could not find the track %s", [source_asset.tuid])
                        MERGE (track)-[trackHasAsset:HAS_ASSET]->(asset)
                            ON CREATE SET
                                trackHasAsset.createdAt = datetime(),
                                trackHasAsset.createdBy = by,
                                trackHasAsset.lastModifiedAt = datetime(),
                                trackHasAsset.lastModifiedBy = by
                    ',
                    {
                        batchSize: 1000
                    }
                )
                YIELD failedOperations, errorMessages, failedBatches, batch
                CALL apoc.util.validate(failedOperations > 0, "At least one sub-operation failed: %s", [reduce(all_errors = "", error IN keys(errorMessages) | all_errors + ", " + error)])
                CALL apoc.util.validate(failedBatches > 0, "At least one batch failed: %s", [reduce(all_errors = "", error IN keys(batch.errors) | all_errors + ", " + error)])
                RETURN 0
            ]]>
        </query>
        <query>
            CALL apoc.log.info("Finished acr_cloud data ingest part 39 of 169 at %s", [datetime()]);
        </query>

        <query>
            <![CDATA[
                CALL apoc.periodic.iterate(
                     "
                        WITH 'snowflake_orchard' AS url_alias,
                        '
                            SELECT * FROM facts.qa.jsonified_track_mapping ORDER BY ACR_ID ASC LIMIT 100000 OFFSET 3900000
                        '
                        AS sql
                        CALL apoc.load.jdbc(url_alias, sql)
                        YIELD row
                        return apoc.convert.fromJsonMap(row.NODE) AS row;
                    ",
                    '
                        WITH *, "database/distro-4707" AS by
                        MERGE (acrId:ACRID { id: row.acr_id })
                            ON CREATE SET
                                acrId.createdAt = datetime(),
                                acrId.createdBy = by,
                                acrId.lastModifiedAt = datetime(),
                                acrId.lastModifiedBy = by
                        MERGE (acrId)<-[acrIdToOsr:CONTAINS_FINGERPRINT]-(osr:OrchardSoundRecording)
                            ON CREATE SET
                                osr.id = apoc.create.uuid(),
                                osr.createdAt = datetime(),
                                osr.createdBy = by,
                                osr.lastModifiedAt = datetime(),
                                osr.lastModifiedBy = by,
                                acrIdToOsr.createdAt = datetime(),
                                acrIdToOsr.createdBy = by,
                                acrIdToOsr.lastModifiedAt = datetime(),
                                acrIdToOsr.lastModifiedBy = by
                        WITH *
                        UNWIND row.assets AS source_asset
                        MERGE (asset:OrchardAsset {
                            filename: source_asset.filename,
                            extension: "mp3",
                            source: "direct-delivery-db"
                        })
                            ON CREATE SET
                                asset.id = apoc.create.uuid(),
                                asset.createdAt = datetime(),
                                asset.createdBy = by,
                                asset.lastModifiedAt = datetime(),
                                asset.lastModifiedBy = by
                        MERGE (asset)-[assetToAcrId:FINGERPRINTED_AS]->(acrId)
                            ON CREATE SET
                                assetToAcrId.createdAt = datetime(),
                                assetToAcrId.createdBy = by
                            SET
                                assetToAcrId.lastModifiedAt = datetime(),
                                assetToAcrId.lastModifiedBy = by
                        WITH *
                        OPTIONAL MATCH (asset)-[assetToOldAcrId:FINGERPRINTED_AS]->(oldAcrId:ACRID)
                            WHERE oldAcrId <> acrId
                        FOREACH (hasOldAcrId IN CASE WHEN oldAcrId IS NOT NULL THEN [1] ELSE [] END |
                            CREATE (asset)-[deletedRelationship:DELETED_FINGERPRINTED_AS]->(oldAcrId)
                            SET
                                deletedRelationship += assetToOldAcrId,
                                deletedRelationship.deletedAt = datetime(),
                                deletedRelationship.deletedBy = by
                            DELETE assetToOldAcrId
                        )
                        WITH DISTINCT source_asset, by, asset
                        OPTIONAL MATCH (track:Track { id: toInteger(source_asset.tuid) })
                        CALL apoc.util.validate(track IS NULL, "Could not find the track %s", [source_asset.tuid])
                        MERGE (track)-[trackHasAsset:HAS_ASSET]->(asset)
                            ON CREATE SET
                                trackHasAsset.createdAt = datetime(),
                                trackHasAsset.createdBy = by,
                                trackHasAsset.lastModifiedAt = datetime(),
                                trackHasAsset.lastModifiedBy = by
                    ',
                    {
                        batchSize: 1000
                    }
                )
                YIELD failedOperations, errorMessages, failedBatches, batch
                CALL apoc.util.validate(failedOperations > 0, "At least one sub-operation failed: %s", [reduce(all_errors = "", error IN keys(errorMessages) | all_errors + ", " + error)])
                CALL apoc.util.validate(failedBatches > 0, "At least one batch failed: %s", [reduce(all_errors = "", error IN keys(batch.errors) | all_errors + ", " + error)])
                RETURN 0
            ]]>
        </query>
        <query>
            CALL apoc.log.info("Finished acr_cloud data ingest part 40 of 169 at %s", [datetime()]);
        </query>

        <query>
            <![CDATA[
                CALL apoc.periodic.iterate(
                     "
                        WITH 'snowflake_orchard' AS url_alias,
                        '
                            SELECT * FROM facts.qa.jsonified_track_mapping ORDER BY ACR_ID ASC LIMIT 100000 OFFSET 4000000
                        '
                        AS sql
                        CALL apoc.load.jdbc(url_alias, sql)
                        YIELD row
                        return apoc.convert.fromJsonMap(row.NODE) AS row;
                    ",
                    '
                        WITH *, "database/distro-4707" AS by
                        MERGE (acrId:ACRID { id: row.acr_id })
                            ON CREATE SET
                                acrId.createdAt = datetime(),
                                acrId.createdBy = by,
                                acrId.lastModifiedAt = datetime(),
                                acrId.lastModifiedBy = by
                        MERGE (acrId)<-[acrIdToOsr:CONTAINS_FINGERPRINT]-(osr:OrchardSoundRecording)
                            ON CREATE SET
                                osr.id = apoc.create.uuid(),
                                osr.createdAt = datetime(),
                                osr.createdBy = by,
                                osr.lastModifiedAt = datetime(),
                                osr.lastModifiedBy = by,
                                acrIdToOsr.createdAt = datetime(),
                                acrIdToOsr.createdBy = by,
                                acrIdToOsr.lastModifiedAt = datetime(),
                                acrIdToOsr.lastModifiedBy = by
                        WITH *
                        UNWIND row.assets AS source_asset
                        MERGE (asset:OrchardAsset {
                            filename: source_asset.filename,
                            extension: "mp3",
                            source: "direct-delivery-db"
                        })
                            ON CREATE SET
                                asset.id = apoc.create.uuid(),
                                asset.createdAt = datetime(),
                                asset.createdBy = by,
                                asset.lastModifiedAt = datetime(),
                                asset.lastModifiedBy = by
                        MERGE (asset)-[assetToAcrId:FINGERPRINTED_AS]->(acrId)
                            ON CREATE SET
                                assetToAcrId.createdAt = datetime(),
                                assetToAcrId.createdBy = by
                            SET
                                assetToAcrId.lastModifiedAt = datetime(),
                                assetToAcrId.lastModifiedBy = by
                        WITH *
                        OPTIONAL MATCH (asset)-[assetToOldAcrId:FINGERPRINTED_AS]->(oldAcrId:ACRID)
                            WHERE oldAcrId <> acrId
                        FOREACH (hasOldAcrId IN CASE WHEN oldAcrId IS NOT NULL THEN [1] ELSE [] END |
                            CREATE (asset)-[deletedRelationship:DELETED_FINGERPRINTED_AS]->(oldAcrId)
                            SET
                                deletedRelationship += assetToOldAcrId,
                                deletedRelationship.deletedAt = datetime(),
                                deletedRelationship.deletedBy = by
                            DELETE assetToOldAcrId
                        )
                        WITH DISTINCT source_asset, by, asset
                        OPTIONAL MATCH (track:Track { id: toInteger(source_asset.tuid) })
                        CALL apoc.util.validate(track IS NULL, "Could not find the track %s", [source_asset.tuid])
                        MERGE (track)-[trackHasAsset:HAS_ASSET]->(asset)
                            ON CREATE SET
                                trackHasAsset.createdAt = datetime(),
                                trackHasAsset.createdBy = by,
                                trackHasAsset.lastModifiedAt = datetime(),
                                trackHasAsset.lastModifiedBy = by
                    ',
                    {
                        batchSize: 1000
                    }
                )
                YIELD failedOperations, errorMessages, failedBatches, batch
                CALL apoc.util.validate(failedOperations > 0, "At least one sub-operation failed: %s", [reduce(all_errors = "", error IN keys(errorMessages) | all_errors + ", " + error)])
                CALL apoc.util.validate(failedBatches > 0, "At least one batch failed: %s", [reduce(all_errors = "", error IN keys(batch.errors) | all_errors + ", " + error)])
                RETURN 0
            ]]>
        </query>
        <query>
            CALL apoc.log.info("Finished acr_cloud data ingest part 41 of 169 at %s", [datetime()]);
        </query>

        <query>
            <![CDATA[
                CALL apoc.periodic.iterate(
                     "
                        WITH 'snowflake_orchard' AS url_alias,
                        '
                            SELECT * FROM facts.qa.jsonified_track_mapping ORDER BY ACR_ID ASC LIMIT 100000 OFFSET 4100000
                        '
                        AS sql
                        CALL apoc.load.jdbc(url_alias, sql)
                        YIELD row
                        return apoc.convert.fromJsonMap(row.NODE) AS row;
                    ",
                    '
                        WITH *, "database/distro-4707" AS by
                        MERGE (acrId:ACRID { id: row.acr_id })
                            ON CREATE SET
                                acrId.createdAt = datetime(),
                                acrId.createdBy = by,
                                acrId.lastModifiedAt = datetime(),
                                acrId.lastModifiedBy = by
                        MERGE (acrId)<-[acrIdToOsr:CONTAINS_FINGERPRINT]-(osr:OrchardSoundRecording)
                            ON CREATE SET
                                osr.id = apoc.create.uuid(),
                                osr.createdAt = datetime(),
                                osr.createdBy = by,
                                osr.lastModifiedAt = datetime(),
                                osr.lastModifiedBy = by,
                                acrIdToOsr.createdAt = datetime(),
                                acrIdToOsr.createdBy = by,
                                acrIdToOsr.lastModifiedAt = datetime(),
                                acrIdToOsr.lastModifiedBy = by
                        WITH *
                        UNWIND row.assets AS source_asset
                        MERGE (asset:OrchardAsset {
                            filename: source_asset.filename,
                            extension: "mp3",
                            source: "direct-delivery-db"
                        })
                            ON CREATE SET
                                asset.id = apoc.create.uuid(),
                                asset.createdAt = datetime(),
                                asset.createdBy = by,
                                asset.lastModifiedAt = datetime(),
                                asset.lastModifiedBy = by
                        MERGE (asset)-[assetToAcrId:FINGERPRINTED_AS]->(acrId)
                            ON CREATE SET
                                assetToAcrId.createdAt = datetime(),
                                assetToAcrId.createdBy = by
                            SET
                                assetToAcrId.lastModifiedAt = datetime(),
                                assetToAcrId.lastModifiedBy = by
                        WITH *
                        OPTIONAL MATCH (asset)-[assetToOldAcrId:FINGERPRINTED_AS]->(oldAcrId:ACRID)
                            WHERE oldAcrId <> acrId
                        FOREACH (hasOldAcrId IN CASE WHEN oldAcrId IS NOT NULL THEN [1] ELSE [] END |
                            CREATE (asset)-[deletedRelationship:DELETED_FINGERPRINTED_AS]->(oldAcrId)
                            SET
                                deletedRelationship += assetToOldAcrId,
                                deletedRelationship.deletedAt = datetime(),
                                deletedRelationship.deletedBy = by
                            DELETE assetToOldAcrId
                        )
                        WITH DISTINCT source_asset, by, asset
                        OPTIONAL MATCH (track:Track { id: toInteger(source_asset.tuid) })
                        CALL apoc.util.validate(track IS NULL, "Could not find the track %s", [source_asset.tuid])
                        MERGE (track)-[trackHasAsset:HAS_ASSET]->(asset)
                            ON CREATE SET
                                trackHasAsset.createdAt = datetime(),
                                trackHasAsset.createdBy = by,
                                trackHasAsset.lastModifiedAt = datetime(),
                                trackHasAsset.lastModifiedBy = by
                    ',
                    {
                        batchSize: 1000
                    }
                )
                YIELD failedOperations, errorMessages, failedBatches, batch
                CALL apoc.util.validate(failedOperations > 0, "At least one sub-operation failed: %s", [reduce(all_errors = "", error IN keys(errorMessages) | all_errors + ", " + error)])
                CALL apoc.util.validate(failedBatches > 0, "At least one batch failed: %s", [reduce(all_errors = "", error IN keys(batch.errors) | all_errors + ", " + error)])
                RETURN 0
            ]]>
        </query>
        <query>
            CALL apoc.log.info("Finished acr_cloud data ingest part 42 of 169 at %s", [datetime()]);
        </query>

        <query>
            <![CDATA[
                CALL apoc.periodic.iterate(
                     "
                        WITH 'snowflake_orchard' AS url_alias,
                        '
                            SELECT * FROM facts.qa.jsonified_track_mapping ORDER BY ACR_ID ASC LIMIT 100000 OFFSET 4200000
                        '
                        AS sql
                        CALL apoc.load.jdbc(url_alias, sql)
                        YIELD row
                        return apoc.convert.fromJsonMap(row.NODE) AS row;
                    ",
                    '
                        WITH *, "database/distro-4707" AS by
                        MERGE (acrId:ACRID { id: row.acr_id })
                            ON CREATE SET
                                acrId.createdAt = datetime(),
                                acrId.createdBy = by,
                                acrId.lastModifiedAt = datetime(),
                                acrId.lastModifiedBy = by
                        MERGE (acrId)<-[acrIdToOsr:CONTAINS_FINGERPRINT]-(osr:OrchardSoundRecording)
                            ON CREATE SET
                                osr.id = apoc.create.uuid(),
                                osr.createdAt = datetime(),
                                osr.createdBy = by,
                                osr.lastModifiedAt = datetime(),
                                osr.lastModifiedBy = by,
                                acrIdToOsr.createdAt = datetime(),
                                acrIdToOsr.createdBy = by,
                                acrIdToOsr.lastModifiedAt = datetime(),
                                acrIdToOsr.lastModifiedBy = by
                        WITH *
                        UNWIND row.assets AS source_asset
                        MERGE (asset:OrchardAsset {
                            filename: source_asset.filename,
                            extension: "mp3",
                            source: "direct-delivery-db"
                        })
                            ON CREATE SET
                                asset.id = apoc.create.uuid(),
                                asset.createdAt = datetime(),
                                asset.createdBy = by,
                                asset.lastModifiedAt = datetime(),
                                asset.lastModifiedBy = by
                        MERGE (asset)-[assetToAcrId:FINGERPRINTED_AS]->(acrId)
                            ON CREATE SET
                                assetToAcrId.createdAt = datetime(),
                                assetToAcrId.createdBy = by
                            SET
                                assetToAcrId.lastModifiedAt = datetime(),
                                assetToAcrId.lastModifiedBy = by
                        WITH *
                        OPTIONAL MATCH (asset)-[assetToOldAcrId:FINGERPRINTED_AS]->(oldAcrId:ACRID)
                            WHERE oldAcrId <> acrId
                        FOREACH (hasOldAcrId IN CASE WHEN oldAcrId IS NOT NULL THEN [1] ELSE [] END |
                            CREATE (asset)-[deletedRelationship:DELETED_FINGERPRINTED_AS]->(oldAcrId)
                            SET
                                deletedRelationship += assetToOldAcrId,
                                deletedRelationship.deletedAt = datetime(),
                                deletedRelationship.deletedBy = by
                            DELETE assetToOldAcrId
                        )
                        WITH DISTINCT source_asset, by, asset
                        OPTIONAL MATCH (track:Track { id: toInteger(source_asset.tuid) })
                        CALL apoc.util.validate(track IS NULL, "Could not find the track %s", [source_asset.tuid])
                        MERGE (track)-[trackHasAsset:HAS_ASSET]->(asset)
                            ON CREATE SET
                                trackHasAsset.createdAt = datetime(),
                                trackHasAsset.createdBy = by,
                                trackHasAsset.lastModifiedAt = datetime(),
                                trackHasAsset.lastModifiedBy = by
                    ',
                    {
                        batchSize: 1000
                    }
                )
                YIELD failedOperations, errorMessages, failedBatches, batch
                CALL apoc.util.validate(failedOperations > 0, "At least one sub-operation failed: %s", [reduce(all_errors = "", error IN keys(errorMessages) | all_errors + ", " + error)])
                CALL apoc.util.validate(failedBatches > 0, "At least one batch failed: %s", [reduce(all_errors = "", error IN keys(batch.errors) | all_errors + ", " + error)])
                RETURN 0
            ]]>
        </query>
        <query>
            CALL apoc.log.info("Finished acr_cloud data ingest part 43 of 169 at %s", [datetime()]);
        </query>

        <query>
            <![CDATA[
                CALL apoc.periodic.iterate(
                     "
                        WITH 'snowflake_orchard' AS url_alias,
                        '
                            SELECT * FROM facts.qa.jsonified_track_mapping ORDER BY ACR_ID ASC LIMIT 100000 OFFSET 4300000
                        '
                        AS sql
                        CALL apoc.load.jdbc(url_alias, sql)
                        YIELD row
                        return apoc.convert.fromJsonMap(row.NODE) AS row;
                    ",
                    '
                        WITH *, "database/distro-4707" AS by
                        MERGE (acrId:ACRID { id: row.acr_id })
                            ON CREATE SET
                                acrId.createdAt = datetime(),
                                acrId.createdBy = by,
                                acrId.lastModifiedAt = datetime(),
                                acrId.lastModifiedBy = by
                        MERGE (acrId)<-[acrIdToOsr:CONTAINS_FINGERPRINT]-(osr:OrchardSoundRecording)
                            ON CREATE SET
                                osr.id = apoc.create.uuid(),
                                osr.createdAt = datetime(),
                                osr.createdBy = by,
                                osr.lastModifiedAt = datetime(),
                                osr.lastModifiedBy = by,
                                acrIdToOsr.createdAt = datetime(),
                                acrIdToOsr.createdBy = by,
                                acrIdToOsr.lastModifiedAt = datetime(),
                                acrIdToOsr.lastModifiedBy = by
                        WITH *
                        UNWIND row.assets AS source_asset
                        MERGE (asset:OrchardAsset {
                            filename: source_asset.filename,
                            extension: "mp3",
                            source: "direct-delivery-db"
                        })
                            ON CREATE SET
                                asset.id = apoc.create.uuid(),
                                asset.createdAt = datetime(),
                                asset.createdBy = by,
                                asset.lastModifiedAt = datetime(),
                                asset.lastModifiedBy = by
                        MERGE (asset)-[assetToAcrId:FINGERPRINTED_AS]->(acrId)
                            ON CREATE SET
                                assetToAcrId.createdAt = datetime(),
                                assetToAcrId.createdBy = by
                            SET
                                assetToAcrId.lastModifiedAt = datetime(),
                                assetToAcrId.lastModifiedBy = by
                        WITH *
                        OPTIONAL MATCH (asset)-[assetToOldAcrId:FINGERPRINTED_AS]->(oldAcrId:ACRID)
                            WHERE oldAcrId <> acrId
                        FOREACH (hasOldAcrId IN CASE WHEN oldAcrId IS NOT NULL THEN [1] ELSE [] END |
                            CREATE (asset)-[deletedRelationship:DELETED_FINGERPRINTED_AS]->(oldAcrId)
                            SET
                                deletedRelationship += assetToOldAcrId,
                                deletedRelationship.deletedAt = datetime(),
                                deletedRelationship.deletedBy = by
                            DELETE assetToOldAcrId
                        )
                        WITH DISTINCT source_asset, by, asset
                        OPTIONAL MATCH (track:Track { id: toInteger(source_asset.tuid) })
                        CALL apoc.util.validate(track IS NULL, "Could not find the track %s", [source_asset.tuid])
                        MERGE (track)-[trackHasAsset:HAS_ASSET]->(asset)
                            ON CREATE SET
                                trackHasAsset.createdAt = datetime(),
                                trackHasAsset.createdBy = by,
                                trackHasAsset.lastModifiedAt = datetime(),
                                trackHasAsset.lastModifiedBy = by
                    ',
                    {
                        batchSize: 1000
                    }
                )
                YIELD failedOperations, errorMessages, failedBatches, batch
                CALL apoc.util.validate(failedOperations > 0, "At least one sub-operation failed: %s", [reduce(all_errors = "", error IN keys(errorMessages) | all_errors + ", " + error)])
                CALL apoc.util.validate(failedBatches > 0, "At least one batch failed: %s", [reduce(all_errors = "", error IN keys(batch.errors) | all_errors + ", " + error)])
                RETURN 0
            ]]>
        </query>
        <query>
            CALL apoc.log.info("Finished acr_cloud data ingest part 44 of 169 at %s", [datetime()]);
        </query>

        <query>
            <![CDATA[
                CALL apoc.periodic.iterate(
                     "
                        WITH 'snowflake_orchard' AS url_alias,
                        '
                            SELECT * FROM facts.qa.jsonified_track_mapping ORDER BY ACR_ID ASC LIMIT 100000 OFFSET 4400000
                        '
                        AS sql
                        CALL apoc.load.jdbc(url_alias, sql)
                        YIELD row
                        return apoc.convert.fromJsonMap(row.NODE) AS row;
                    ",
                    '
                        WITH *, "database/distro-4707" AS by
                        MERGE (acrId:ACRID { id: row.acr_id })
                            ON CREATE SET
                                acrId.createdAt = datetime(),
                                acrId.createdBy = by,
                                acrId.lastModifiedAt = datetime(),
                                acrId.lastModifiedBy = by
                        MERGE (acrId)<-[acrIdToOsr:CONTAINS_FINGERPRINT]-(osr:OrchardSoundRecording)
                            ON CREATE SET
                                osr.id = apoc.create.uuid(),
                                osr.createdAt = datetime(),
                                osr.createdBy = by,
                                osr.lastModifiedAt = datetime(),
                                osr.lastModifiedBy = by,
                                acrIdToOsr.createdAt = datetime(),
                                acrIdToOsr.createdBy = by,
                                acrIdToOsr.lastModifiedAt = datetime(),
                                acrIdToOsr.lastModifiedBy = by
                        WITH *
                        UNWIND row.assets AS source_asset
                        MERGE (asset:OrchardAsset {
                            filename: source_asset.filename,
                            extension: "mp3",
                            source: "direct-delivery-db"
                        })
                            ON CREATE SET
                                asset.id = apoc.create.uuid(),
                                asset.createdAt = datetime(),
                                asset.createdBy = by,
                                asset.lastModifiedAt = datetime(),
                                asset.lastModifiedBy = by
                        MERGE (asset)-[assetToAcrId:FINGERPRINTED_AS]->(acrId)
                            ON CREATE SET
                                assetToAcrId.createdAt = datetime(),
                                assetToAcrId.createdBy = by
                            SET
                                assetToAcrId.lastModifiedAt = datetime(),
                                assetToAcrId.lastModifiedBy = by
                        WITH *
                        OPTIONAL MATCH (asset)-[assetToOldAcrId:FINGERPRINTED_AS]->(oldAcrId:ACRID)
                            WHERE oldAcrId <> acrId
                        FOREACH (hasOldAcrId IN CASE WHEN oldAcrId IS NOT NULL THEN [1] ELSE [] END |
                            CREATE (asset)-[deletedRelationship:DELETED_FINGERPRINTED_AS]->(oldAcrId)
                            SET
                                deletedRelationship += assetToOldAcrId,
                                deletedRelationship.deletedAt = datetime(),
                                deletedRelationship.deletedBy = by
                            DELETE assetToOldAcrId
                        )
                        WITH DISTINCT source_asset, by, asset
                        OPTIONAL MATCH (track:Track { id: toInteger(source_asset.tuid) })
                        CALL apoc.util.validate(track IS NULL, "Could not find the track %s", [source_asset.tuid])
                        MERGE (track)-[trackHasAsset:HAS_ASSET]->(asset)
                            ON CREATE SET
                                trackHasAsset.createdAt = datetime(),
                                trackHasAsset.createdBy = by,
                                trackHasAsset.lastModifiedAt = datetime(),
                                trackHasAsset.lastModifiedBy = by
                    ',
                    {
                        batchSize: 1000
                    }
                )
                YIELD failedOperations, errorMessages, failedBatches, batch
                CALL apoc.util.validate(failedOperations > 0, "At least one sub-operation failed: %s", [reduce(all_errors = "", error IN keys(errorMessages) | all_errors + ", " + error)])
                CALL apoc.util.validate(failedBatches > 0, "At least one batch failed: %s", [reduce(all_errors = "", error IN keys(batch.errors) | all_errors + ", " + error)])
                RETURN 0
            ]]>
        </query>
        <query>
            CALL apoc.log.info("Finished acr_cloud data ingest part 45 of 169 at %s", [datetime()]);
        </query>

        <query>
            <![CDATA[
                CALL apoc.periodic.iterate(
                     "
                        WITH 'snowflake_orchard' AS url_alias,
                        '
                            SELECT * FROM facts.qa.jsonified_track_mapping ORDER BY ACR_ID ASC LIMIT 100000 OFFSET 4500000
                        '
                        AS sql
                        CALL apoc.load.jdbc(url_alias, sql)
                        YIELD row
                        return apoc.convert.fromJsonMap(row.NODE) AS row;
                    ",
                    '
                        WITH *, "database/distro-4707" AS by
                        MERGE (acrId:ACRID { id: row.acr_id })
                            ON CREATE SET
                                acrId.createdAt = datetime(),
                                acrId.createdBy = by,
                                acrId.lastModifiedAt = datetime(),
                                acrId.lastModifiedBy = by
                        MERGE (acrId)<-[acrIdToOsr:CONTAINS_FINGERPRINT]-(osr:OrchardSoundRecording)
                            ON CREATE SET
                                osr.id = apoc.create.uuid(),
                                osr.createdAt = datetime(),
                                osr.createdBy = by,
                                osr.lastModifiedAt = datetime(),
                                osr.lastModifiedBy = by,
                                acrIdToOsr.createdAt = datetime(),
                                acrIdToOsr.createdBy = by,
                                acrIdToOsr.lastModifiedAt = datetime(),
                                acrIdToOsr.lastModifiedBy = by
                        WITH *
                        UNWIND row.assets AS source_asset
                        MERGE (asset:OrchardAsset {
                            filename: source_asset.filename,
                            extension: "mp3",
                            source: "direct-delivery-db"
                        })
                            ON CREATE SET
                                asset.id = apoc.create.uuid(),
                                asset.createdAt = datetime(),
                                asset.createdBy = by,
                                asset.lastModifiedAt = datetime(),
                                asset.lastModifiedBy = by
                        MERGE (asset)-[assetToAcrId:FINGERPRINTED_AS]->(acrId)
                            ON CREATE SET
                                assetToAcrId.createdAt = datetime(),
                                assetToAcrId.createdBy = by
                            SET
                                assetToAcrId.lastModifiedAt = datetime(),
                                assetToAcrId.lastModifiedBy = by
                        WITH *
                        OPTIONAL MATCH (asset)-[assetToOldAcrId:FINGERPRINTED_AS]->(oldAcrId:ACRID)
                            WHERE oldAcrId <> acrId
                        FOREACH (hasOldAcrId IN CASE WHEN oldAcrId IS NOT NULL THEN [1] ELSE [] END |
                            CREATE (asset)-[deletedRelationship:DELETED_FINGERPRINTED_AS]->(oldAcrId)
                            SET
                                deletedRelationship += assetToOldAcrId,
                                deletedRelationship.deletedAt = datetime(),
                                deletedRelationship.deletedBy = by
                            DELETE assetToOldAcrId
                        )
                        WITH DISTINCT source_asset, by, asset
                        OPTIONAL MATCH (track:Track { id: toInteger(source_asset.tuid) })
                        CALL apoc.util.validate(track IS NULL, "Could not find the track %s", [source_asset.tuid])
                        MERGE (track)-[trackHasAsset:HAS_ASSET]->(asset)
                            ON CREATE SET
                                trackHasAsset.createdAt = datetime(),
                                trackHasAsset.createdBy = by,
                                trackHasAsset.lastModifiedAt = datetime(),
                                trackHasAsset.lastModifiedBy = by
                    ',
                    {
                        batchSize: 1000
                    }
                )
                YIELD failedOperations, errorMessages, failedBatches, batch
                CALL apoc.util.validate(failedOperations > 0, "At least one sub-operation failed: %s", [reduce(all_errors = "", error IN keys(errorMessages) | all_errors + ", " + error)])
                CALL apoc.util.validate(failedBatches > 0, "At least one batch failed: %s", [reduce(all_errors = "", error IN keys(batch.errors) | all_errors + ", " + error)])
                RETURN 0
            ]]>
        </query>
        <query>
            CALL apoc.log.info("Finished acr_cloud data ingest part 46 of 169 at %s", [datetime()]);
        </query>

        <query>
            <![CDATA[
                CALL apoc.periodic.iterate(
                     "
                        WITH 'snowflake_orchard' AS url_alias,
                        '
                            SELECT * FROM facts.qa.jsonified_track_mapping ORDER BY ACR_ID ASC LIMIT 100000 OFFSET 4600000
                        '
                        AS sql
                        CALL apoc.load.jdbc(url_alias, sql)
                        YIELD row
                        return apoc.convert.fromJsonMap(row.NODE) AS row;
                    ",
                    '
                        WITH *, "database/distro-4707" AS by
                        MERGE (acrId:ACRID { id: row.acr_id })
                            ON CREATE SET
                                acrId.createdAt = datetime(),
                                acrId.createdBy = by,
                                acrId.lastModifiedAt = datetime(),
                                acrId.lastModifiedBy = by
                        MERGE (acrId)<-[acrIdToOsr:CONTAINS_FINGERPRINT]-(osr:OrchardSoundRecording)
                            ON CREATE SET
                                osr.id = apoc.create.uuid(),
                                osr.createdAt = datetime(),
                                osr.createdBy = by,
                                osr.lastModifiedAt = datetime(),
                                osr.lastModifiedBy = by,
                                acrIdToOsr.createdAt = datetime(),
                                acrIdToOsr.createdBy = by,
                                acrIdToOsr.lastModifiedAt = datetime(),
                                acrIdToOsr.lastModifiedBy = by
                        WITH *
                        UNWIND row.assets AS source_asset
                        MERGE (asset:OrchardAsset {
                            filename: source_asset.filename,
                            extension: "mp3",
                            source: "direct-delivery-db"
                        })
                            ON CREATE SET
                                asset.id = apoc.create.uuid(),
                                asset.createdAt = datetime(),
                                asset.createdBy = by,
                                asset.lastModifiedAt = datetime(),
                                asset.lastModifiedBy = by
                        MERGE (asset)-[assetToAcrId:FINGERPRINTED_AS]->(acrId)
                            ON CREATE SET
                                assetToAcrId.createdAt = datetime(),
                                assetToAcrId.createdBy = by
                            SET
                                assetToAcrId.lastModifiedAt = datetime(),
                                assetToAcrId.lastModifiedBy = by
                        WITH *
                        OPTIONAL MATCH (asset)-[assetToOldAcrId:FINGERPRINTED_AS]->(oldAcrId:ACRID)
                            WHERE oldAcrId <> acrId
                        FOREACH (hasOldAcrId IN CASE WHEN oldAcrId IS NOT NULL THEN [1] ELSE [] END |
                            CREATE (asset)-[deletedRelationship:DELETED_FINGERPRINTED_AS]->(oldAcrId)
                            SET
                                deletedRelationship += assetToOldAcrId,
                                deletedRelationship.deletedAt = datetime(),
                                deletedRelationship.deletedBy = by
                            DELETE assetToOldAcrId
                        )
                        WITH DISTINCT source_asset, by, asset
                        OPTIONAL MATCH (track:Track { id: toInteger(source_asset.tuid) })
                        CALL apoc.util.validate(track IS NULL, "Could not find the track %s", [source_asset.tuid])
                        MERGE (track)-[trackHasAsset:HAS_ASSET]->(asset)
                            ON CREATE SET
                                trackHasAsset.createdAt = datetime(),
                                trackHasAsset.createdBy = by,
                                trackHasAsset.lastModifiedAt = datetime(),
                                trackHasAsset.lastModifiedBy = by
                    ',
                    {
                        batchSize: 1000
                    }
                )
                YIELD failedOperations, errorMessages, failedBatches, batch
                CALL apoc.util.validate(failedOperations > 0, "At least one sub-operation failed: %s", [reduce(all_errors = "", error IN keys(errorMessages) | all_errors + ", " + error)])
                CALL apoc.util.validate(failedBatches > 0, "At least one batch failed: %s", [reduce(all_errors = "", error IN keys(batch.errors) | all_errors + ", " + error)])
                RETURN 0
            ]]>
        </query>
        <query>
            CALL apoc.log.info("Finished acr_cloud data ingest part 47 of 169 at %s", [datetime()]);
        </query>

        <query>
            <![CDATA[
                CALL apoc.periodic.iterate(
                     "
                        WITH 'snowflake_orchard' AS url_alias,
                        '
                            SELECT * FROM facts.qa.jsonified_track_mapping ORDER BY ACR_ID ASC LIMIT 100000 OFFSET 4700000
                        '
                        AS sql
                        CALL apoc.load.jdbc(url_alias, sql)
                        YIELD row
                        return apoc.convert.fromJsonMap(row.NODE) AS row;
                    ",
                    '
                        WITH *, "database/distro-4707" AS by
                        MERGE (acrId:ACRID { id: row.acr_id })
                            ON CREATE SET
                                acrId.createdAt = datetime(),
                                acrId.createdBy = by,
                                acrId.lastModifiedAt = datetime(),
                                acrId.lastModifiedBy = by
                        MERGE (acrId)<-[acrIdToOsr:CONTAINS_FINGERPRINT]-(osr:OrchardSoundRecording)
                            ON CREATE SET
                                osr.id = apoc.create.uuid(),
                                osr.createdAt = datetime(),
                                osr.createdBy = by,
                                osr.lastModifiedAt = datetime(),
                                osr.lastModifiedBy = by,
                                acrIdToOsr.createdAt = datetime(),
                                acrIdToOsr.createdBy = by,
                                acrIdToOsr.lastModifiedAt = datetime(),
                                acrIdToOsr.lastModifiedBy = by
                        WITH *
                        UNWIND row.assets AS source_asset
                        MERGE (asset:OrchardAsset {
                            filename: source_asset.filename,
                            extension: "mp3",
                            source: "direct-delivery-db"
                        })
                            ON CREATE SET
                                asset.id = apoc.create.uuid(),
                                asset.createdAt = datetime(),
                                asset.createdBy = by,
                                asset.lastModifiedAt = datetime(),
                                asset.lastModifiedBy = by
                        MERGE (asset)-[assetToAcrId:FINGERPRINTED_AS]->(acrId)
                            ON CREATE SET
                                assetToAcrId.createdAt = datetime(),
                                assetToAcrId.createdBy = by
                            SET
                                assetToAcrId.lastModifiedAt = datetime(),
                                assetToAcrId.lastModifiedBy = by
                        WITH *
                        OPTIONAL MATCH (asset)-[assetToOldAcrId:FINGERPRINTED_AS]->(oldAcrId:ACRID)
                            WHERE oldAcrId <> acrId
                        FOREACH (hasOldAcrId IN CASE WHEN oldAcrId IS NOT NULL THEN [1] ELSE [] END |
                            CREATE (asset)-[deletedRelationship:DELETED_FINGERPRINTED_AS]->(oldAcrId)
                            SET
                                deletedRelationship += assetToOldAcrId,
                                deletedRelationship.deletedAt = datetime(),
                                deletedRelationship.deletedBy = by
                            DELETE assetToOldAcrId
                        )
                        WITH DISTINCT source_asset, by, asset
                        OPTIONAL MATCH (track:Track { id: toInteger(source_asset.tuid) })
                        CALL apoc.util.validate(track IS NULL, "Could not find the track %s", [source_asset.tuid])
                        MERGE (track)-[trackHasAsset:HAS_ASSET]->(asset)
                            ON CREATE SET
                                trackHasAsset.createdAt = datetime(),
                                trackHasAsset.createdBy = by,
                                trackHasAsset.lastModifiedAt = datetime(),
                                trackHasAsset.lastModifiedBy = by
                    ',
                    {
                        batchSize: 1000
                    }
                )
                YIELD failedOperations, errorMessages, failedBatches, batch
                CALL apoc.util.validate(failedOperations > 0, "At least one sub-operation failed: %s", [reduce(all_errors = "", error IN keys(errorMessages) | all_errors + ", " + error)])
                CALL apoc.util.validate(failedBatches > 0, "At least one batch failed: %s", [reduce(all_errors = "", error IN keys(batch.errors) | all_errors + ", " + error)])
                RETURN 0
            ]]>
        </query>
        <query>
            CALL apoc.log.info("Finished acr_cloud data ingest part 48 of 169 at %s", [datetime()]);
        </query>

        <query>
            <![CDATA[
                CALL apoc.periodic.iterate(
                     "
                        WITH 'snowflake_orchard' AS url_alias,
                        '
                            SELECT * FROM facts.qa.jsonified_track_mapping ORDER BY ACR_ID ASC LIMIT 100000 OFFSET 4800000
                        '
                        AS sql
                        CALL apoc.load.jdbc(url_alias, sql)
                        YIELD row
                        return apoc.convert.fromJsonMap(row.NODE) AS row;
                    ",
                    '
                        WITH *, "database/distro-4707" AS by
                        MERGE (acrId:ACRID { id: row.acr_id })
                            ON CREATE SET
                                acrId.createdAt = datetime(),
                                acrId.createdBy = by,
                                acrId.lastModifiedAt = datetime(),
                                acrId.lastModifiedBy = by
                        MERGE (acrId)<-[acrIdToOsr:CONTAINS_FINGERPRINT]-(osr:OrchardSoundRecording)
                            ON CREATE SET
                                osr.id = apoc.create.uuid(),
                                osr.createdAt = datetime(),
                                osr.createdBy = by,
                                osr.lastModifiedAt = datetime(),
                                osr.lastModifiedBy = by,
                                acrIdToOsr.createdAt = datetime(),
                                acrIdToOsr.createdBy = by,
                                acrIdToOsr.lastModifiedAt = datetime(),
                                acrIdToOsr.lastModifiedBy = by
                        WITH *
                        UNWIND row.assets AS source_asset
                        MERGE (asset:OrchardAsset {
                            filename: source_asset.filename,
                            extension: "mp3",
                            source: "direct-delivery-db"
                        })
                            ON CREATE SET
                                asset.id = apoc.create.uuid(),
                                asset.createdAt = datetime(),
                                asset.createdBy = by,
                                asset.lastModifiedAt = datetime(),
                                asset.lastModifiedBy = by
                        MERGE (asset)-[assetToAcrId:FINGERPRINTED_AS]->(acrId)
                            ON CREATE SET
                                assetToAcrId.createdAt = datetime(),
                                assetToAcrId.createdBy = by
                            SET
                                assetToAcrId.lastModifiedAt = datetime(),
                                assetToAcrId.lastModifiedBy = by
                        WITH *
                        OPTIONAL MATCH (asset)-[assetToOldAcrId:FINGERPRINTED_AS]->(oldAcrId:ACRID)
                            WHERE oldAcrId <> acrId
                        FOREACH (hasOldAcrId IN CASE WHEN oldAcrId IS NOT NULL THEN [1] ELSE [] END |
                            CREATE (asset)-[deletedRelationship:DELETED_FINGERPRINTED_AS]->(oldAcrId)
                            SET
                                deletedRelationship += assetToOldAcrId,
                                deletedRelationship.deletedAt = datetime(),
                                deletedRelationship.deletedBy = by
                            DELETE assetToOldAcrId
                        )
                        WITH DISTINCT source_asset, by, asset
                        OPTIONAL MATCH (track:Track { id: toInteger(source_asset.tuid) })
                        CALL apoc.util.validate(track IS NULL, "Could not find the track %s", [source_asset.tuid])
                        MERGE (track)-[trackHasAsset:HAS_ASSET]->(asset)
                            ON CREATE SET
                                trackHasAsset.createdAt = datetime(),
                                trackHasAsset.createdBy = by,
                                trackHasAsset.lastModifiedAt = datetime(),
                                trackHasAsset.lastModifiedBy = by
                    ',
                    {
                        batchSize: 1000
                    }
                )
                YIELD failedOperations, errorMessages, failedBatches, batch
                CALL apoc.util.validate(failedOperations > 0, "At least one sub-operation failed: %s", [reduce(all_errors = "", error IN keys(errorMessages) | all_errors + ", " + error)])
                CALL apoc.util.validate(failedBatches > 0, "At least one batch failed: %s", [reduce(all_errors = "", error IN keys(batch.errors) | all_errors + ", " + error)])
                RETURN 0
            ]]>
        </query>
        <query>
            CALL apoc.log.info("Finished acr_cloud data ingest part 49 of 169 at %s", [datetime()]);
        </query>

        <query>
            <![CDATA[
                CALL apoc.periodic.iterate(
                     "
                        WITH 'snowflake_orchard' AS url_alias,
                        '
                            SELECT * FROM facts.qa.jsonified_track_mapping ORDER BY ACR_ID ASC LIMIT 100000 OFFSET 4900000
                        '
                        AS sql
                        CALL apoc.load.jdbc(url_alias, sql)
                        YIELD row
                        return apoc.convert.fromJsonMap(row.NODE) AS row;
                    ",
                    '
                        WITH *, "database/distro-4707" AS by
                        MERGE (acrId:ACRID { id: row.acr_id })
                            ON CREATE SET
                                acrId.createdAt = datetime(),
                                acrId.createdBy = by,
                                acrId.lastModifiedAt = datetime(),
                                acrId.lastModifiedBy = by
                        MERGE (acrId)<-[acrIdToOsr:CONTAINS_FINGERPRINT]-(osr:OrchardSoundRecording)
                            ON CREATE SET
                                osr.id = apoc.create.uuid(),
                                osr.createdAt = datetime(),
                                osr.createdBy = by,
                                osr.lastModifiedAt = datetime(),
                                osr.lastModifiedBy = by,
                                acrIdToOsr.createdAt = datetime(),
                                acrIdToOsr.createdBy = by,
                                acrIdToOsr.lastModifiedAt = datetime(),
                                acrIdToOsr.lastModifiedBy = by
                        WITH *
                        UNWIND row.assets AS source_asset
                        MERGE (asset:OrchardAsset {
                            filename: source_asset.filename,
                            extension: "mp3",
                            source: "direct-delivery-db"
                        })
                            ON CREATE SET
                                asset.id = apoc.create.uuid(),
                                asset.createdAt = datetime(),
                                asset.createdBy = by,
                                asset.lastModifiedAt = datetime(),
                                asset.lastModifiedBy = by
                        MERGE (asset)-[assetToAcrId:FINGERPRINTED_AS]->(acrId)
                            ON CREATE SET
                                assetToAcrId.createdAt = datetime(),
                                assetToAcrId.createdBy = by
                            SET
                                assetToAcrId.lastModifiedAt = datetime(),
                                assetToAcrId.lastModifiedBy = by
                        WITH *
                        OPTIONAL MATCH (asset)-[assetToOldAcrId:FINGERPRINTED_AS]->(oldAcrId:ACRID)
                            WHERE oldAcrId <> acrId
                        FOREACH (hasOldAcrId IN CASE WHEN oldAcrId IS NOT NULL THEN [1] ELSE [] END |
                            CREATE (asset)-[deletedRelationship:DELETED_FINGERPRINTED_AS]->(oldAcrId)
                            SET
                                deletedRelationship += assetToOldAcrId,
                                deletedRelationship.deletedAt = datetime(),
                                deletedRelationship.deletedBy = by
                            DELETE assetToOldAcrId
                        )
                        WITH DISTINCT source_asset, by, asset
                        OPTIONAL MATCH (track:Track { id: toInteger(source_asset.tuid) })
                        CALL apoc.util.validate(track IS NULL, "Could not find the track %s", [source_asset.tuid])
                        MERGE (track)-[trackHasAsset:HAS_ASSET]->(asset)
                            ON CREATE SET
                                trackHasAsset.createdAt = datetime(),
                                trackHasAsset.createdBy = by,
                                trackHasAsset.lastModifiedAt = datetime(),
                                trackHasAsset.lastModifiedBy = by
                    ',
                    {
                        batchSize: 1000
                    }
                )
                YIELD failedOperations, errorMessages, failedBatches, batch
                CALL apoc.util.validate(failedOperations > 0, "At least one sub-operation failed: %s", [reduce(all_errors = "", error IN keys(errorMessages) | all_errors + ", " + error)])
                CALL apoc.util.validate(failedBatches > 0, "At least one batch failed: %s", [reduce(all_errors = "", error IN keys(batch.errors) | all_errors + ", " + error)])
                RETURN 0
            ]]>
        </query>
        <query>
            CALL apoc.log.info("Finished acr_cloud data ingest part 50 of 169 at %s", [datetime()]);
        </query>

        <query>
            <![CDATA[
                CALL apoc.periodic.iterate(
                     "
                        WITH 'snowflake_orchard' AS url_alias,
                        '
                            SELECT * FROM facts.qa.jsonified_track_mapping ORDER BY ACR_ID ASC LIMIT 100000 OFFSET 5000000
                        '
                        AS sql
                        CALL apoc.load.jdbc(url_alias, sql)
                        YIELD row
                        return apoc.convert.fromJsonMap(row.NODE) AS row;
                    ",
                    '
                        WITH *, "database/distro-4707" AS by
                        MERGE (acrId:ACRID { id: row.acr_id })
                            ON CREATE SET
                                acrId.createdAt = datetime(),
                                acrId.createdBy = by,
                                acrId.lastModifiedAt = datetime(),
                                acrId.lastModifiedBy = by
                        MERGE (acrId)<-[acrIdToOsr:CONTAINS_FINGERPRINT]-(osr:OrchardSoundRecording)
                            ON CREATE SET
                                osr.id = apoc.create.uuid(),
                                osr.createdAt = datetime(),
                                osr.createdBy = by,
                                osr.lastModifiedAt = datetime(),
                                osr.lastModifiedBy = by,
                                acrIdToOsr.createdAt = datetime(),
                                acrIdToOsr.createdBy = by,
                                acrIdToOsr.lastModifiedAt = datetime(),
                                acrIdToOsr.lastModifiedBy = by
                        WITH *
                        UNWIND row.assets AS source_asset
                        MERGE (asset:OrchardAsset {
                            filename: source_asset.filename,
                            extension: "mp3",
                            source: "direct-delivery-db"
                        })
                            ON CREATE SET
                                asset.id = apoc.create.uuid(),
                                asset.createdAt = datetime(),
                                asset.createdBy = by,
                                asset.lastModifiedAt = datetime(),
                                asset.lastModifiedBy = by
                        MERGE (asset)-[assetToAcrId:FINGERPRINTED_AS]->(acrId)
                            ON CREATE SET
                                assetToAcrId.createdAt = datetime(),
                                assetToAcrId.createdBy = by
                            SET
                                assetToAcrId.lastModifiedAt = datetime(),
                                assetToAcrId.lastModifiedBy = by
                        WITH *
                        OPTIONAL MATCH (asset)-[assetToOldAcrId:FINGERPRINTED_AS]->(oldAcrId:ACRID)
                            WHERE oldAcrId <> acrId
                        FOREACH (hasOldAcrId IN CASE WHEN oldAcrId IS NOT NULL THEN [1] ELSE [] END |
                            CREATE (asset)-[deletedRelationship:DELETED_FINGERPRINTED_AS]->(oldAcrId)
                            SET
                                deletedRelationship += assetToOldAcrId,
                                deletedRelationship.deletedAt = datetime(),
                                deletedRelationship.deletedBy = by
                            DELETE assetToOldAcrId
                        )
                        WITH DISTINCT source_asset, by, asset
                        OPTIONAL MATCH (track:Track { id: toInteger(source_asset.tuid) })
                        CALL apoc.util.validate(track IS NULL, "Could not find the track %s", [source_asset.tuid])
                        MERGE (track)-[trackHasAsset:HAS_ASSET]->(asset)
                            ON CREATE SET
                                trackHasAsset.createdAt = datetime(),
                                trackHasAsset.createdBy = by,
                                trackHasAsset.lastModifiedAt = datetime(),
                                trackHasAsset.lastModifiedBy = by
                    ',
                    {
                        batchSize: 1000
                    }
                )
                YIELD failedOperations, errorMessages, failedBatches, batch
                CALL apoc.util.validate(failedOperations > 0, "At least one sub-operation failed: %s", [reduce(all_errors = "", error IN keys(errorMessages) | all_errors + ", " + error)])
                CALL apoc.util.validate(failedBatches > 0, "At least one batch failed: %s", [reduce(all_errors = "", error IN keys(batch.errors) | all_errors + ", " + error)])
                RETURN 0
            ]]>
        </query>
        <query>
            CALL apoc.log.info("Finished acr_cloud data ingest part 51 of 169 at %s", [datetime()]);
        </query>

        <query>
            <![CDATA[
                CALL apoc.periodic.iterate(
                     "
                        WITH 'snowflake_orchard' AS url_alias,
                        '
                            SELECT * FROM facts.qa.jsonified_track_mapping ORDER BY ACR_ID ASC LIMIT 100000 OFFSET 5100000
                        '
                        AS sql
                        CALL apoc.load.jdbc(url_alias, sql)
                        YIELD row
                        return apoc.convert.fromJsonMap(row.NODE) AS row;
                    ",
                    '
                        WITH *, "database/distro-4707" AS by
                        MERGE (acrId:ACRID { id: row.acr_id })
                            ON CREATE SET
                                acrId.createdAt = datetime(),
                                acrId.createdBy = by,
                                acrId.lastModifiedAt = datetime(),
                                acrId.lastModifiedBy = by
                        MERGE (acrId)<-[acrIdToOsr:CONTAINS_FINGERPRINT]-(osr:OrchardSoundRecording)
                            ON CREATE SET
                                osr.id = apoc.create.uuid(),
                                osr.createdAt = datetime(),
                                osr.createdBy = by,
                                osr.lastModifiedAt = datetime(),
                                osr.lastModifiedBy = by,
                                acrIdToOsr.createdAt = datetime(),
                                acrIdToOsr.createdBy = by,
                                acrIdToOsr.lastModifiedAt = datetime(),
                                acrIdToOsr.lastModifiedBy = by
                        WITH *
                        UNWIND row.assets AS source_asset
                        MERGE (asset:OrchardAsset {
                            filename: source_asset.filename,
                            extension: "mp3",
                            source: "direct-delivery-db"
                        })
                            ON CREATE SET
                                asset.id = apoc.create.uuid(),
                                asset.createdAt = datetime(),
                                asset.createdBy = by,
                                asset.lastModifiedAt = datetime(),
                                asset.lastModifiedBy = by
                        MERGE (asset)-[assetToAcrId:FINGERPRINTED_AS]->(acrId)
                            ON CREATE SET
                                assetToAcrId.createdAt = datetime(),
                                assetToAcrId.createdBy = by
                            SET
                                assetToAcrId.lastModifiedAt = datetime(),
                                assetToAcrId.lastModifiedBy = by
                        WITH *
                        OPTIONAL MATCH (asset)-[assetToOldAcrId:FINGERPRINTED_AS]->(oldAcrId:ACRID)
                            WHERE oldAcrId <> acrId
                        FOREACH (hasOldAcrId IN CASE WHEN oldAcrId IS NOT NULL THEN [1] ELSE [] END |
                            CREATE (asset)-[deletedRelationship:DELETED_FINGERPRINTED_AS]->(oldAcrId)
                            SET
                                deletedRelationship += assetToOldAcrId,
                                deletedRelationship.deletedAt = datetime(),
                                deletedRelationship.deletedBy = by
                            DELETE assetToOldAcrId
                        )
                        WITH DISTINCT source_asset, by, asset
                        OPTIONAL MATCH (track:Track { id: toInteger(source_asset.tuid) })
                        CALL apoc.util.validate(track IS NULL, "Could not find the track %s", [source_asset.tuid])
                        MERGE (track)-[trackHasAsset:HAS_ASSET]->(asset)
                            ON CREATE SET
                                trackHasAsset.createdAt = datetime(),
                                trackHasAsset.createdBy = by,
                                trackHasAsset.lastModifiedAt = datetime(),
                                trackHasAsset.lastModifiedBy = by
                    ',
                    {
                        batchSize: 1000
                    }
                )
                YIELD failedOperations, errorMessages, failedBatches, batch
                CALL apoc.util.validate(failedOperations > 0, "At least one sub-operation failed: %s", [reduce(all_errors = "", error IN keys(errorMessages) | all_errors + ", " + error)])
                CALL apoc.util.validate(failedBatches > 0, "At least one batch failed: %s", [reduce(all_errors = "", error IN keys(batch.errors) | all_errors + ", " + error)])
                RETURN 0
            ]]>
        </query>
        <query>
            CALL apoc.log.info("Finished acr_cloud data ingest part 52 of 169 at %s", [datetime()]);
        </query>

        <query>
            <![CDATA[
                CALL apoc.periodic.iterate(
                     "
                        WITH 'snowflake_orchard' AS url_alias,
                        '
                            SELECT * FROM facts.qa.jsonified_track_mapping ORDER BY ACR_ID ASC LIMIT 100000 OFFSET 5200000
                        '
                        AS sql
                        CALL apoc.load.jdbc(url_alias, sql)
                        YIELD row
                        return apoc.convert.fromJsonMap(row.NODE) AS row;
                    ",
                    '
                        WITH *, "database/distro-4707" AS by
                        MERGE (acrId:ACRID { id: row.acr_id })
                            ON CREATE SET
                                acrId.createdAt = datetime(),
                                acrId.createdBy = by,
                                acrId.lastModifiedAt = datetime(),
                                acrId.lastModifiedBy = by
                        MERGE (acrId)<-[acrIdToOsr:CONTAINS_FINGERPRINT]-(osr:OrchardSoundRecording)
                            ON CREATE SET
                                osr.id = apoc.create.uuid(),
                                osr.createdAt = datetime(),
                                osr.createdBy = by,
                                osr.lastModifiedAt = datetime(),
                                osr.lastModifiedBy = by,
                                acrIdToOsr.createdAt = datetime(),
                                acrIdToOsr.createdBy = by,
                                acrIdToOsr.lastModifiedAt = datetime(),
                                acrIdToOsr.lastModifiedBy = by
                        WITH *
                        UNWIND row.assets AS source_asset
                        MERGE (asset:OrchardAsset {
                            filename: source_asset.filename,
                            extension: "mp3",
                            source: "direct-delivery-db"
                        })
                            ON CREATE SET
                                asset.id = apoc.create.uuid(),
                                asset.createdAt = datetime(),
                                asset.createdBy = by,
                                asset.lastModifiedAt = datetime(),
                                asset.lastModifiedBy = by
                        MERGE (asset)-[assetToAcrId:FINGERPRINTED_AS]->(acrId)
                            ON CREATE SET
                                assetToAcrId.createdAt = datetime(),
                                assetToAcrId.createdBy = by
                            SET
                                assetToAcrId.lastModifiedAt = datetime(),
                                assetToAcrId.lastModifiedBy = by
                        WITH *
                        OPTIONAL MATCH (asset)-[assetToOldAcrId:FINGERPRINTED_AS]->(oldAcrId:ACRID)
                            WHERE oldAcrId <> acrId
                        FOREACH (hasOldAcrId IN CASE WHEN oldAcrId IS NOT NULL THEN [1] ELSE [] END |
                            CREATE (asset)-[deletedRelationship:DELETED_FINGERPRINTED_AS]->(oldAcrId)
                            SET
                                deletedRelationship += assetToOldAcrId,
                                deletedRelationship.deletedAt = datetime(),
                                deletedRelationship.deletedBy = by
                            DELETE assetToOldAcrId
                        )
                        WITH DISTINCT source_asset, by, asset
                        OPTIONAL MATCH (track:Track { id: toInteger(source_asset.tuid) })
                        CALL apoc.util.validate(track IS NULL, "Could not find the track %s", [source_asset.tuid])
                        MERGE (track)-[trackHasAsset:HAS_ASSET]->(asset)
                            ON CREATE SET
                                trackHasAsset.createdAt = datetime(),
                                trackHasAsset.createdBy = by,
                                trackHasAsset.lastModifiedAt = datetime(),
                                trackHasAsset.lastModifiedBy = by
                    ',
                    {
                        batchSize: 1000
                    }
                )
                YIELD failedOperations, errorMessages, failedBatches, batch
                CALL apoc.util.validate(failedOperations > 0, "At least one sub-operation failed: %s", [reduce(all_errors = "", error IN keys(errorMessages) | all_errors + ", " + error)])
                CALL apoc.util.validate(failedBatches > 0, "At least one batch failed: %s", [reduce(all_errors = "", error IN keys(batch.errors) | all_errors + ", " + error)])
                RETURN 0
            ]]>
        </query>
        <query>
            CALL apoc.log.info("Finished acr_cloud data ingest part 53 of 169 at %s", [datetime()]);
        </query>

        <query>
            <![CDATA[
                CALL apoc.periodic.iterate(
                     "
                        WITH 'snowflake_orchard' AS url_alias,
                        '
                            SELECT * FROM facts.qa.jsonified_track_mapping ORDER BY ACR_ID ASC LIMIT 100000 OFFSET 5300000
                        '
                        AS sql
                        CALL apoc.load.jdbc(url_alias, sql)
                        YIELD row
                        return apoc.convert.fromJsonMap(row.NODE) AS row;
                    ",
                    '
                        WITH *, "database/distro-4707" AS by
                        MERGE (acrId:ACRID { id: row.acr_id })
                            ON CREATE SET
                                acrId.createdAt = datetime(),
                                acrId.createdBy = by,
                                acrId.lastModifiedAt = datetime(),
                                acrId.lastModifiedBy = by
                        MERGE (acrId)<-[acrIdToOsr:CONTAINS_FINGERPRINT]-(osr:OrchardSoundRecording)
                            ON CREATE SET
                                osr.id = apoc.create.uuid(),
                                osr.createdAt = datetime(),
                                osr.createdBy = by,
                                osr.lastModifiedAt = datetime(),
                                osr.lastModifiedBy = by,
                                acrIdToOsr.createdAt = datetime(),
                                acrIdToOsr.createdBy = by,
                                acrIdToOsr.lastModifiedAt = datetime(),
                                acrIdToOsr.lastModifiedBy = by
                        WITH *
                        UNWIND row.assets AS source_asset
                        MERGE (asset:OrchardAsset {
                            filename: source_asset.filename,
                            extension: "mp3",
                            source: "direct-delivery-db"
                        })
                            ON CREATE SET
                                asset.id = apoc.create.uuid(),
                                asset.createdAt = datetime(),
                                asset.createdBy = by,
                                asset.lastModifiedAt = datetime(),
                                asset.lastModifiedBy = by
                        MERGE (asset)-[assetToAcrId:FINGERPRINTED_AS]->(acrId)
                            ON CREATE SET
                                assetToAcrId.createdAt = datetime(),
                                assetToAcrId.createdBy = by
                            SET
                                assetToAcrId.lastModifiedAt = datetime(),
                                assetToAcrId.lastModifiedBy = by
                        WITH *
                        OPTIONAL MATCH (asset)-[assetToOldAcrId:FINGERPRINTED_AS]->(oldAcrId:ACRID)
                            WHERE oldAcrId <> acrId
                        FOREACH (hasOldAcrId IN CASE WHEN oldAcrId IS NOT NULL THEN [1] ELSE [] END |
                            CREATE (asset)-[deletedRelationship:DELETED_FINGERPRINTED_AS]->(oldAcrId)
                            SET
                                deletedRelationship += assetToOldAcrId,
                                deletedRelationship.deletedAt = datetime(),
                                deletedRelationship.deletedBy = by
                            DELETE assetToOldAcrId
                        )
                        WITH DISTINCT source_asset, by, asset
                        OPTIONAL MATCH (track:Track { id: toInteger(source_asset.tuid) })
                        CALL apoc.util.validate(track IS NULL, "Could not find the track %s", [source_asset.tuid])
                        MERGE (track)-[trackHasAsset:HAS_ASSET]->(asset)
                            ON CREATE SET
                                trackHasAsset.createdAt = datetime(),
                                trackHasAsset.createdBy = by,
                                trackHasAsset.lastModifiedAt = datetime(),
                                trackHasAsset.lastModifiedBy = by
                    ',
                    {
                        batchSize: 1000
                    }
                )
                YIELD failedOperations, errorMessages, failedBatches, batch
                CALL apoc.util.validate(failedOperations > 0, "At least one sub-operation failed: %s", [reduce(all_errors = "", error IN keys(errorMessages) | all_errors + ", " + error)])
                CALL apoc.util.validate(failedBatches > 0, "At least one batch failed: %s", [reduce(all_errors = "", error IN keys(batch.errors) | all_errors + ", " + error)])
                RETURN 0
            ]]>
        </query>
        <query>
            CALL apoc.log.info("Finished acr_cloud data ingest part 54 of 169 at %s", [datetime()]);
        </query>

        <query>
            <![CDATA[
                CALL apoc.periodic.iterate(
                     "
                        WITH 'snowflake_orchard' AS url_alias,
                        '
                            SELECT * FROM facts.qa.jsonified_track_mapping ORDER BY ACR_ID ASC LIMIT 100000 OFFSET 5400000
                        '
                        AS sql
                        CALL apoc.load.jdbc(url_alias, sql)
                        YIELD row
                        return apoc.convert.fromJsonMap(row.NODE) AS row;
                    ",
                    '
                        WITH *, "database/distro-4707" AS by
                        MERGE (acrId:ACRID { id: row.acr_id })
                            ON CREATE SET
                                acrId.createdAt = datetime(),
                                acrId.createdBy = by,
                                acrId.lastModifiedAt = datetime(),
                                acrId.lastModifiedBy = by
                        MERGE (acrId)<-[acrIdToOsr:CONTAINS_FINGERPRINT]-(osr:OrchardSoundRecording)
                            ON CREATE SET
                                osr.id = apoc.create.uuid(),
                                osr.createdAt = datetime(),
                                osr.createdBy = by,
                                osr.lastModifiedAt = datetime(),
                                osr.lastModifiedBy = by,
                                acrIdToOsr.createdAt = datetime(),
                                acrIdToOsr.createdBy = by,
                                acrIdToOsr.lastModifiedAt = datetime(),
                                acrIdToOsr.lastModifiedBy = by
                        WITH *
                        UNWIND row.assets AS source_asset
                        MERGE (asset:OrchardAsset {
                            filename: source_asset.filename,
                            extension: "mp3",
                            source: "direct-delivery-db"
                        })
                            ON CREATE SET
                                asset.id = apoc.create.uuid(),
                                asset.createdAt = datetime(),
                                asset.createdBy = by,
                                asset.lastModifiedAt = datetime(),
                                asset.lastModifiedBy = by
                        MERGE (asset)-[assetToAcrId:FINGERPRINTED_AS]->(acrId)
                            ON CREATE SET
                                assetToAcrId.createdAt = datetime(),
                                assetToAcrId.createdBy = by
                            SET
                                assetToAcrId.lastModifiedAt = datetime(),
                                assetToAcrId.lastModifiedBy = by
                        WITH *
                        OPTIONAL MATCH (asset)-[assetToOldAcrId:FINGERPRINTED_AS]->(oldAcrId:ACRID)
                            WHERE oldAcrId <> acrId
                        FOREACH (hasOldAcrId IN CASE WHEN oldAcrId IS NOT NULL THEN [1] ELSE [] END |
                            CREATE (asset)-[deletedRelationship:DELETED_FINGERPRINTED_AS]->(oldAcrId)
                            SET
                                deletedRelationship += assetToOldAcrId,
                                deletedRelationship.deletedAt = datetime(),
                                deletedRelationship.deletedBy = by
                            DELETE assetToOldAcrId
                        )
                        WITH DISTINCT source_asset, by, asset
                        OPTIONAL MATCH (track:Track { id: toInteger(source_asset.tuid) })
                        CALL apoc.util.validate(track IS NULL, "Could not find the track %s", [source_asset.tuid])
                        MERGE (track)-[trackHasAsset:HAS_ASSET]->(asset)
                            ON CREATE SET
                                trackHasAsset.createdAt = datetime(),
                                trackHasAsset.createdBy = by,
                                trackHasAsset.lastModifiedAt = datetime(),
                                trackHasAsset.lastModifiedBy = by
                    ',
                    {
                        batchSize: 1000
                    }
                )
                YIELD failedOperations, errorMessages, failedBatches, batch
                CALL apoc.util.validate(failedOperations > 0, "At least one sub-operation failed: %s", [reduce(all_errors = "", error IN keys(errorMessages) | all_errors + ", " + error)])
                CALL apoc.util.validate(failedBatches > 0, "At least one batch failed: %s", [reduce(all_errors = "", error IN keys(batch.errors) | all_errors + ", " + error)])
                RETURN 0
            ]]>
        </query>
        <query>
            CALL apoc.log.info("Finished acr_cloud data ingest part 55 of 169 at %s", [datetime()]);
        </query>

        <query>
            <![CDATA[
                CALL apoc.periodic.iterate(
                     "
                        WITH 'snowflake_orchard' AS url_alias,
                        '
                            SELECT * FROM facts.qa.jsonified_track_mapping ORDER BY ACR_ID ASC LIMIT 100000 OFFSET 5500000
                        '
                        AS sql
                        CALL apoc.load.jdbc(url_alias, sql)
                        YIELD row
                        return apoc.convert.fromJsonMap(row.NODE) AS row;
                    ",
                    '
                        WITH *, "database/distro-4707" AS by
                        MERGE (acrId:ACRID { id: row.acr_id })
                            ON CREATE SET
                                acrId.createdAt = datetime(),
                                acrId.createdBy = by,
                                acrId.lastModifiedAt = datetime(),
                                acrId.lastModifiedBy = by
                        MERGE (acrId)<-[acrIdToOsr:CONTAINS_FINGERPRINT]-(osr:OrchardSoundRecording)
                            ON CREATE SET
                                osr.id = apoc.create.uuid(),
                                osr.createdAt = datetime(),
                                osr.createdBy = by,
                                osr.lastModifiedAt = datetime(),
                                osr.lastModifiedBy = by,
                                acrIdToOsr.createdAt = datetime(),
                                acrIdToOsr.createdBy = by,
                                acrIdToOsr.lastModifiedAt = datetime(),
                                acrIdToOsr.lastModifiedBy = by
                        WITH *
                        UNWIND row.assets AS source_asset
                        MERGE (asset:OrchardAsset {
                            filename: source_asset.filename,
                            extension: "mp3",
                            source: "direct-delivery-db"
                        })
                            ON CREATE SET
                                asset.id = apoc.create.uuid(),
                                asset.createdAt = datetime(),
                                asset.createdBy = by,
                                asset.lastModifiedAt = datetime(),
                                asset.lastModifiedBy = by
                        MERGE (asset)-[assetToAcrId:FINGERPRINTED_AS]->(acrId)
                            ON CREATE SET
                                assetToAcrId.createdAt = datetime(),
                                assetToAcrId.createdBy = by
                            SET
                                assetToAcrId.lastModifiedAt = datetime(),
                                assetToAcrId.lastModifiedBy = by
                        WITH *
                        OPTIONAL MATCH (asset)-[assetToOldAcrId:FINGERPRINTED_AS]->(oldAcrId:ACRID)
                            WHERE oldAcrId <> acrId
                        FOREACH (hasOldAcrId IN CASE WHEN oldAcrId IS NOT NULL THEN [1] ELSE [] END |
                            CREATE (asset)-[deletedRelationship:DELETED_FINGERPRINTED_AS]->(oldAcrId)
                            SET
                                deletedRelationship += assetToOldAcrId,
                                deletedRelationship.deletedAt = datetime(),
                                deletedRelationship.deletedBy = by
                            DELETE assetToOldAcrId
                        )
                        WITH DISTINCT source_asset, by, asset
                        OPTIONAL MATCH (track:Track { id: toInteger(source_asset.tuid) })
                        CALL apoc.util.validate(track IS NULL, "Could not find the track %s", [source_asset.tuid])
                        MERGE (track)-[trackHasAsset:HAS_ASSET]->(asset)
                            ON CREATE SET
                                trackHasAsset.createdAt = datetime(),
                                trackHasAsset.createdBy = by,
                                trackHasAsset.lastModifiedAt = datetime(),
                                trackHasAsset.lastModifiedBy = by
                    ',
                    {
                        batchSize: 1000
                    }
                )
                YIELD failedOperations, errorMessages, failedBatches, batch
                CALL apoc.util.validate(failedOperations > 0, "At least one sub-operation failed: %s", [reduce(all_errors = "", error IN keys(errorMessages) | all_errors + ", " + error)])
                CALL apoc.util.validate(failedBatches > 0, "At least one batch failed: %s", [reduce(all_errors = "", error IN keys(batch.errors) | all_errors + ", " + error)])
                RETURN 0
            ]]>
        </query>
        <query>
            CALL apoc.log.info("Finished acr_cloud data ingest part 56 of 169 at %s", [datetime()]);
        </query>

        <query>
            <![CDATA[
                CALL apoc.periodic.iterate(
                     "
                        WITH 'snowflake_orchard' AS url_alias,
                        '
                            SELECT * FROM facts.qa.jsonified_track_mapping ORDER BY ACR_ID ASC LIMIT 100000 OFFSET 5600000
                        '
                        AS sql
                        CALL apoc.load.jdbc(url_alias, sql)
                        YIELD row
                        return apoc.convert.fromJsonMap(row.NODE) AS row;
                    ",
                    '
                        WITH *, "database/distro-4707" AS by
                        MERGE (acrId:ACRID { id: row.acr_id })
                            ON CREATE SET
                                acrId.createdAt = datetime(),
                                acrId.createdBy = by,
                                acrId.lastModifiedAt = datetime(),
                                acrId.lastModifiedBy = by
                        MERGE (acrId)<-[acrIdToOsr:CONTAINS_FINGERPRINT]-(osr:OrchardSoundRecording)
                            ON CREATE SET
                                osr.id = apoc.create.uuid(),
                                osr.createdAt = datetime(),
                                osr.createdBy = by,
                                osr.lastModifiedAt = datetime(),
                                osr.lastModifiedBy = by,
                                acrIdToOsr.createdAt = datetime(),
                                acrIdToOsr.createdBy = by,
                                acrIdToOsr.lastModifiedAt = datetime(),
                                acrIdToOsr.lastModifiedBy = by
                        WITH *
                        UNWIND row.assets AS source_asset
                        MERGE (asset:OrchardAsset {
                            filename: source_asset.filename,
                            extension: "mp3",
                            source: "direct-delivery-db"
                        })
                            ON CREATE SET
                                asset.id = apoc.create.uuid(),
                                asset.createdAt = datetime(),
                                asset.createdBy = by,
                                asset.lastModifiedAt = datetime(),
                                asset.lastModifiedBy = by
                        MERGE (asset)-[assetToAcrId:FINGERPRINTED_AS]->(acrId)
                            ON CREATE SET
                                assetToAcrId.createdAt = datetime(),
                                assetToAcrId.createdBy = by
                            SET
                                assetToAcrId.lastModifiedAt = datetime(),
                                assetToAcrId.lastModifiedBy = by
                        WITH *
                        OPTIONAL MATCH (asset)-[assetToOldAcrId:FINGERPRINTED_AS]->(oldAcrId:ACRID)
                            WHERE oldAcrId <> acrId
                        FOREACH (hasOldAcrId IN CASE WHEN oldAcrId IS NOT NULL THEN [1] ELSE [] END |
                            CREATE (asset)-[deletedRelationship:DELETED_FINGERPRINTED_AS]->(oldAcrId)
                            SET
                                deletedRelationship += assetToOldAcrId,
                                deletedRelationship.deletedAt = datetime(),
                                deletedRelationship.deletedBy = by
                            DELETE assetToOldAcrId
                        )
                        WITH DISTINCT source_asset, by, asset
                        OPTIONAL MATCH (track:Track { id: toInteger(source_asset.tuid) })
                        CALL apoc.util.validate(track IS NULL, "Could not find the track %s", [source_asset.tuid])
                        MERGE (track)-[trackHasAsset:HAS_ASSET]->(asset)
                            ON CREATE SET
                                trackHasAsset.createdAt = datetime(),
                                trackHasAsset.createdBy = by,
                                trackHasAsset.lastModifiedAt = datetime(),
                                trackHasAsset.lastModifiedBy = by
                    ',
                    {
                        batchSize: 1000
                    }
                )
                YIELD failedOperations, errorMessages, failedBatches, batch
                CALL apoc.util.validate(failedOperations > 0, "At least one sub-operation failed: %s", [reduce(all_errors = "", error IN keys(errorMessages) | all_errors + ", " + error)])
                CALL apoc.util.validate(failedBatches > 0, "At least one batch failed: %s", [reduce(all_errors = "", error IN keys(batch.errors) | all_errors + ", " + error)])
                RETURN 0
            ]]>
        </query>
        <query>
            CALL apoc.log.info("Finished acr_cloud data ingest part 57 of 169 at %s", [datetime()]);
        </query>

        <query>
            <![CDATA[
                CALL apoc.periodic.iterate(
                     "
                        WITH 'snowflake_orchard' AS url_alias,
                        '
                            SELECT * FROM facts.qa.jsonified_track_mapping ORDER BY ACR_ID ASC LIMIT 100000 OFFSET 5700000
                        '
                        AS sql
                        CALL apoc.load.jdbc(url_alias, sql)
                        YIELD row
                        return apoc.convert.fromJsonMap(row.NODE) AS row;
                    ",
                    '
                        WITH *, "database/distro-4707" AS by
                        MERGE (acrId:ACRID { id: row.acr_id })
                            ON CREATE SET
                                acrId.createdAt = datetime(),
                                acrId.createdBy = by,
                                acrId.lastModifiedAt = datetime(),
                                acrId.lastModifiedBy = by
                        MERGE (acrId)<-[acrIdToOsr:CONTAINS_FINGERPRINT]-(osr:OrchardSoundRecording)
                            ON CREATE SET
                                osr.id = apoc.create.uuid(),
                                osr.createdAt = datetime(),
                                osr.createdBy = by,
                                osr.lastModifiedAt = datetime(),
                                osr.lastModifiedBy = by,
                                acrIdToOsr.createdAt = datetime(),
                                acrIdToOsr.createdBy = by,
                                acrIdToOsr.lastModifiedAt = datetime(),
                                acrIdToOsr.lastModifiedBy = by
                        WITH *
                        UNWIND row.assets AS source_asset
                        MERGE (asset:OrchardAsset {
                            filename: source_asset.filename,
                            extension: "mp3",
                            source: "direct-delivery-db"
                        })
                            ON CREATE SET
                                asset.id = apoc.create.uuid(),
                                asset.createdAt = datetime(),
                                asset.createdBy = by,
                                asset.lastModifiedAt = datetime(),
                                asset.lastModifiedBy = by
                        MERGE (asset)-[assetToAcrId:FINGERPRINTED_AS]->(acrId)
                            ON CREATE SET
                                assetToAcrId.createdAt = datetime(),
                                assetToAcrId.createdBy = by
                            SET
                                assetToAcrId.lastModifiedAt = datetime(),
                                assetToAcrId.lastModifiedBy = by
                        WITH *
                        OPTIONAL MATCH (asset)-[assetToOldAcrId:FINGERPRINTED_AS]->(oldAcrId:ACRID)
                            WHERE oldAcrId <> acrId
                        FOREACH (hasOldAcrId IN CASE WHEN oldAcrId IS NOT NULL THEN [1] ELSE [] END |
                            CREATE (asset)-[deletedRelationship:DELETED_FINGERPRINTED_AS]->(oldAcrId)
                            SET
                                deletedRelationship += assetToOldAcrId,
                                deletedRelationship.deletedAt = datetime(),
                                deletedRelationship.deletedBy = by
                            DELETE assetToOldAcrId
                        )
                        WITH DISTINCT source_asset, by, asset
                        OPTIONAL MATCH (track:Track { id: toInteger(source_asset.tuid) })
                        CALL apoc.util.validate(track IS NULL, "Could not find the track %s", [source_asset.tuid])
                        MERGE (track)-[trackHasAsset:HAS_ASSET]->(asset)
                            ON CREATE SET
                                trackHasAsset.createdAt = datetime(),
                                trackHasAsset.createdBy = by,
                                trackHasAsset.lastModifiedAt = datetime(),
                                trackHasAsset.lastModifiedBy = by
                    ',
                    {
                        batchSize: 1000
                    }
                )
                YIELD failedOperations, errorMessages, failedBatches, batch
                CALL apoc.util.validate(failedOperations > 0, "At least one sub-operation failed: %s", [reduce(all_errors = "", error IN keys(errorMessages) | all_errors + ", " + error)])
                CALL apoc.util.validate(failedBatches > 0, "At least one batch failed: %s", [reduce(all_errors = "", error IN keys(batch.errors) | all_errors + ", " + error)])
                RETURN 0
            ]]>
        </query>
        <query>
            CALL apoc.log.info("Finished acr_cloud data ingest part 58 of 169 at %s", [datetime()]);
        </query>

        <query>
            <![CDATA[
                CALL apoc.periodic.iterate(
                     "
                        WITH 'snowflake_orchard' AS url_alias,
                        '
                            SELECT * FROM facts.qa.jsonified_track_mapping ORDER BY ACR_ID ASC LIMIT 100000 OFFSET 5800000
                        '
                        AS sql
                        CALL apoc.load.jdbc(url_alias, sql)
                        YIELD row
                        return apoc.convert.fromJsonMap(row.NODE) AS row;
                    ",
                    '
                        WITH *, "database/distro-4707" AS by
                        MERGE (acrId:ACRID { id: row.acr_id })
                            ON CREATE SET
                                acrId.createdAt = datetime(),
                                acrId.createdBy = by,
                                acrId.lastModifiedAt = datetime(),
                                acrId.lastModifiedBy = by
                        MERGE (acrId)<-[acrIdToOsr:CONTAINS_FINGERPRINT]-(osr:OrchardSoundRecording)
                            ON CREATE SET
                                osr.id = apoc.create.uuid(),
                                osr.createdAt = datetime(),
                                osr.createdBy = by,
                                osr.lastModifiedAt = datetime(),
                                osr.lastModifiedBy = by,
                                acrIdToOsr.createdAt = datetime(),
                                acrIdToOsr.createdBy = by,
                                acrIdToOsr.lastModifiedAt = datetime(),
                                acrIdToOsr.lastModifiedBy = by
                        WITH *
                        UNWIND row.assets AS source_asset
                        MERGE (asset:OrchardAsset {
                            filename: source_asset.filename,
                            extension: "mp3",
                            source: "direct-delivery-db"
                        })
                            ON CREATE SET
                                asset.id = apoc.create.uuid(),
                                asset.createdAt = datetime(),
                                asset.createdBy = by,
                                asset.lastModifiedAt = datetime(),
                                asset.lastModifiedBy = by
                        MERGE (asset)-[assetToAcrId:FINGERPRINTED_AS]->(acrId)
                            ON CREATE SET
                                assetToAcrId.createdAt = datetime(),
                                assetToAcrId.createdBy = by
                            SET
                                assetToAcrId.lastModifiedAt = datetime(),
                                assetToAcrId.lastModifiedBy = by
                        WITH *
                        OPTIONAL MATCH (asset)-[assetToOldAcrId:FINGERPRINTED_AS]->(oldAcrId:ACRID)
                            WHERE oldAcrId <> acrId
                        FOREACH (hasOldAcrId IN CASE WHEN oldAcrId IS NOT NULL THEN [1] ELSE [] END |
                            CREATE (asset)-[deletedRelationship:DELETED_FINGERPRINTED_AS]->(oldAcrId)
                            SET
                                deletedRelationship += assetToOldAcrId,
                                deletedRelationship.deletedAt = datetime(),
                                deletedRelationship.deletedBy = by
                            DELETE assetToOldAcrId
                        )
                        WITH DISTINCT source_asset, by, asset
                        OPTIONAL MATCH (track:Track { id: toInteger(source_asset.tuid) })
                        CALL apoc.util.validate(track IS NULL, "Could not find the track %s", [source_asset.tuid])
                        MERGE (track)-[trackHasAsset:HAS_ASSET]->(asset)
                            ON CREATE SET
                                trackHasAsset.createdAt = datetime(),
                                trackHasAsset.createdBy = by,
                                trackHasAsset.lastModifiedAt = datetime(),
                                trackHasAsset.lastModifiedBy = by
                    ',
                    {
                        batchSize: 1000
                    }
                )
                YIELD failedOperations, errorMessages, failedBatches, batch
                CALL apoc.util.validate(failedOperations > 0, "At least one sub-operation failed: %s", [reduce(all_errors = "", error IN keys(errorMessages) | all_errors + ", " + error)])
                CALL apoc.util.validate(failedBatches > 0, "At least one batch failed: %s", [reduce(all_errors = "", error IN keys(batch.errors) | all_errors + ", " + error)])
                RETURN 0
            ]]>
        </query>
        <query>
            CALL apoc.log.info("Finished acr_cloud data ingest part 59 of 169 at %s", [datetime()]);
        </query>

        <query>
            <![CDATA[
                CALL apoc.periodic.iterate(
                     "
                        WITH 'snowflake_orchard' AS url_alias,
                        '
                            SELECT * FROM facts.qa.jsonified_track_mapping ORDER BY ACR_ID ASC LIMIT 100000 OFFSET 5900000
                        '
                        AS sql
                        CALL apoc.load.jdbc(url_alias, sql)
                        YIELD row
                        return apoc.convert.fromJsonMap(row.NODE) AS row;
                    ",
                    '
                        WITH *, "database/distro-4707" AS by
                        MERGE (acrId:ACRID { id: row.acr_id })
                            ON CREATE SET
                                acrId.createdAt = datetime(),
                                acrId.createdBy = by,
                                acrId.lastModifiedAt = datetime(),
                                acrId.lastModifiedBy = by
                        MERGE (acrId)<-[acrIdToOsr:CONTAINS_FINGERPRINT]-(osr:OrchardSoundRecording)
                            ON CREATE SET
                                osr.id = apoc.create.uuid(),
                                osr.createdAt = datetime(),
                                osr.createdBy = by,
                                osr.lastModifiedAt = datetime(),
                                osr.lastModifiedBy = by,
                                acrIdToOsr.createdAt = datetime(),
                                acrIdToOsr.createdBy = by,
                                acrIdToOsr.lastModifiedAt = datetime(),
                                acrIdToOsr.lastModifiedBy = by
                        WITH *
                        UNWIND row.assets AS source_asset
                        MERGE (asset:OrchardAsset {
                            filename: source_asset.filename,
                            extension: "mp3",
                            source: "direct-delivery-db"
                        })
                            ON CREATE SET
                                asset.id = apoc.create.uuid(),
                                asset.createdAt = datetime(),
                                asset.createdBy = by,
                                asset.lastModifiedAt = datetime(),
                                asset.lastModifiedBy = by
                        MERGE (asset)-[assetToAcrId:FINGERPRINTED_AS]->(acrId)
                            ON CREATE SET
                                assetToAcrId.createdAt = datetime(),
                                assetToAcrId.createdBy = by
                            SET
                                assetToAcrId.lastModifiedAt = datetime(),
                                assetToAcrId.lastModifiedBy = by
                        WITH *
                        OPTIONAL MATCH (asset)-[assetToOldAcrId:FINGERPRINTED_AS]->(oldAcrId:ACRID)
                            WHERE oldAcrId <> acrId
                        FOREACH (hasOldAcrId IN CASE WHEN oldAcrId IS NOT NULL THEN [1] ELSE [] END |
                            CREATE (asset)-[deletedRelationship:DELETED_FINGERPRINTED_AS]->(oldAcrId)
                            SET
                                deletedRelationship += assetToOldAcrId,
                                deletedRelationship.deletedAt = datetime(),
                                deletedRelationship.deletedBy = by
                            DELETE assetToOldAcrId
                        )
                        WITH DISTINCT source_asset, by, asset
                        OPTIONAL MATCH (track:Track { id: toInteger(source_asset.tuid) })
                        CALL apoc.util.validate(track IS NULL, "Could not find the track %s", [source_asset.tuid])
                        MERGE (track)-[trackHasAsset:HAS_ASSET]->(asset)
                            ON CREATE SET
                                trackHasAsset.createdAt = datetime(),
                                trackHasAsset.createdBy = by,
                                trackHasAsset.lastModifiedAt = datetime(),
                                trackHasAsset.lastModifiedBy = by
                    ',
                    {
                        batchSize: 1000
                    }
                )
                YIELD failedOperations, errorMessages, failedBatches, batch
                CALL apoc.util.validate(failedOperations > 0, "At least one sub-operation failed: %s", [reduce(all_errors = "", error IN keys(errorMessages) | all_errors + ", " + error)])
                CALL apoc.util.validate(failedBatches > 0, "At least one batch failed: %s", [reduce(all_errors = "", error IN keys(batch.errors) | all_errors + ", " + error)])
                RETURN 0
            ]]>
        </query>
        <query>
            CALL apoc.log.info("Finished acr_cloud data ingest part 60 of 169 at %s", [datetime()]);
        </query>

        <query>
            <![CDATA[
                CALL apoc.periodic.iterate(
                     "
                        WITH 'snowflake_orchard' AS url_alias,
                        '
                            SELECT * FROM facts.qa.jsonified_track_mapping ORDER BY ACR_ID ASC LIMIT 100000 OFFSET 6000000
                        '
                        AS sql
                        CALL apoc.load.jdbc(url_alias, sql)
                        YIELD row
                        return apoc.convert.fromJsonMap(row.NODE) AS row;
                    ",
                    '
                        WITH *, "database/distro-4707" AS by
                        MERGE (acrId:ACRID { id: row.acr_id })
                            ON CREATE SET
                                acrId.createdAt = datetime(),
                                acrId.createdBy = by,
                                acrId.lastModifiedAt = datetime(),
                                acrId.lastModifiedBy = by
                        MERGE (acrId)<-[acrIdToOsr:CONTAINS_FINGERPRINT]-(osr:OrchardSoundRecording)
                            ON CREATE SET
                                osr.id = apoc.create.uuid(),
                                osr.createdAt = datetime(),
                                osr.createdBy = by,
                                osr.lastModifiedAt = datetime(),
                                osr.lastModifiedBy = by,
                                acrIdToOsr.createdAt = datetime(),
                                acrIdToOsr.createdBy = by,
                                acrIdToOsr.lastModifiedAt = datetime(),
                                acrIdToOsr.lastModifiedBy = by
                        WITH *
                        UNWIND row.assets AS source_asset
                        MERGE (asset:OrchardAsset {
                            filename: source_asset.filename,
                            extension: "mp3",
                            source: "direct-delivery-db"
                        })
                            ON CREATE SET
                                asset.id = apoc.create.uuid(),
                                asset.createdAt = datetime(),
                                asset.createdBy = by,
                                asset.lastModifiedAt = datetime(),
                                asset.lastModifiedBy = by
                        MERGE (asset)-[assetToAcrId:FINGERPRINTED_AS]->(acrId)
                            ON CREATE SET
                                assetToAcrId.createdAt = datetime(),
                                assetToAcrId.createdBy = by
                            SET
                                assetToAcrId.lastModifiedAt = datetime(),
                                assetToAcrId.lastModifiedBy = by
                        WITH *
                        OPTIONAL MATCH (asset)-[assetToOldAcrId:FINGERPRINTED_AS]->(oldAcrId:ACRID)
                            WHERE oldAcrId <> acrId
                        FOREACH (hasOldAcrId IN CASE WHEN oldAcrId IS NOT NULL THEN [1] ELSE [] END |
                            CREATE (asset)-[deletedRelationship:DELETED_FINGERPRINTED_AS]->(oldAcrId)
                            SET
                                deletedRelationship += assetToOldAcrId,
                                deletedRelationship.deletedAt = datetime(),
                                deletedRelationship.deletedBy = by
                            DELETE assetToOldAcrId
                        )
                        WITH DISTINCT source_asset, by, asset
                        OPTIONAL MATCH (track:Track { id: toInteger(source_asset.tuid) })
                        CALL apoc.util.validate(track IS NULL, "Could not find the track %s", [source_asset.tuid])
                        MERGE (track)-[trackHasAsset:HAS_ASSET]->(asset)
                            ON CREATE SET
                                trackHasAsset.createdAt = datetime(),
                                trackHasAsset.createdBy = by,
                                trackHasAsset.lastModifiedAt = datetime(),
                                trackHasAsset.lastModifiedBy = by
                    ',
                    {
                        batchSize: 1000
                    }
                )
                YIELD failedOperations, errorMessages, failedBatches, batch
                CALL apoc.util.validate(failedOperations > 0, "At least one sub-operation failed: %s", [reduce(all_errors = "", error IN keys(errorMessages) | all_errors + ", " + error)])
                CALL apoc.util.validate(failedBatches > 0, "At least one batch failed: %s", [reduce(all_errors = "", error IN keys(batch.errors) | all_errors + ", " + error)])
                RETURN 0
            ]]>
        </query>
        <query>
            CALL apoc.log.info("Finished acr_cloud data ingest part 61 of 169 at %s", [datetime()]);
        </query>

        <query>
            <![CDATA[
                CALL apoc.periodic.iterate(
                     "
                        WITH 'snowflake_orchard' AS url_alias,
                        '
                            SELECT * FROM facts.qa.jsonified_track_mapping ORDER BY ACR_ID ASC LIMIT 100000 OFFSET 6100000
                        '
                        AS sql
                        CALL apoc.load.jdbc(url_alias, sql)
                        YIELD row
                        return apoc.convert.fromJsonMap(row.NODE) AS row;
                    ",
                    '
                        WITH *, "database/distro-4707" AS by
                        MERGE (acrId:ACRID { id: row.acr_id })
                            ON CREATE SET
                                acrId.createdAt = datetime(),
                                acrId.createdBy = by,
                                acrId.lastModifiedAt = datetime(),
                                acrId.lastModifiedBy = by
                        MERGE (acrId)<-[acrIdToOsr:CONTAINS_FINGERPRINT]-(osr:OrchardSoundRecording)
                            ON CREATE SET
                                osr.id = apoc.create.uuid(),
                                osr.createdAt = datetime(),
                                osr.createdBy = by,
                                osr.lastModifiedAt = datetime(),
                                osr.lastModifiedBy = by,
                                acrIdToOsr.createdAt = datetime(),
                                acrIdToOsr.createdBy = by,
                                acrIdToOsr.lastModifiedAt = datetime(),
                                acrIdToOsr.lastModifiedBy = by
                        WITH *
                        UNWIND row.assets AS source_asset
                        MERGE (asset:OrchardAsset {
                            filename: source_asset.filename,
                            extension: "mp3",
                            source: "direct-delivery-db"
                        })
                            ON CREATE SET
                                asset.id = apoc.create.uuid(),
                                asset.createdAt = datetime(),
                                asset.createdBy = by,
                                asset.lastModifiedAt = datetime(),
                                asset.lastModifiedBy = by
                        MERGE (asset)-[assetToAcrId:FINGERPRINTED_AS]->(acrId)
                            ON CREATE SET
                                assetToAcrId.createdAt = datetime(),
                                assetToAcrId.createdBy = by
                            SET
                                assetToAcrId.lastModifiedAt = datetime(),
                                assetToAcrId.lastModifiedBy = by
                        WITH *
                        OPTIONAL MATCH (asset)-[assetToOldAcrId:FINGERPRINTED_AS]->(oldAcrId:ACRID)
                            WHERE oldAcrId <> acrId
                        FOREACH (hasOldAcrId IN CASE WHEN oldAcrId IS NOT NULL THEN [1] ELSE [] END |
                            CREATE (asset)-[deletedRelationship:DELETED_FINGERPRINTED_AS]->(oldAcrId)
                            SET
                                deletedRelationship += assetToOldAcrId,
                                deletedRelationship.deletedAt = datetime(),
                                deletedRelationship.deletedBy = by
                            DELETE assetToOldAcrId
                        )
                        WITH DISTINCT source_asset, by, asset
                        OPTIONAL MATCH (track:Track { id: toInteger(source_asset.tuid) })
                        CALL apoc.util.validate(track IS NULL, "Could not find the track %s", [source_asset.tuid])
                        MERGE (track)-[trackHasAsset:HAS_ASSET]->(asset)
                            ON CREATE SET
                                trackHasAsset.createdAt = datetime(),
                                trackHasAsset.createdBy = by,
                                trackHasAsset.lastModifiedAt = datetime(),
                                trackHasAsset.lastModifiedBy = by
                    ',
                    {
                        batchSize: 1000
                    }
                )
                YIELD failedOperations, errorMessages, failedBatches, batch
                CALL apoc.util.validate(failedOperations > 0, "At least one sub-operation failed: %s", [reduce(all_errors = "", error IN keys(errorMessages) | all_errors + ", " + error)])
                CALL apoc.util.validate(failedBatches > 0, "At least one batch failed: %s", [reduce(all_errors = "", error IN keys(batch.errors) | all_errors + ", " + error)])
                RETURN 0
            ]]>
        </query>
        <query>
            CALL apoc.log.info("Finished acr_cloud data ingest part 62 of 169 at %s", [datetime()]);
        </query>

        <query>
            <![CDATA[
                CALL apoc.periodic.iterate(
                     "
                        WITH 'snowflake_orchard' AS url_alias,
                        '
                            SELECT * FROM facts.qa.jsonified_track_mapping ORDER BY ACR_ID ASC LIMIT 100000 OFFSET 6200000
                        '
                        AS sql
                        CALL apoc.load.jdbc(url_alias, sql)
                        YIELD row
                        return apoc.convert.fromJsonMap(row.NODE) AS row;
                    ",
                    '
                        WITH *, "database/distro-4707" AS by
                        MERGE (acrId:ACRID { id: row.acr_id })
                            ON CREATE SET
                                acrId.createdAt = datetime(),
                                acrId.createdBy = by,
                                acrId.lastModifiedAt = datetime(),
                                acrId.lastModifiedBy = by
                        MERGE (acrId)<-[acrIdToOsr:CONTAINS_FINGERPRINT]-(osr:OrchardSoundRecording)
                            ON CREATE SET
                                osr.id = apoc.create.uuid(),
                                osr.createdAt = datetime(),
                                osr.createdBy = by,
                                osr.lastModifiedAt = datetime(),
                                osr.lastModifiedBy = by,
                                acrIdToOsr.createdAt = datetime(),
                                acrIdToOsr.createdBy = by,
                                acrIdToOsr.lastModifiedAt = datetime(),
                                acrIdToOsr.lastModifiedBy = by
                        WITH *
                        UNWIND row.assets AS source_asset
                        MERGE (asset:OrchardAsset {
                            filename: source_asset.filename,
                            extension: "mp3",
                            source: "direct-delivery-db"
                        })
                            ON CREATE SET
                                asset.id = apoc.create.uuid(),
                                asset.createdAt = datetime(),
                                asset.createdBy = by,
                                asset.lastModifiedAt = datetime(),
                                asset.lastModifiedBy = by
                        MERGE (asset)-[assetToAcrId:FINGERPRINTED_AS]->(acrId)
                            ON CREATE SET
                                assetToAcrId.createdAt = datetime(),
                                assetToAcrId.createdBy = by
                            SET
                                assetToAcrId.lastModifiedAt = datetime(),
                                assetToAcrId.lastModifiedBy = by
                        WITH *
                        OPTIONAL MATCH (asset)-[assetToOldAcrId:FINGERPRINTED_AS]->(oldAcrId:ACRID)
                            WHERE oldAcrId <> acrId
                        FOREACH (hasOldAcrId IN CASE WHEN oldAcrId IS NOT NULL THEN [1] ELSE [] END |
                            CREATE (asset)-[deletedRelationship:DELETED_FINGERPRINTED_AS]->(oldAcrId)
                            SET
                                deletedRelationship += assetToOldAcrId,
                                deletedRelationship.deletedAt = datetime(),
                                deletedRelationship.deletedBy = by
                            DELETE assetToOldAcrId
                        )
                        WITH DISTINCT source_asset, by, asset
                        OPTIONAL MATCH (track:Track { id: toInteger(source_asset.tuid) })
                        CALL apoc.util.validate(track IS NULL, "Could not find the track %s", [source_asset.tuid])
                        MERGE (track)-[trackHasAsset:HAS_ASSET]->(asset)
                            ON CREATE SET
                                trackHasAsset.createdAt = datetime(),
                                trackHasAsset.createdBy = by,
                                trackHasAsset.lastModifiedAt = datetime(),
                                trackHasAsset.lastModifiedBy = by
                    ',
                    {
                        batchSize: 1000
                    }
                )
                YIELD failedOperations, errorMessages, failedBatches, batch
                CALL apoc.util.validate(failedOperations > 0, "At least one sub-operation failed: %s", [reduce(all_errors = "", error IN keys(errorMessages) | all_errors + ", " + error)])
                CALL apoc.util.validate(failedBatches > 0, "At least one batch failed: %s", [reduce(all_errors = "", error IN keys(batch.errors) | all_errors + ", " + error)])
                RETURN 0
            ]]>
        </query>
        <query>
            CALL apoc.log.info("Finished acr_cloud data ingest part 63 of 169 at %s", [datetime()]);
        </query>

        <query>
            <![CDATA[
                CALL apoc.periodic.iterate(
                     "
                        WITH 'snowflake_orchard' AS url_alias,
                        '
                            SELECT * FROM facts.qa.jsonified_track_mapping ORDER BY ACR_ID ASC LIMIT 100000 OFFSET 6300000
                        '
                        AS sql
                        CALL apoc.load.jdbc(url_alias, sql)
                        YIELD row
                        return apoc.convert.fromJsonMap(row.NODE) AS row;
                    ",
                    '
                        WITH *, "database/distro-4707" AS by
                        MERGE (acrId:ACRID { id: row.acr_id })
                            ON CREATE SET
                                acrId.createdAt = datetime(),
                                acrId.createdBy = by,
                                acrId.lastModifiedAt = datetime(),
                                acrId.lastModifiedBy = by
                        MERGE (acrId)<-[acrIdToOsr:CONTAINS_FINGERPRINT]-(osr:OrchardSoundRecording)
                            ON CREATE SET
                                osr.id = apoc.create.uuid(),
                                osr.createdAt = datetime(),
                                osr.createdBy = by,
                                osr.lastModifiedAt = datetime(),
                                osr.lastModifiedBy = by,
                                acrIdToOsr.createdAt = datetime(),
                                acrIdToOsr.createdBy = by,
                                acrIdToOsr.lastModifiedAt = datetime(),
                                acrIdToOsr.lastModifiedBy = by
                        WITH *
                        UNWIND row.assets AS source_asset
                        MERGE (asset:OrchardAsset {
                            filename: source_asset.filename,
                            extension: "mp3",
                            source: "direct-delivery-db"
                        })
                            ON CREATE SET
                                asset.id = apoc.create.uuid(),
                                asset.createdAt = datetime(),
                                asset.createdBy = by,
                                asset.lastModifiedAt = datetime(),
                                asset.lastModifiedBy = by
                        MERGE (asset)-[assetToAcrId:FINGERPRINTED_AS]->(acrId)
                            ON CREATE SET
                                assetToAcrId.createdAt = datetime(),
                                assetToAcrId.createdBy = by
                            SET
                                assetToAcrId.lastModifiedAt = datetime(),
                                assetToAcrId.lastModifiedBy = by
                        WITH *
                        OPTIONAL MATCH (asset)-[assetToOldAcrId:FINGERPRINTED_AS]->(oldAcrId:ACRID)
                            WHERE oldAcrId <> acrId
                        FOREACH (hasOldAcrId IN CASE WHEN oldAcrId IS NOT NULL THEN [1] ELSE [] END |
                            CREATE (asset)-[deletedRelationship:DELETED_FINGERPRINTED_AS]->(oldAcrId)
                            SET
                                deletedRelationship += assetToOldAcrId,
                                deletedRelationship.deletedAt = datetime(),
                                deletedRelationship.deletedBy = by
                            DELETE assetToOldAcrId
                        )
                        WITH DISTINCT source_asset, by, asset
                        OPTIONAL MATCH (track:Track { id: toInteger(source_asset.tuid) })
                        CALL apoc.util.validate(track IS NULL, "Could not find the track %s", [source_asset.tuid])
                        MERGE (track)-[trackHasAsset:HAS_ASSET]->(asset)
                            ON CREATE SET
                                trackHasAsset.createdAt = datetime(),
                                trackHasAsset.createdBy = by,
                                trackHasAsset.lastModifiedAt = datetime(),
                                trackHasAsset.lastModifiedBy = by
                    ',
                    {
                        batchSize: 1000
                    }
                )
                YIELD failedOperations, errorMessages, failedBatches, batch
                CALL apoc.util.validate(failedOperations > 0, "At least one sub-operation failed: %s", [reduce(all_errors = "", error IN keys(errorMessages) | all_errors + ", " + error)])
                CALL apoc.util.validate(failedBatches > 0, "At least one batch failed: %s", [reduce(all_errors = "", error IN keys(batch.errors) | all_errors + ", " + error)])
                RETURN 0
            ]]>
        </query>
        <query>
            CALL apoc.log.info("Finished acr_cloud data ingest part 64 of 169 at %s", [datetime()]);
        </query>

        <query>
            <![CDATA[
                CALL apoc.periodic.iterate(
                     "
                        WITH 'snowflake_orchard' AS url_alias,
                        '
                            SELECT * FROM facts.qa.jsonified_track_mapping ORDER BY ACR_ID ASC LIMIT 100000 OFFSET 6400000
                        '
                        AS sql
                        CALL apoc.load.jdbc(url_alias, sql)
                        YIELD row
                        return apoc.convert.fromJsonMap(row.NODE) AS row;
                    ",
                    '
                        WITH *, "database/distro-4707" AS by
                        MERGE (acrId:ACRID { id: row.acr_id })
                            ON CREATE SET
                                acrId.createdAt = datetime(),
                                acrId.createdBy = by,
                                acrId.lastModifiedAt = datetime(),
                                acrId.lastModifiedBy = by
                        MERGE (acrId)<-[acrIdToOsr:CONTAINS_FINGERPRINT]-(osr:OrchardSoundRecording)
                            ON CREATE SET
                                osr.id = apoc.create.uuid(),
                                osr.createdAt = datetime(),
                                osr.createdBy = by,
                                osr.lastModifiedAt = datetime(),
                                osr.lastModifiedBy = by,
                                acrIdToOsr.createdAt = datetime(),
                                acrIdToOsr.createdBy = by,
                                acrIdToOsr.lastModifiedAt = datetime(),
                                acrIdToOsr.lastModifiedBy = by
                        WITH *
                        UNWIND row.assets AS source_asset
                        MERGE (asset:OrchardAsset {
                            filename: source_asset.filename,
                            extension: "mp3",
                            source: "direct-delivery-db"
                        })
                            ON CREATE SET
                                asset.id = apoc.create.uuid(),
                                asset.createdAt = datetime(),
                                asset.createdBy = by,
                                asset.lastModifiedAt = datetime(),
                                asset.lastModifiedBy = by
                        MERGE (asset)-[assetToAcrId:FINGERPRINTED_AS]->(acrId)
                            ON CREATE SET
                                assetToAcrId.createdAt = datetime(),
                                assetToAcrId.createdBy = by
                            SET
                                assetToAcrId.lastModifiedAt = datetime(),
                                assetToAcrId.lastModifiedBy = by
                        WITH *
                        OPTIONAL MATCH (asset)-[assetToOldAcrId:FINGERPRINTED_AS]->(oldAcrId:ACRID)
                            WHERE oldAcrId <> acrId
                        FOREACH (hasOldAcrId IN CASE WHEN oldAcrId IS NOT NULL THEN [1] ELSE [] END |
                            CREATE (asset)-[deletedRelationship:DELETED_FINGERPRINTED_AS]->(oldAcrId)
                            SET
                                deletedRelationship += assetToOldAcrId,
                                deletedRelationship.deletedAt = datetime(),
                                deletedRelationship.deletedBy = by
                            DELETE assetToOldAcrId
                        )
                        WITH DISTINCT source_asset, by, asset
                        OPTIONAL MATCH (track:Track { id: toInteger(source_asset.tuid) })
                        CALL apoc.util.validate(track IS NULL, "Could not find the track %s", [source_asset.tuid])
                        MERGE (track)-[trackHasAsset:HAS_ASSET]->(asset)
                            ON CREATE SET
                                trackHasAsset.createdAt = datetime(),
                                trackHasAsset.createdBy = by,
                                trackHasAsset.lastModifiedAt = datetime(),
                                trackHasAsset.lastModifiedBy = by
                    ',
                    {
                        batchSize: 1000
                    }
                )
                YIELD failedOperations, errorMessages, failedBatches, batch
                CALL apoc.util.validate(failedOperations > 0, "At least one sub-operation failed: %s", [reduce(all_errors = "", error IN keys(errorMessages) | all_errors + ", " + error)])
                CALL apoc.util.validate(failedBatches > 0, "At least one batch failed: %s", [reduce(all_errors = "", error IN keys(batch.errors) | all_errors + ", " + error)])
                RETURN 0
            ]]>
        </query>
        <query>
            CALL apoc.log.info("Finished acr_cloud data ingest part 65 of 169 at %s", [datetime()]);
        </query>

        <query>
            <![CDATA[
                CALL apoc.periodic.iterate(
                     "
                        WITH 'snowflake_orchard' AS url_alias,
                        '
                            SELECT * FROM facts.qa.jsonified_track_mapping ORDER BY ACR_ID ASC LIMIT 100000 OFFSET 6500000
                        '
                        AS sql
                        CALL apoc.load.jdbc(url_alias, sql)
                        YIELD row
                        return apoc.convert.fromJsonMap(row.NODE) AS row;
                    ",
                    '
                        WITH *, "database/distro-4707" AS by
                        MERGE (acrId:ACRID { id: row.acr_id })
                            ON CREATE SET
                                acrId.createdAt = datetime(),
                                acrId.createdBy = by,
                                acrId.lastModifiedAt = datetime(),
                                acrId.lastModifiedBy = by
                        MERGE (acrId)<-[acrIdToOsr:CONTAINS_FINGERPRINT]-(osr:OrchardSoundRecording)
                            ON CREATE SET
                                osr.id = apoc.create.uuid(),
                                osr.createdAt = datetime(),
                                osr.createdBy = by,
                                osr.lastModifiedAt = datetime(),
                                osr.lastModifiedBy = by,
                                acrIdToOsr.createdAt = datetime(),
                                acrIdToOsr.createdBy = by,
                                acrIdToOsr.lastModifiedAt = datetime(),
                                acrIdToOsr.lastModifiedBy = by
                        WITH *
                        UNWIND row.assets AS source_asset
                        MERGE (asset:OrchardAsset {
                            filename: source_asset.filename,
                            extension: "mp3",
                            source: "direct-delivery-db"
                        })
                            ON CREATE SET
                                asset.id = apoc.create.uuid(),
                                asset.createdAt = datetime(),
                                asset.createdBy = by,
                                asset.lastModifiedAt = datetime(),
                                asset.lastModifiedBy = by
                        MERGE (asset)-[assetToAcrId:FINGERPRINTED_AS]->(acrId)
                            ON CREATE SET
                                assetToAcrId.createdAt = datetime(),
                                assetToAcrId.createdBy = by
                            SET
                                assetToAcrId.lastModifiedAt = datetime(),
                                assetToAcrId.lastModifiedBy = by
                        WITH *
                        OPTIONAL MATCH (asset)-[assetToOldAcrId:FINGERPRINTED_AS]->(oldAcrId:ACRID)
                            WHERE oldAcrId <> acrId
                        FOREACH (hasOldAcrId IN CASE WHEN oldAcrId IS NOT NULL THEN [1] ELSE [] END |
                            CREATE (asset)-[deletedRelationship:DELETED_FINGERPRINTED_AS]->(oldAcrId)
                            SET
                                deletedRelationship += assetToOldAcrId,
                                deletedRelationship.deletedAt = datetime(),
                                deletedRelationship.deletedBy = by
                            DELETE assetToOldAcrId
                        )
                        WITH DISTINCT source_asset, by, asset
                        OPTIONAL MATCH (track:Track { id: toInteger(source_asset.tuid) })
                        CALL apoc.util.validate(track IS NULL, "Could not find the track %s", [source_asset.tuid])
                        MERGE (track)-[trackHasAsset:HAS_ASSET]->(asset)
                            ON CREATE SET
                                trackHasAsset.createdAt = datetime(),
                                trackHasAsset.createdBy = by,
                                trackHasAsset.lastModifiedAt = datetime(),
                                trackHasAsset.lastModifiedBy = by
                    ',
                    {
                        batchSize: 1000
                    }
                )
                YIELD failedOperations, errorMessages, failedBatches, batch
                CALL apoc.util.validate(failedOperations > 0, "At least one sub-operation failed: %s", [reduce(all_errors = "", error IN keys(errorMessages) | all_errors + ", " + error)])
                CALL apoc.util.validate(failedBatches > 0, "At least one batch failed: %s", [reduce(all_errors = "", error IN keys(batch.errors) | all_errors + ", " + error)])
                RETURN 0
            ]]>
        </query>
        <query>
            CALL apoc.log.info("Finished acr_cloud data ingest part 66 of 169 at %s", [datetime()]);
        </query>

        <query>
            <![CDATA[
                CALL apoc.periodic.iterate(
                     "
                        WITH 'snowflake_orchard' AS url_alias,
                        '
                            SELECT * FROM facts.qa.jsonified_track_mapping ORDER BY ACR_ID ASC LIMIT 100000 OFFSET 6600000
                        '
                        AS sql
                        CALL apoc.load.jdbc(url_alias, sql)
                        YIELD row
                        return apoc.convert.fromJsonMap(row.NODE) AS row;
                    ",
                    '
                        WITH *, "database/distro-4707" AS by
                        MERGE (acrId:ACRID { id: row.acr_id })
                            ON CREATE SET
                                acrId.createdAt = datetime(),
                                acrId.createdBy = by,
                                acrId.lastModifiedAt = datetime(),
                                acrId.lastModifiedBy = by
                        MERGE (acrId)<-[acrIdToOsr:CONTAINS_FINGERPRINT]-(osr:OrchardSoundRecording)
                            ON CREATE SET
                                osr.id = apoc.create.uuid(),
                                osr.createdAt = datetime(),
                                osr.createdBy = by,
                                osr.lastModifiedAt = datetime(),
                                osr.lastModifiedBy = by,
                                acrIdToOsr.createdAt = datetime(),
                                acrIdToOsr.createdBy = by,
                                acrIdToOsr.lastModifiedAt = datetime(),
                                acrIdToOsr.lastModifiedBy = by
                        WITH *
                        UNWIND row.assets AS source_asset
                        MERGE (asset:OrchardAsset {
                            filename: source_asset.filename,
                            extension: "mp3",
                            source: "direct-delivery-db"
                        })
                            ON CREATE SET
                                asset.id = apoc.create.uuid(),
                                asset.createdAt = datetime(),
                                asset.createdBy = by,
                                asset.lastModifiedAt = datetime(),
                                asset.lastModifiedBy = by
                        MERGE (asset)-[assetToAcrId:FINGERPRINTED_AS]->(acrId)
                            ON CREATE SET
                                assetToAcrId.createdAt = datetime(),
                                assetToAcrId.createdBy = by
                            SET
                                assetToAcrId.lastModifiedAt = datetime(),
                                assetToAcrId.lastModifiedBy = by
                        WITH *
                        OPTIONAL MATCH (asset)-[assetToOldAcrId:FINGERPRINTED_AS]->(oldAcrId:ACRID)
                            WHERE oldAcrId <> acrId
                        FOREACH (hasOldAcrId IN CASE WHEN oldAcrId IS NOT NULL THEN [1] ELSE [] END |
                            CREATE (asset)-[deletedRelationship:DELETED_FINGERPRINTED_AS]->(oldAcrId)
                            SET
                                deletedRelationship += assetToOldAcrId,
                                deletedRelationship.deletedAt = datetime(),
                                deletedRelationship.deletedBy = by
                            DELETE assetToOldAcrId
                        )
                        WITH DISTINCT source_asset, by, asset
                        OPTIONAL MATCH (track:Track { id: toInteger(source_asset.tuid) })
                        CALL apoc.util.validate(track IS NULL, "Could not find the track %s", [source_asset.tuid])
                        MERGE (track)-[trackHasAsset:HAS_ASSET]->(asset)
                            ON CREATE SET
                                trackHasAsset.createdAt = datetime(),
                                trackHasAsset.createdBy = by,
                                trackHasAsset.lastModifiedAt = datetime(),
                                trackHasAsset.lastModifiedBy = by
                    ',
                    {
                        batchSize: 1000
                    }
                )
                YIELD failedOperations, errorMessages, failedBatches, batch
                CALL apoc.util.validate(failedOperations > 0, "At least one sub-operation failed: %s", [reduce(all_errors = "", error IN keys(errorMessages) | all_errors + ", " + error)])
                CALL apoc.util.validate(failedBatches > 0, "At least one batch failed: %s", [reduce(all_errors = "", error IN keys(batch.errors) | all_errors + ", " + error)])
                RETURN 0
            ]]>
        </query>
        <query>
            CALL apoc.log.info("Finished acr_cloud data ingest part 67 of 169 at %s", [datetime()]);
        </query>

        <query>
            <![CDATA[
                CALL apoc.periodic.iterate(
                     "
                        WITH 'snowflake_orchard' AS url_alias,
                        '
                            SELECT * FROM facts.qa.jsonified_track_mapping ORDER BY ACR_ID ASC LIMIT 100000 OFFSET 6700000
                        '
                        AS sql
                        CALL apoc.load.jdbc(url_alias, sql)
                        YIELD row
                        return apoc.convert.fromJsonMap(row.NODE) AS row;
                    ",
                    '
                        WITH *, "database/distro-4707" AS by
                        MERGE (acrId:ACRID { id: row.acr_id })
                            ON CREATE SET
                                acrId.createdAt = datetime(),
                                acrId.createdBy = by,
                                acrId.lastModifiedAt = datetime(),
                                acrId.lastModifiedBy = by
                        MERGE (acrId)<-[acrIdToOsr:CONTAINS_FINGERPRINT]-(osr:OrchardSoundRecording)
                            ON CREATE SET
                                osr.id = apoc.create.uuid(),
                                osr.createdAt = datetime(),
                                osr.createdBy = by,
                                osr.lastModifiedAt = datetime(),
                                osr.lastModifiedBy = by,
                                acrIdToOsr.createdAt = datetime(),
                                acrIdToOsr.createdBy = by,
                                acrIdToOsr.lastModifiedAt = datetime(),
                                acrIdToOsr.lastModifiedBy = by
                        WITH *
                        UNWIND row.assets AS source_asset
                        MERGE (asset:OrchardAsset {
                            filename: source_asset.filename,
                            extension: "mp3",
                            source: "direct-delivery-db"
                        })
                            ON CREATE SET
                                asset.id = apoc.create.uuid(),
                                asset.createdAt = datetime(),
                                asset.createdBy = by,
                                asset.lastModifiedAt = datetime(),
                                asset.lastModifiedBy = by
                        MERGE (asset)-[assetToAcrId:FINGERPRINTED_AS]->(acrId)
                            ON CREATE SET
                                assetToAcrId.createdAt = datetime(),
                                assetToAcrId.createdBy = by
                            SET
                                assetToAcrId.lastModifiedAt = datetime(),
                                assetToAcrId.lastModifiedBy = by
                        WITH *
                        OPTIONAL MATCH (asset)-[assetToOldAcrId:FINGERPRINTED_AS]->(oldAcrId:ACRID)
                            WHERE oldAcrId <> acrId
                        FOREACH (hasOldAcrId IN CASE WHEN oldAcrId IS NOT NULL THEN [1] ELSE [] END |
                            CREATE (asset)-[deletedRelationship:DELETED_FINGERPRINTED_AS]->(oldAcrId)
                            SET
                                deletedRelationship += assetToOldAcrId,
                                deletedRelationship.deletedAt = datetime(),
                                deletedRelationship.deletedBy = by
                            DELETE assetToOldAcrId
                        )
                        WITH DISTINCT source_asset, by, asset
                        OPTIONAL MATCH (track:Track { id: toInteger(source_asset.tuid) })
                        CALL apoc.util.validate(track IS NULL, "Could not find the track %s", [source_asset.tuid])
                        MERGE (track)-[trackHasAsset:HAS_ASSET]->(asset)
                            ON CREATE SET
                                trackHasAsset.createdAt = datetime(),
                                trackHasAsset.createdBy = by,
                                trackHasAsset.lastModifiedAt = datetime(),
                                trackHasAsset.lastModifiedBy = by
                    ',
                    {
                        batchSize: 1000
                    }
                )
                YIELD failedOperations, errorMessages, failedBatches, batch
                CALL apoc.util.validate(failedOperations > 0, "At least one sub-operation failed: %s", [reduce(all_errors = "", error IN keys(errorMessages) | all_errors + ", " + error)])
                CALL apoc.util.validate(failedBatches > 0, "At least one batch failed: %s", [reduce(all_errors = "", error IN keys(batch.errors) | all_errors + ", " + error)])
                RETURN 0
            ]]>
        </query>
        <query>
            CALL apoc.log.info("Finished acr_cloud data ingest part 68 of 169 at %s", [datetime()]);
        </query>

        <query>
            <![CDATA[
                CALL apoc.periodic.iterate(
                     "
                        WITH 'snowflake_orchard' AS url_alias,
                        '
                            SELECT * FROM facts.qa.jsonified_track_mapping ORDER BY ACR_ID ASC LIMIT 100000 OFFSET 6800000
                        '
                        AS sql
                        CALL apoc.load.jdbc(url_alias, sql)
                        YIELD row
                        return apoc.convert.fromJsonMap(row.NODE) AS row;
                    ",
                    '
                        WITH *, "database/distro-4707" AS by
                        MERGE (acrId:ACRID { id: row.acr_id })
                            ON CREATE SET
                                acrId.createdAt = datetime(),
                                acrId.createdBy = by,
                                acrId.lastModifiedAt = datetime(),
                                acrId.lastModifiedBy = by
                        MERGE (acrId)<-[acrIdToOsr:CONTAINS_FINGERPRINT]-(osr:OrchardSoundRecording)
                            ON CREATE SET
                                osr.id = apoc.create.uuid(),
                                osr.createdAt = datetime(),
                                osr.createdBy = by,
                                osr.lastModifiedAt = datetime(),
                                osr.lastModifiedBy = by,
                                acrIdToOsr.createdAt = datetime(),
                                acrIdToOsr.createdBy = by,
                                acrIdToOsr.lastModifiedAt = datetime(),
                                acrIdToOsr.lastModifiedBy = by
                        WITH *
                        UNWIND row.assets AS source_asset
                        MERGE (asset:OrchardAsset {
                            filename: source_asset.filename,
                            extension: "mp3",
                            source: "direct-delivery-db"
                        })
                            ON CREATE SET
                                asset.id = apoc.create.uuid(),
                                asset.createdAt = datetime(),
                                asset.createdBy = by,
                                asset.lastModifiedAt = datetime(),
                                asset.lastModifiedBy = by
                        MERGE (asset)-[assetToAcrId:FINGERPRINTED_AS]->(acrId)
                            ON CREATE SET
                                assetToAcrId.createdAt = datetime(),
                                assetToAcrId.createdBy = by
                            SET
                                assetToAcrId.lastModifiedAt = datetime(),
                                assetToAcrId.lastModifiedBy = by
                        WITH *
                        OPTIONAL MATCH (asset)-[assetToOldAcrId:FINGERPRINTED_AS]->(oldAcrId:ACRID)
                            WHERE oldAcrId <> acrId
                        FOREACH (hasOldAcrId IN CASE WHEN oldAcrId IS NOT NULL THEN [1] ELSE [] END |
                            CREATE (asset)-[deletedRelationship:DELETED_FINGERPRINTED_AS]->(oldAcrId)
                            SET
                                deletedRelationship += assetToOldAcrId,
                                deletedRelationship.deletedAt = datetime(),
                                deletedRelationship.deletedBy = by
                            DELETE assetToOldAcrId
                        )
                        WITH DISTINCT source_asset, by, asset
                        OPTIONAL MATCH (track:Track { id: toInteger(source_asset.tuid) })
                        CALL apoc.util.validate(track IS NULL, "Could not find the track %s", [source_asset.tuid])
                        MERGE (track)-[trackHasAsset:HAS_ASSET]->(asset)
                            ON CREATE SET
                                trackHasAsset.createdAt = datetime(),
                                trackHasAsset.createdBy = by,
                                trackHasAsset.lastModifiedAt = datetime(),
                                trackHasAsset.lastModifiedBy = by
                    ',
                    {
                        batchSize: 1000
                    }
                )
                YIELD failedOperations, errorMessages, failedBatches, batch
                CALL apoc.util.validate(failedOperations > 0, "At least one sub-operation failed: %s", [reduce(all_errors = "", error IN keys(errorMessages) | all_errors + ", " + error)])
                CALL apoc.util.validate(failedBatches > 0, "At least one batch failed: %s", [reduce(all_errors = "", error IN keys(batch.errors) | all_errors + ", " + error)])
                RETURN 0
            ]]>
        </query>
        <query>
            CALL apoc.log.info("Finished acr_cloud data ingest part 69 of 169 at %s", [datetime()]);
        </query>

        <query>
            <![CDATA[
                CALL apoc.periodic.iterate(
                     "
                        WITH 'snowflake_orchard' AS url_alias,
                        '
                            SELECT * FROM facts.qa.jsonified_track_mapping ORDER BY ACR_ID ASC LIMIT 100000 OFFSET 6900000
                        '
                        AS sql
                        CALL apoc.load.jdbc(url_alias, sql)
                        YIELD row
                        return apoc.convert.fromJsonMap(row.NODE) AS row;
                    ",
                    '
                        WITH *, "database/distro-4707" AS by
                        MERGE (acrId:ACRID { id: row.acr_id })
                            ON CREATE SET
                                acrId.createdAt = datetime(),
                                acrId.createdBy = by,
                                acrId.lastModifiedAt = datetime(),
                                acrId.lastModifiedBy = by
                        MERGE (acrId)<-[acrIdToOsr:CONTAINS_FINGERPRINT]-(osr:OrchardSoundRecording)
                            ON CREATE SET
                                osr.id = apoc.create.uuid(),
                                osr.createdAt = datetime(),
                                osr.createdBy = by,
                                osr.lastModifiedAt = datetime(),
                                osr.lastModifiedBy = by,
                                acrIdToOsr.createdAt = datetime(),
                                acrIdToOsr.createdBy = by,
                                acrIdToOsr.lastModifiedAt = datetime(),
                                acrIdToOsr.lastModifiedBy = by
                        WITH *
                        UNWIND row.assets AS source_asset
                        MERGE (asset:OrchardAsset {
                            filename: source_asset.filename,
                            extension: "mp3",
                            source: "direct-delivery-db"
                        })
                            ON CREATE SET
                                asset.id = apoc.create.uuid(),
                                asset.createdAt = datetime(),
                                asset.createdBy = by,
                                asset.lastModifiedAt = datetime(),
                                asset.lastModifiedBy = by
                        MERGE (asset)-[assetToAcrId:FINGERPRINTED_AS]->(acrId)
                            ON CREATE SET
                                assetToAcrId.createdAt = datetime(),
                                assetToAcrId.createdBy = by
                            SET
                                assetToAcrId.lastModifiedAt = datetime(),
                                assetToAcrId.lastModifiedBy = by
                        WITH *
                        OPTIONAL MATCH (asset)-[assetToOldAcrId:FINGERPRINTED_AS]->(oldAcrId:ACRID)
                            WHERE oldAcrId <> acrId
                        FOREACH (hasOldAcrId IN CASE WHEN oldAcrId IS NOT NULL THEN [1] ELSE [] END |
                            CREATE (asset)-[deletedRelationship:DELETED_FINGERPRINTED_AS]->(oldAcrId)
                            SET
                                deletedRelationship += assetToOldAcrId,
                                deletedRelationship.deletedAt = datetime(),
                                deletedRelationship.deletedBy = by
                            DELETE assetToOldAcrId
                        )
                        WITH DISTINCT source_asset, by, asset
                        OPTIONAL MATCH (track:Track { id: toInteger(source_asset.tuid) })
                        CALL apoc.util.validate(track IS NULL, "Could not find the track %s", [source_asset.tuid])
                        MERGE (track)-[trackHasAsset:HAS_ASSET]->(asset)
                            ON CREATE SET
                                trackHasAsset.createdAt = datetime(),
                                trackHasAsset.createdBy = by,
                                trackHasAsset.lastModifiedAt = datetime(),
                                trackHasAsset.lastModifiedBy = by
                    ',
                    {
                        batchSize: 1000
                    }
                )
                YIELD failedOperations, errorMessages, failedBatches, batch
                CALL apoc.util.validate(failedOperations > 0, "At least one sub-operation failed: %s", [reduce(all_errors = "", error IN keys(errorMessages) | all_errors + ", " + error)])
                CALL apoc.util.validate(failedBatches > 0, "At least one batch failed: %s", [reduce(all_errors = "", error IN keys(batch.errors) | all_errors + ", " + error)])
                RETURN 0
            ]]>
        </query>
        <query>
            CALL apoc.log.info("Finished acr_cloud data ingest part 70 of 169 at %s", [datetime()]);
        </query>

        <query>
            <![CDATA[
                CALL apoc.periodic.iterate(
                     "
                        WITH 'snowflake_orchard' AS url_alias,
                        '
                            SELECT * FROM facts.qa.jsonified_track_mapping ORDER BY ACR_ID ASC LIMIT 100000 OFFSET 7000000
                        '
                        AS sql
                        CALL apoc.load.jdbc(url_alias, sql)
                        YIELD row
                        return apoc.convert.fromJsonMap(row.NODE) AS row;
                    ",
                    '
                        WITH *, "database/distro-4707" AS by
                        MERGE (acrId:ACRID { id: row.acr_id })
                            ON CREATE SET
                                acrId.createdAt = datetime(),
                                acrId.createdBy = by,
                                acrId.lastModifiedAt = datetime(),
                                acrId.lastModifiedBy = by
                        MERGE (acrId)<-[acrIdToOsr:CONTAINS_FINGERPRINT]-(osr:OrchardSoundRecording)
                            ON CREATE SET
                                osr.id = apoc.create.uuid(),
                                osr.createdAt = datetime(),
                                osr.createdBy = by,
                                osr.lastModifiedAt = datetime(),
                                osr.lastModifiedBy = by,
                                acrIdToOsr.createdAt = datetime(),
                                acrIdToOsr.createdBy = by,
                                acrIdToOsr.lastModifiedAt = datetime(),
                                acrIdToOsr.lastModifiedBy = by
                        WITH *
                        UNWIND row.assets AS source_asset
                        MERGE (asset:OrchardAsset {
                            filename: source_asset.filename,
                            extension: "mp3",
                            source: "direct-delivery-db"
                        })
                            ON CREATE SET
                                asset.id = apoc.create.uuid(),
                                asset.createdAt = datetime(),
                                asset.createdBy = by,
                                asset.lastModifiedAt = datetime(),
                                asset.lastModifiedBy = by
                        MERGE (asset)-[assetToAcrId:FINGERPRINTED_AS]->(acrId)
                            ON CREATE SET
                                assetToAcrId.createdAt = datetime(),
                                assetToAcrId.createdBy = by
                            SET
                                assetToAcrId.lastModifiedAt = datetime(),
                                assetToAcrId.lastModifiedBy = by
                        WITH *
                        OPTIONAL MATCH (asset)-[assetToOldAcrId:FINGERPRINTED_AS]->(oldAcrId:ACRID)
                            WHERE oldAcrId <> acrId
                        FOREACH (hasOldAcrId IN CASE WHEN oldAcrId IS NOT NULL THEN [1] ELSE [] END |
                            CREATE (asset)-[deletedRelationship:DELETED_FINGERPRINTED_AS]->(oldAcrId)
                            SET
                                deletedRelationship += assetToOldAcrId,
                                deletedRelationship.deletedAt = datetime(),
                                deletedRelationship.deletedBy = by
                            DELETE assetToOldAcrId
                        )
                        WITH DISTINCT source_asset, by, asset
                        OPTIONAL MATCH (track:Track { id: toInteger(source_asset.tuid) })
                        CALL apoc.util.validate(track IS NULL, "Could not find the track %s", [source_asset.tuid])
                        MERGE (track)-[trackHasAsset:HAS_ASSET]->(asset)
                            ON CREATE SET
                                trackHasAsset.createdAt = datetime(),
                                trackHasAsset.createdBy = by,
                                trackHasAsset.lastModifiedAt = datetime(),
                                trackHasAsset.lastModifiedBy = by
                    ',
                    {
                        batchSize: 1000
                    }
                )
                YIELD failedOperations, errorMessages, failedBatches, batch
                CALL apoc.util.validate(failedOperations > 0, "At least one sub-operation failed: %s", [reduce(all_errors = "", error IN keys(errorMessages) | all_errors + ", " + error)])
                CALL apoc.util.validate(failedBatches > 0, "At least one batch failed: %s", [reduce(all_errors = "", error IN keys(batch.errors) | all_errors + ", " + error)])
                RETURN 0
            ]]>
        </query>
        <query>
            CALL apoc.log.info("Finished acr_cloud data ingest part 71 of 169 at %s", [datetime()]);
        </query>

        <query>
            <![CDATA[
                CALL apoc.periodic.iterate(
                     "
                        WITH 'snowflake_orchard' AS url_alias,
                        '
                            SELECT * FROM facts.qa.jsonified_track_mapping ORDER BY ACR_ID ASC LIMIT 100000 OFFSET 7100000
                        '
                        AS sql
                        CALL apoc.load.jdbc(url_alias, sql)
                        YIELD row
                        return apoc.convert.fromJsonMap(row.NODE) AS row;
                    ",
                    '
                        WITH *, "database/distro-4707" AS by
                        MERGE (acrId:ACRID { id: row.acr_id })
                            ON CREATE SET
                                acrId.createdAt = datetime(),
                                acrId.createdBy = by,
                                acrId.lastModifiedAt = datetime(),
                                acrId.lastModifiedBy = by
                        MERGE (acrId)<-[acrIdToOsr:CONTAINS_FINGERPRINT]-(osr:OrchardSoundRecording)
                            ON CREATE SET
                                osr.id = apoc.create.uuid(),
                                osr.createdAt = datetime(),
                                osr.createdBy = by,
                                osr.lastModifiedAt = datetime(),
                                osr.lastModifiedBy = by,
                                acrIdToOsr.createdAt = datetime(),
                                acrIdToOsr.createdBy = by,
                                acrIdToOsr.lastModifiedAt = datetime(),
                                acrIdToOsr.lastModifiedBy = by
                        WITH *
                        UNWIND row.assets AS source_asset
                        MERGE (asset:OrchardAsset {
                            filename: source_asset.filename,
                            extension: "mp3",
                            source: "direct-delivery-db"
                        })
                            ON CREATE SET
                                asset.id = apoc.create.uuid(),
                                asset.createdAt = datetime(),
                                asset.createdBy = by,
                                asset.lastModifiedAt = datetime(),
                                asset.lastModifiedBy = by
                        MERGE (asset)-[assetToAcrId:FINGERPRINTED_AS]->(acrId)
                            ON CREATE SET
                                assetToAcrId.createdAt = datetime(),
                                assetToAcrId.createdBy = by
                            SET
                                assetToAcrId.lastModifiedAt = datetime(),
                                assetToAcrId.lastModifiedBy = by
                        WITH *
                        OPTIONAL MATCH (asset)-[assetToOldAcrId:FINGERPRINTED_AS]->(oldAcrId:ACRID)
                            WHERE oldAcrId <> acrId
                        FOREACH (hasOldAcrId IN CASE WHEN oldAcrId IS NOT NULL THEN [1] ELSE [] END |
                            CREATE (asset)-[deletedRelationship:DELETED_FINGERPRINTED_AS]->(oldAcrId)
                            SET
                                deletedRelationship += assetToOldAcrId,
                                deletedRelationship.deletedAt = datetime(),
                                deletedRelationship.deletedBy = by
                            DELETE assetToOldAcrId
                        )
                        WITH DISTINCT source_asset, by, asset
                        OPTIONAL MATCH (track:Track { id: toInteger(source_asset.tuid) })
                        CALL apoc.util.validate(track IS NULL, "Could not find the track %s", [source_asset.tuid])
                        MERGE (track)-[trackHasAsset:HAS_ASSET]->(asset)
                            ON CREATE SET
                                trackHasAsset.createdAt = datetime(),
                                trackHasAsset.createdBy = by,
                                trackHasAsset.lastModifiedAt = datetime(),
                                trackHasAsset.lastModifiedBy = by
                    ',
                    {
                        batchSize: 1000
                    }
                )
                YIELD failedOperations, errorMessages, failedBatches, batch
                CALL apoc.util.validate(failedOperations > 0, "At least one sub-operation failed: %s", [reduce(all_errors = "", error IN keys(errorMessages) | all_errors + ", " + error)])
                CALL apoc.util.validate(failedBatches > 0, "At least one batch failed: %s", [reduce(all_errors = "", error IN keys(batch.errors) | all_errors + ", " + error)])
                RETURN 0
            ]]>
        </query>
        <query>
            CALL apoc.log.info("Finished acr_cloud data ingest part 72 of 169 at %s", [datetime()]);
        </query>

        <query>
            <![CDATA[
                CALL apoc.periodic.iterate(
                     "
                        WITH 'snowflake_orchard' AS url_alias,
                        '
                            SELECT * FROM facts.qa.jsonified_track_mapping ORDER BY ACR_ID ASC LIMIT 100000 OFFSET 7200000
                        '
                        AS sql
                        CALL apoc.load.jdbc(url_alias, sql)
                        YIELD row
                        return apoc.convert.fromJsonMap(row.NODE) AS row;
                    ",
                    '
                        WITH *, "database/distro-4707" AS by
                        MERGE (acrId:ACRID { id: row.acr_id })
                            ON CREATE SET
                                acrId.createdAt = datetime(),
                                acrId.createdBy = by,
                                acrId.lastModifiedAt = datetime(),
                                acrId.lastModifiedBy = by
                        MERGE (acrId)<-[acrIdToOsr:CONTAINS_FINGERPRINT]-(osr:OrchardSoundRecording)
                            ON CREATE SET
                                osr.id = apoc.create.uuid(),
                                osr.createdAt = datetime(),
                                osr.createdBy = by,
                                osr.lastModifiedAt = datetime(),
                                osr.lastModifiedBy = by,
                                acrIdToOsr.createdAt = datetime(),
                                acrIdToOsr.createdBy = by,
                                acrIdToOsr.lastModifiedAt = datetime(),
                                acrIdToOsr.lastModifiedBy = by
                        WITH *
                        UNWIND row.assets AS source_asset
                        MERGE (asset:OrchardAsset {
                            filename: source_asset.filename,
                            extension: "mp3",
                            source: "direct-delivery-db"
                        })
                            ON CREATE SET
                                asset.id = apoc.create.uuid(),
                                asset.createdAt = datetime(),
                                asset.createdBy = by,
                                asset.lastModifiedAt = datetime(),
                                asset.lastModifiedBy = by
                        MERGE (asset)-[assetToAcrId:FINGERPRINTED_AS]->(acrId)
                            ON CREATE SET
                                assetToAcrId.createdAt = datetime(),
                                assetToAcrId.createdBy = by
                            SET
                                assetToAcrId.lastModifiedAt = datetime(),
                                assetToAcrId.lastModifiedBy = by
                        WITH *
                        OPTIONAL MATCH (asset)-[assetToOldAcrId:FINGERPRINTED_AS]->(oldAcrId:ACRID)
                            WHERE oldAcrId <> acrId
                        FOREACH (hasOldAcrId IN CASE WHEN oldAcrId IS NOT NULL THEN [1] ELSE [] END |
                            CREATE (asset)-[deletedRelationship:DELETED_FINGERPRINTED_AS]->(oldAcrId)
                            SET
                                deletedRelationship += assetToOldAcrId,
                                deletedRelationship.deletedAt = datetime(),
                                deletedRelationship.deletedBy = by
                            DELETE assetToOldAcrId
                        )
                        WITH DISTINCT source_asset, by, asset
                        OPTIONAL MATCH (track:Track { id: toInteger(source_asset.tuid) })
                        CALL apoc.util.validate(track IS NULL, "Could not find the track %s", [source_asset.tuid])
                        MERGE (track)-[trackHasAsset:HAS_ASSET]->(asset)
                            ON CREATE SET
                                trackHasAsset.createdAt = datetime(),
                                trackHasAsset.createdBy = by,
                                trackHasAsset.lastModifiedAt = datetime(),
                                trackHasAsset.lastModifiedBy = by
                    ',
                    {
                        batchSize: 1000
                    }
                )
                YIELD failedOperations, errorMessages, failedBatches, batch
                CALL apoc.util.validate(failedOperations > 0, "At least one sub-operation failed: %s", [reduce(all_errors = "", error IN keys(errorMessages) | all_errors + ", " + error)])
                CALL apoc.util.validate(failedBatches > 0, "At least one batch failed: %s", [reduce(all_errors = "", error IN keys(batch.errors) | all_errors + ", " + error)])
                RETURN 0
            ]]>
        </query>
        <query>
            CALL apoc.log.info("Finished acr_cloud data ingest part 73 of 169 at %s", [datetime()]);
        </query>

        <query>
            <![CDATA[
                CALL apoc.periodic.iterate(
                     "
                        WITH 'snowflake_orchard' AS url_alias,
                        '
                            SELECT * FROM facts.qa.jsonified_track_mapping ORDER BY ACR_ID ASC LIMIT 100000 OFFSET 7300000
                        '
                        AS sql
                        CALL apoc.load.jdbc(url_alias, sql)
                        YIELD row
                        return apoc.convert.fromJsonMap(row.NODE) AS row;
                    ",
                    '
                        WITH *, "database/distro-4707" AS by
                        MERGE (acrId:ACRID { id: row.acr_id })
                            ON CREATE SET
                                acrId.createdAt = datetime(),
                                acrId.createdBy = by,
                                acrId.lastModifiedAt = datetime(),
                                acrId.lastModifiedBy = by
                        MERGE (acrId)<-[acrIdToOsr:CONTAINS_FINGERPRINT]-(osr:OrchardSoundRecording)
                            ON CREATE SET
                                osr.id = apoc.create.uuid(),
                                osr.createdAt = datetime(),
                                osr.createdBy = by,
                                osr.lastModifiedAt = datetime(),
                                osr.lastModifiedBy = by,
                                acrIdToOsr.createdAt = datetime(),
                                acrIdToOsr.createdBy = by,
                                acrIdToOsr.lastModifiedAt = datetime(),
                                acrIdToOsr.lastModifiedBy = by
                        WITH *
                        UNWIND row.assets AS source_asset
                        MERGE (asset:OrchardAsset {
                            filename: source_asset.filename,
                            extension: "mp3",
                            source: "direct-delivery-db"
                        })
                            ON CREATE SET
                                asset.id = apoc.create.uuid(),
                                asset.createdAt = datetime(),
                                asset.createdBy = by,
                                asset.lastModifiedAt = datetime(),
                                asset.lastModifiedBy = by
                        MERGE (asset)-[assetToAcrId:FINGERPRINTED_AS]->(acrId)
                            ON CREATE SET
                                assetToAcrId.createdAt = datetime(),
                                assetToAcrId.createdBy = by
                            SET
                                assetToAcrId.lastModifiedAt = datetime(),
                                assetToAcrId.lastModifiedBy = by
                        WITH *
                        OPTIONAL MATCH (asset)-[assetToOldAcrId:FINGERPRINTED_AS]->(oldAcrId:ACRID)
                            WHERE oldAcrId <> acrId
                        FOREACH (hasOldAcrId IN CASE WHEN oldAcrId IS NOT NULL THEN [1] ELSE [] END |
                            CREATE (asset)-[deletedRelationship:DELETED_FINGERPRINTED_AS]->(oldAcrId)
                            SET
                                deletedRelationship += assetToOldAcrId,
                                deletedRelationship.deletedAt = datetime(),
                                deletedRelationship.deletedBy = by
                            DELETE assetToOldAcrId
                        )
                        WITH DISTINCT source_asset, by, asset
                        OPTIONAL MATCH (track:Track { id: toInteger(source_asset.tuid) })
                        CALL apoc.util.validate(track IS NULL, "Could not find the track %s", [source_asset.tuid])
                        MERGE (track)-[trackHasAsset:HAS_ASSET]->(asset)
                            ON CREATE SET
                                trackHasAsset.createdAt = datetime(),
                                trackHasAsset.createdBy = by,
                                trackHasAsset.lastModifiedAt = datetime(),
                                trackHasAsset.lastModifiedBy = by
                    ',
                    {
                        batchSize: 1000
                    }
                )
                YIELD failedOperations, errorMessages, failedBatches, batch
                CALL apoc.util.validate(failedOperations > 0, "At least one sub-operation failed: %s", [reduce(all_errors = "", error IN keys(errorMessages) | all_errors + ", " + error)])
                CALL apoc.util.validate(failedBatches > 0, "At least one batch failed: %s", [reduce(all_errors = "", error IN keys(batch.errors) | all_errors + ", " + error)])
                RETURN 0
            ]]>
        </query>
        <query>
            CALL apoc.log.info("Finished acr_cloud data ingest part 74 of 169 at %s", [datetime()]);
        </query>

        <query>
            <![CDATA[
                CALL apoc.periodic.iterate(
                     "
                        WITH 'snowflake_orchard' AS url_alias,
                        '
                            SELECT * FROM facts.qa.jsonified_track_mapping ORDER BY ACR_ID ASC LIMIT 100000 OFFSET 7400000
                        '
                        AS sql
                        CALL apoc.load.jdbc(url_alias, sql)
                        YIELD row
                        return apoc.convert.fromJsonMap(row.NODE) AS row;
                    ",
                    '
                        WITH *, "database/distro-4707" AS by
                        MERGE (acrId:ACRID { id: row.acr_id })
                            ON CREATE SET
                                acrId.createdAt = datetime(),
                                acrId.createdBy = by,
                                acrId.lastModifiedAt = datetime(),
                                acrId.lastModifiedBy = by
                        MERGE (acrId)<-[acrIdToOsr:CONTAINS_FINGERPRINT]-(osr:OrchardSoundRecording)
                            ON CREATE SET
                                osr.id = apoc.create.uuid(),
                                osr.createdAt = datetime(),
                                osr.createdBy = by,
                                osr.lastModifiedAt = datetime(),
                                osr.lastModifiedBy = by,
                                acrIdToOsr.createdAt = datetime(),
                                acrIdToOsr.createdBy = by,
                                acrIdToOsr.lastModifiedAt = datetime(),
                                acrIdToOsr.lastModifiedBy = by
                        WITH *
                        UNWIND row.assets AS source_asset
                        MERGE (asset:OrchardAsset {
                            filename: source_asset.filename,
                            extension: "mp3",
                            source: "direct-delivery-db"
                        })
                            ON CREATE SET
                                asset.id = apoc.create.uuid(),
                                asset.createdAt = datetime(),
                                asset.createdBy = by,
                                asset.lastModifiedAt = datetime(),
                                asset.lastModifiedBy = by
                        MERGE (asset)-[assetToAcrId:FINGERPRINTED_AS]->(acrId)
                            ON CREATE SET
                                assetToAcrId.createdAt = datetime(),
                                assetToAcrId.createdBy = by
                            SET
                                assetToAcrId.lastModifiedAt = datetime(),
                                assetToAcrId.lastModifiedBy = by
                        WITH *
                        OPTIONAL MATCH (asset)-[assetToOldAcrId:FINGERPRINTED_AS]->(oldAcrId:ACRID)
                            WHERE oldAcrId <> acrId
                        FOREACH (hasOldAcrId IN CASE WHEN oldAcrId IS NOT NULL THEN [1] ELSE [] END |
                            CREATE (asset)-[deletedRelationship:DELETED_FINGERPRINTED_AS]->(oldAcrId)
                            SET
                                deletedRelationship += assetToOldAcrId,
                                deletedRelationship.deletedAt = datetime(),
                                deletedRelationship.deletedBy = by
                            DELETE assetToOldAcrId
                        )
                        WITH DISTINCT source_asset, by, asset
                        OPTIONAL MATCH (track:Track { id: toInteger(source_asset.tuid) })
                        CALL apoc.util.validate(track IS NULL, "Could not find the track %s", [source_asset.tuid])
                        MERGE (track)-[trackHasAsset:HAS_ASSET]->(asset)
                            ON CREATE SET
                                trackHasAsset.createdAt = datetime(),
                                trackHasAsset.createdBy = by,
                                trackHasAsset.lastModifiedAt = datetime(),
                                trackHasAsset.lastModifiedBy = by
                    ',
                    {
                        batchSize: 1000
                    }
                )
                YIELD failedOperations, errorMessages, failedBatches, batch
                CALL apoc.util.validate(failedOperations > 0, "At least one sub-operation failed: %s", [reduce(all_errors = "", error IN keys(errorMessages) | all_errors + ", " + error)])
                CALL apoc.util.validate(failedBatches > 0, "At least one batch failed: %s", [reduce(all_errors = "", error IN keys(batch.errors) | all_errors + ", " + error)])
                RETURN 0
            ]]>
        </query>
        <query>
            CALL apoc.log.info("Finished acr_cloud data ingest part 75 of 169 at %s", [datetime()]);
        </query>

        <query>
            <![CDATA[
                CALL apoc.periodic.iterate(
                     "
                        WITH 'snowflake_orchard' AS url_alias,
                        '
                            SELECT * FROM facts.qa.jsonified_track_mapping ORDER BY ACR_ID ASC LIMIT 100000 OFFSET 7500000
                        '
                        AS sql
                        CALL apoc.load.jdbc(url_alias, sql)
                        YIELD row
                        return apoc.convert.fromJsonMap(row.NODE) AS row;
                    ",
                    '
                        WITH *, "database/distro-4707" AS by
                        MERGE (acrId:ACRID { id: row.acr_id })
                            ON CREATE SET
                                acrId.createdAt = datetime(),
                                acrId.createdBy = by,
                                acrId.lastModifiedAt = datetime(),
                                acrId.lastModifiedBy = by
                        MERGE (acrId)<-[acrIdToOsr:CONTAINS_FINGERPRINT]-(osr:OrchardSoundRecording)
                            ON CREATE SET
                                osr.id = apoc.create.uuid(),
                                osr.createdAt = datetime(),
                                osr.createdBy = by,
                                osr.lastModifiedAt = datetime(),
                                osr.lastModifiedBy = by,
                                acrIdToOsr.createdAt = datetime(),
                                acrIdToOsr.createdBy = by,
                                acrIdToOsr.lastModifiedAt = datetime(),
                                acrIdToOsr.lastModifiedBy = by
                        WITH *
                        UNWIND row.assets AS source_asset
                        MERGE (asset:OrchardAsset {
                            filename: source_asset.filename,
                            extension: "mp3",
                            source: "direct-delivery-db"
                        })
                            ON CREATE SET
                                asset.id = apoc.create.uuid(),
                                asset.createdAt = datetime(),
                                asset.createdBy = by,
                                asset.lastModifiedAt = datetime(),
                                asset.lastModifiedBy = by
                        MERGE (asset)-[assetToAcrId:FINGERPRINTED_AS]->(acrId)
                            ON CREATE SET
                                assetToAcrId.createdAt = datetime(),
                                assetToAcrId.createdBy = by
                            SET
                                assetToAcrId.lastModifiedAt = datetime(),
                                assetToAcrId.lastModifiedBy = by
                        WITH *
                        OPTIONAL MATCH (asset)-[assetToOldAcrId:FINGERPRINTED_AS]->(oldAcrId:ACRID)
                            WHERE oldAcrId <> acrId
                        FOREACH (hasOldAcrId IN CASE WHEN oldAcrId IS NOT NULL THEN [1] ELSE [] END |
                            CREATE (asset)-[deletedRelationship:DELETED_FINGERPRINTED_AS]->(oldAcrId)
                            SET
                                deletedRelationship += assetToOldAcrId,
                                deletedRelationship.deletedAt = datetime(),
                                deletedRelationship.deletedBy = by
                            DELETE assetToOldAcrId
                        )
                        WITH DISTINCT source_asset, by, asset
                        OPTIONAL MATCH (track:Track { id: toInteger(source_asset.tuid) })
                        CALL apoc.util.validate(track IS NULL, "Could not find the track %s", [source_asset.tuid])
                        MERGE (track)-[trackHasAsset:HAS_ASSET]->(asset)
                            ON CREATE SET
                                trackHasAsset.createdAt = datetime(),
                                trackHasAsset.createdBy = by,
                                trackHasAsset.lastModifiedAt = datetime(),
                                trackHasAsset.lastModifiedBy = by
                    ',
                    {
                        batchSize: 1000
                    }
                )
                YIELD failedOperations, errorMessages, failedBatches, batch
                CALL apoc.util.validate(failedOperations > 0, "At least one sub-operation failed: %s", [reduce(all_errors = "", error IN keys(errorMessages) | all_errors + ", " + error)])
                CALL apoc.util.validate(failedBatches > 0, "At least one batch failed: %s", [reduce(all_errors = "", error IN keys(batch.errors) | all_errors + ", " + error)])
                RETURN 0
            ]]>
        </query>
        <query>
            CALL apoc.log.info("Finished acr_cloud data ingest part 76 of 169 at %s", [datetime()]);
        </query>

        <query>
            <![CDATA[
                CALL apoc.periodic.iterate(
                     "
                        WITH 'snowflake_orchard' AS url_alias,
                        '
                            SELECT * FROM facts.qa.jsonified_track_mapping ORDER BY ACR_ID ASC LIMIT 100000 OFFSET 7600000
                        '
                        AS sql
                        CALL apoc.load.jdbc(url_alias, sql)
                        YIELD row
                        return apoc.convert.fromJsonMap(row.NODE) AS row;
                    ",
                    '
                        WITH *, "database/distro-4707" AS by
                        MERGE (acrId:ACRID { id: row.acr_id })
                            ON CREATE SET
                                acrId.createdAt = datetime(),
                                acrId.createdBy = by,
                                acrId.lastModifiedAt = datetime(),
                                acrId.lastModifiedBy = by
                        MERGE (acrId)<-[acrIdToOsr:CONTAINS_FINGERPRINT]-(osr:OrchardSoundRecording)
                            ON CREATE SET
                                osr.id = apoc.create.uuid(),
                                osr.createdAt = datetime(),
                                osr.createdBy = by,
                                osr.lastModifiedAt = datetime(),
                                osr.lastModifiedBy = by,
                                acrIdToOsr.createdAt = datetime(),
                                acrIdToOsr.createdBy = by,
                                acrIdToOsr.lastModifiedAt = datetime(),
                                acrIdToOsr.lastModifiedBy = by
                        WITH *
                        UNWIND row.assets AS source_asset
                        MERGE (asset:OrchardAsset {
                            filename: source_asset.filename,
                            extension: "mp3",
                            source: "direct-delivery-db"
                        })
                            ON CREATE SET
                                asset.id = apoc.create.uuid(),
                                asset.createdAt = datetime(),
                                asset.createdBy = by,
                                asset.lastModifiedAt = datetime(),
                                asset.lastModifiedBy = by
                        MERGE (asset)-[assetToAcrId:FINGERPRINTED_AS]->(acrId)
                            ON CREATE SET
                                assetToAcrId.createdAt = datetime(),
                                assetToAcrId.createdBy = by
                            SET
                                assetToAcrId.lastModifiedAt = datetime(),
                                assetToAcrId.lastModifiedBy = by
                        WITH *
                        OPTIONAL MATCH (asset)-[assetToOldAcrId:FINGERPRINTED_AS]->(oldAcrId:ACRID)
                            WHERE oldAcrId <> acrId
                        FOREACH (hasOldAcrId IN CASE WHEN oldAcrId IS NOT NULL THEN [1] ELSE [] END |
                            CREATE (asset)-[deletedRelationship:DELETED_FINGERPRINTED_AS]->(oldAcrId)
                            SET
                                deletedRelationship += assetToOldAcrId,
                                deletedRelationship.deletedAt = datetime(),
                                deletedRelationship.deletedBy = by
                            DELETE assetToOldAcrId
                        )
                        WITH DISTINCT source_asset, by, asset
                        OPTIONAL MATCH (track:Track { id: toInteger(source_asset.tuid) })
                        CALL apoc.util.validate(track IS NULL, "Could not find the track %s", [source_asset.tuid])
                        MERGE (track)-[trackHasAsset:HAS_ASSET]->(asset)
                            ON CREATE SET
                                trackHasAsset.createdAt = datetime(),
                                trackHasAsset.createdBy = by,
                                trackHasAsset.lastModifiedAt = datetime(),
                                trackHasAsset.lastModifiedBy = by
                    ',
                    {
                        batchSize: 1000
                    }
                )
                YIELD failedOperations, errorMessages, failedBatches, batch
                CALL apoc.util.validate(failedOperations > 0, "At least one sub-operation failed: %s", [reduce(all_errors = "", error IN keys(errorMessages) | all_errors + ", " + error)])
                CALL apoc.util.validate(failedBatches > 0, "At least one batch failed: %s", [reduce(all_errors = "", error IN keys(batch.errors) | all_errors + ", " + error)])
                RETURN 0
            ]]>
        </query>
        <query>
            CALL apoc.log.info("Finished acr_cloud data ingest part 77 of 169 at %s", [datetime()]);
        </query>

        <query>
            <![CDATA[
                CALL apoc.periodic.iterate(
                     "
                        WITH 'snowflake_orchard' AS url_alias,
                        '
                            SELECT * FROM facts.qa.jsonified_track_mapping ORDER BY ACR_ID ASC LIMIT 100000 OFFSET 7700000
                        '
                        AS sql
                        CALL apoc.load.jdbc(url_alias, sql)
                        YIELD row
                        return apoc.convert.fromJsonMap(row.NODE) AS row;
                    ",
                    '
                        WITH *, "database/distro-4707" AS by
                        MERGE (acrId:ACRID { id: row.acr_id })
                            ON CREATE SET
                                acrId.createdAt = datetime(),
                                acrId.createdBy = by,
                                acrId.lastModifiedAt = datetime(),
                                acrId.lastModifiedBy = by
                        MERGE (acrId)<-[acrIdToOsr:CONTAINS_FINGERPRINT]-(osr:OrchardSoundRecording)
                            ON CREATE SET
                                osr.id = apoc.create.uuid(),
                                osr.createdAt = datetime(),
                                osr.createdBy = by,
                                osr.lastModifiedAt = datetime(),
                                osr.lastModifiedBy = by,
                                acrIdToOsr.createdAt = datetime(),
                                acrIdToOsr.createdBy = by,
                                acrIdToOsr.lastModifiedAt = datetime(),
                                acrIdToOsr.lastModifiedBy = by
                        WITH *
                        UNWIND row.assets AS source_asset
                        MERGE (asset:OrchardAsset {
                            filename: source_asset.filename,
                            extension: "mp3",
                            source: "direct-delivery-db"
                        })
                            ON CREATE SET
                                asset.id = apoc.create.uuid(),
                                asset.createdAt = datetime(),
                                asset.createdBy = by,
                                asset.lastModifiedAt = datetime(),
                                asset.lastModifiedBy = by
                        MERGE (asset)-[assetToAcrId:FINGERPRINTED_AS]->(acrId)
                            ON CREATE SET
                                assetToAcrId.createdAt = datetime(),
                                assetToAcrId.createdBy = by
                            SET
                                assetToAcrId.lastModifiedAt = datetime(),
                                assetToAcrId.lastModifiedBy = by
                        WITH *
                        OPTIONAL MATCH (asset)-[assetToOldAcrId:FINGERPRINTED_AS]->(oldAcrId:ACRID)
                            WHERE oldAcrId <> acrId
                        FOREACH (hasOldAcrId IN CASE WHEN oldAcrId IS NOT NULL THEN [1] ELSE [] END |
                            CREATE (asset)-[deletedRelationship:DELETED_FINGERPRINTED_AS]->(oldAcrId)
                            SET
                                deletedRelationship += assetToOldAcrId,
                                deletedRelationship.deletedAt = datetime(),
                                deletedRelationship.deletedBy = by
                            DELETE assetToOldAcrId
                        )
                        WITH DISTINCT source_asset, by, asset
                        OPTIONAL MATCH (track:Track { id: toInteger(source_asset.tuid) })
                        CALL apoc.util.validate(track IS NULL, "Could not find the track %s", [source_asset.tuid])
                        MERGE (track)-[trackHasAsset:HAS_ASSET]->(asset)
                            ON CREATE SET
                                trackHasAsset.createdAt = datetime(),
                                trackHasAsset.createdBy = by,
                                trackHasAsset.lastModifiedAt = datetime(),
                                trackHasAsset.lastModifiedBy = by
                    ',
                    {
                        batchSize: 1000
                    }
                )
                YIELD failedOperations, errorMessages, failedBatches, batch
                CALL apoc.util.validate(failedOperations > 0, "At least one sub-operation failed: %s", [reduce(all_errors = "", error IN keys(errorMessages) | all_errors + ", " + error)])
                CALL apoc.util.validate(failedBatches > 0, "At least one batch failed: %s", [reduce(all_errors = "", error IN keys(batch.errors) | all_errors + ", " + error)])
                RETURN 0
            ]]>
        </query>
        <query>
            CALL apoc.log.info("Finished acr_cloud data ingest part 78 of 169 at %s", [datetime()]);
        </query>

        <query>
            <![CDATA[
                CALL apoc.periodic.iterate(
                     "
                        WITH 'snowflake_orchard' AS url_alias,
                        '
                            SELECT * FROM facts.qa.jsonified_track_mapping ORDER BY ACR_ID ASC LIMIT 100000 OFFSET 7800000
                        '
                        AS sql
                        CALL apoc.load.jdbc(url_alias, sql)
                        YIELD row
                        return apoc.convert.fromJsonMap(row.NODE) AS row;
                    ",
                    '
                        WITH *, "database/distro-4707" AS by
                        MERGE (acrId:ACRID { id: row.acr_id })
                            ON CREATE SET
                                acrId.createdAt = datetime(),
                                acrId.createdBy = by,
                                acrId.lastModifiedAt = datetime(),
                                acrId.lastModifiedBy = by
                        MERGE (acrId)<-[acrIdToOsr:CONTAINS_FINGERPRINT]-(osr:OrchardSoundRecording)
                            ON CREATE SET
                                osr.id = apoc.create.uuid(),
                                osr.createdAt = datetime(),
                                osr.createdBy = by,
                                osr.lastModifiedAt = datetime(),
                                osr.lastModifiedBy = by,
                                acrIdToOsr.createdAt = datetime(),
                                acrIdToOsr.createdBy = by,
                                acrIdToOsr.lastModifiedAt = datetime(),
                                acrIdToOsr.lastModifiedBy = by
                        WITH *
                        UNWIND row.assets AS source_asset
                        MERGE (asset:OrchardAsset {
                            filename: source_asset.filename,
                            extension: "mp3",
                            source: "direct-delivery-db"
                        })
                            ON CREATE SET
                                asset.id = apoc.create.uuid(),
                                asset.createdAt = datetime(),
                                asset.createdBy = by,
                                asset.lastModifiedAt = datetime(),
                                asset.lastModifiedBy = by
                        MERGE (asset)-[assetToAcrId:FINGERPRINTED_AS]->(acrId)
                            ON CREATE SET
                                assetToAcrId.createdAt = datetime(),
                                assetToAcrId.createdBy = by
                            SET
                                assetToAcrId.lastModifiedAt = datetime(),
                                assetToAcrId.lastModifiedBy = by
                        WITH *
                        OPTIONAL MATCH (asset)-[assetToOldAcrId:FINGERPRINTED_AS]->(oldAcrId:ACRID)
                            WHERE oldAcrId <> acrId
                        FOREACH (hasOldAcrId IN CASE WHEN oldAcrId IS NOT NULL THEN [1] ELSE [] END |
                            CREATE (asset)-[deletedRelationship:DELETED_FINGERPRINTED_AS]->(oldAcrId)
                            SET
                                deletedRelationship += assetToOldAcrId,
                                deletedRelationship.deletedAt = datetime(),
                                deletedRelationship.deletedBy = by
                            DELETE assetToOldAcrId
                        )
                        WITH DISTINCT source_asset, by, asset
                        OPTIONAL MATCH (track:Track { id: toInteger(source_asset.tuid) })
                        CALL apoc.util.validate(track IS NULL, "Could not find the track %s", [source_asset.tuid])
                        MERGE (track)-[trackHasAsset:HAS_ASSET]->(asset)
                            ON CREATE SET
                                trackHasAsset.createdAt = datetime(),
                                trackHasAsset.createdBy = by,
                                trackHasAsset.lastModifiedAt = datetime(),
                                trackHasAsset.lastModifiedBy = by
                    ',
                    {
                        batchSize: 1000
                    }
                )
                YIELD failedOperations, errorMessages, failedBatches, batch
                CALL apoc.util.validate(failedOperations > 0, "At least one sub-operation failed: %s", [reduce(all_errors = "", error IN keys(errorMessages) | all_errors + ", " + error)])
                CALL apoc.util.validate(failedBatches > 0, "At least one batch failed: %s", [reduce(all_errors = "", error IN keys(batch.errors) | all_errors + ", " + error)])
                RETURN 0
            ]]>
        </query>
        <query>
            CALL apoc.log.info("Finished acr_cloud data ingest part 79 of 169 at %s", [datetime()]);
        </query>

        <query>
            <![CDATA[
                CALL apoc.periodic.iterate(
                     "
                        WITH 'snowflake_orchard' AS url_alias,
                        '
                            SELECT * FROM facts.qa.jsonified_track_mapping ORDER BY ACR_ID ASC LIMIT 100000 OFFSET 7900000
                        '
                        AS sql
                        CALL apoc.load.jdbc(url_alias, sql)
                        YIELD row
                        return apoc.convert.fromJsonMap(row.NODE) AS row;
                    ",
                    '
                        WITH *, "database/distro-4707" AS by
                        MERGE (acrId:ACRID { id: row.acr_id })
                            ON CREATE SET
                                acrId.createdAt = datetime(),
                                acrId.createdBy = by,
                                acrId.lastModifiedAt = datetime(),
                                acrId.lastModifiedBy = by
                        MERGE (acrId)<-[acrIdToOsr:CONTAINS_FINGERPRINT]-(osr:OrchardSoundRecording)
                            ON CREATE SET
                                osr.id = apoc.create.uuid(),
                                osr.createdAt = datetime(),
                                osr.createdBy = by,
                                osr.lastModifiedAt = datetime(),
                                osr.lastModifiedBy = by,
                                acrIdToOsr.createdAt = datetime(),
                                acrIdToOsr.createdBy = by,
                                acrIdToOsr.lastModifiedAt = datetime(),
                                acrIdToOsr.lastModifiedBy = by
                        WITH *
                        UNWIND row.assets AS source_asset
                        MERGE (asset:OrchardAsset {
                            filename: source_asset.filename,
                            extension: "mp3",
                            source: "direct-delivery-db"
                        })
                            ON CREATE SET
                                asset.id = apoc.create.uuid(),
                                asset.createdAt = datetime(),
                                asset.createdBy = by,
                                asset.lastModifiedAt = datetime(),
                                asset.lastModifiedBy = by
                        MERGE (asset)-[assetToAcrId:FINGERPRINTED_AS]->(acrId)
                            ON CREATE SET
                                assetToAcrId.createdAt = datetime(),
                                assetToAcrId.createdBy = by
                            SET
                                assetToAcrId.lastModifiedAt = datetime(),
                                assetToAcrId.lastModifiedBy = by
                        WITH *
                        OPTIONAL MATCH (asset)-[assetToOldAcrId:FINGERPRINTED_AS]->(oldAcrId:ACRID)
                            WHERE oldAcrId <> acrId
                        FOREACH (hasOldAcrId IN CASE WHEN oldAcrId IS NOT NULL THEN [1] ELSE [] END |
                            CREATE (asset)-[deletedRelationship:DELETED_FINGERPRINTED_AS]->(oldAcrId)
                            SET
                                deletedRelationship += assetToOldAcrId,
                                deletedRelationship.deletedAt = datetime(),
                                deletedRelationship.deletedBy = by
                            DELETE assetToOldAcrId
                        )
                        WITH DISTINCT source_asset, by, asset
                        OPTIONAL MATCH (track:Track { id: toInteger(source_asset.tuid) })
                        CALL apoc.util.validate(track IS NULL, "Could not find the track %s", [source_asset.tuid])
                        MERGE (track)-[trackHasAsset:HAS_ASSET]->(asset)
                            ON CREATE SET
                                trackHasAsset.createdAt = datetime(),
                                trackHasAsset.createdBy = by,
                                trackHasAsset.lastModifiedAt = datetime(),
                                trackHasAsset.lastModifiedBy = by
                    ',
                    {
                        batchSize: 1000
                    }
                )
                YIELD failedOperations, errorMessages, failedBatches, batch
                CALL apoc.util.validate(failedOperations > 0, "At least one sub-operation failed: %s", [reduce(all_errors = "", error IN keys(errorMessages) | all_errors + ", " + error)])
                CALL apoc.util.validate(failedBatches > 0, "At least one batch failed: %s", [reduce(all_errors = "", error IN keys(batch.errors) | all_errors + ", " + error)])
                RETURN 0
            ]]>
        </query>
        <query>
            CALL apoc.log.info("Finished acr_cloud data ingest part 80 of 169 at %s", [datetime()]);
        </query>

        <query>
            <![CDATA[
                CALL apoc.periodic.iterate(
                     "
                        WITH 'snowflake_orchard' AS url_alias,
                        '
                            SELECT * FROM facts.qa.jsonified_track_mapping ORDER BY ACR_ID ASC LIMIT 100000 OFFSET 8000000
                        '
                        AS sql
                        CALL apoc.load.jdbc(url_alias, sql)
                        YIELD row
                        return apoc.convert.fromJsonMap(row.NODE) AS row;
                    ",
                    '
                        WITH *, "database/distro-4707" AS by
                        MERGE (acrId:ACRID { id: row.acr_id })
                            ON CREATE SET
                                acrId.createdAt = datetime(),
                                acrId.createdBy = by,
                                acrId.lastModifiedAt = datetime(),
                                acrId.lastModifiedBy = by
                        MERGE (acrId)<-[acrIdToOsr:CONTAINS_FINGERPRINT]-(osr:OrchardSoundRecording)
                            ON CREATE SET
                                osr.id = apoc.create.uuid(),
                                osr.createdAt = datetime(),
                                osr.createdBy = by,
                                osr.lastModifiedAt = datetime(),
                                osr.lastModifiedBy = by,
                                acrIdToOsr.createdAt = datetime(),
                                acrIdToOsr.createdBy = by,
                                acrIdToOsr.lastModifiedAt = datetime(),
                                acrIdToOsr.lastModifiedBy = by
                        WITH *
                        UNWIND row.assets AS source_asset
                        MERGE (asset:OrchardAsset {
                            filename: source_asset.filename,
                            extension: "mp3",
                            source: "direct-delivery-db"
                        })
                            ON CREATE SET
                                asset.id = apoc.create.uuid(),
                                asset.createdAt = datetime(),
                                asset.createdBy = by,
                                asset.lastModifiedAt = datetime(),
                                asset.lastModifiedBy = by
                        MERGE (asset)-[assetToAcrId:FINGERPRINTED_AS]->(acrId)
                            ON CREATE SET
                                assetToAcrId.createdAt = datetime(),
                                assetToAcrId.createdBy = by
                            SET
                                assetToAcrId.lastModifiedAt = datetime(),
                                assetToAcrId.lastModifiedBy = by
                        WITH *
                        OPTIONAL MATCH (asset)-[assetToOldAcrId:FINGERPRINTED_AS]->(oldAcrId:ACRID)
                            WHERE oldAcrId <> acrId
                        FOREACH (hasOldAcrId IN CASE WHEN oldAcrId IS NOT NULL THEN [1] ELSE [] END |
                            CREATE (asset)-[deletedRelationship:DELETED_FINGERPRINTED_AS]->(oldAcrId)
                            SET
                                deletedRelationship += assetToOldAcrId,
                                deletedRelationship.deletedAt = datetime(),
                                deletedRelationship.deletedBy = by
                            DELETE assetToOldAcrId
                        )
                        WITH DISTINCT source_asset, by, asset
                        OPTIONAL MATCH (track:Track { id: toInteger(source_asset.tuid) })
                        CALL apoc.util.validate(track IS NULL, "Could not find the track %s", [source_asset.tuid])
                        MERGE (track)-[trackHasAsset:HAS_ASSET]->(asset)
                            ON CREATE SET
                                trackHasAsset.createdAt = datetime(),
                                trackHasAsset.createdBy = by,
                                trackHasAsset.lastModifiedAt = datetime(),
                                trackHasAsset.lastModifiedBy = by
                    ',
                    {
                        batchSize: 1000
                    }
                )
                YIELD failedOperations, errorMessages, failedBatches, batch
                CALL apoc.util.validate(failedOperations > 0, "At least one sub-operation failed: %s", [reduce(all_errors = "", error IN keys(errorMessages) | all_errors + ", " + error)])
                CALL apoc.util.validate(failedBatches > 0, "At least one batch failed: %s", [reduce(all_errors = "", error IN keys(batch.errors) | all_errors + ", " + error)])
                RETURN 0
            ]]>
        </query>
        <query>
            CALL apoc.log.info("Finished acr_cloud data ingest part 81 of 169 at %s", [datetime()]);
        </query>

        <query>
            <![CDATA[
                CALL apoc.periodic.iterate(
                     "
                        WITH 'snowflake_orchard' AS url_alias,
                        '
                            SELECT * FROM facts.qa.jsonified_track_mapping ORDER BY ACR_ID ASC LIMIT 100000 OFFSET 8100000
                        '
                        AS sql
                        CALL apoc.load.jdbc(url_alias, sql)
                        YIELD row
                        return apoc.convert.fromJsonMap(row.NODE) AS row;
                    ",
                    '
                        WITH *, "database/distro-4707" AS by
                        MERGE (acrId:ACRID { id: row.acr_id })
                            ON CREATE SET
                                acrId.createdAt = datetime(),
                                acrId.createdBy = by,
                                acrId.lastModifiedAt = datetime(),
                                acrId.lastModifiedBy = by
                        MERGE (acrId)<-[acrIdToOsr:CONTAINS_FINGERPRINT]-(osr:OrchardSoundRecording)
                            ON CREATE SET
                                osr.id = apoc.create.uuid(),
                                osr.createdAt = datetime(),
                                osr.createdBy = by,
                                osr.lastModifiedAt = datetime(),
                                osr.lastModifiedBy = by,
                                acrIdToOsr.createdAt = datetime(),
                                acrIdToOsr.createdBy = by,
                                acrIdToOsr.lastModifiedAt = datetime(),
                                acrIdToOsr.lastModifiedBy = by
                        WITH *
                        UNWIND row.assets AS source_asset
                        MERGE (asset:OrchardAsset {
                            filename: source_asset.filename,
                            extension: "mp3",
                            source: "direct-delivery-db"
                        })
                            ON CREATE SET
                                asset.id = apoc.create.uuid(),
                                asset.createdAt = datetime(),
                                asset.createdBy = by,
                                asset.lastModifiedAt = datetime(),
                                asset.lastModifiedBy = by
                        MERGE (asset)-[assetToAcrId:FINGERPRINTED_AS]->(acrId)
                            ON CREATE SET
                                assetToAcrId.createdAt = datetime(),
                                assetToAcrId.createdBy = by
                            SET
                                assetToAcrId.lastModifiedAt = datetime(),
                                assetToAcrId.lastModifiedBy = by
                        WITH *
                        OPTIONAL MATCH (asset)-[assetToOldAcrId:FINGERPRINTED_AS]->(oldAcrId:ACRID)
                            WHERE oldAcrId <> acrId
                        FOREACH (hasOldAcrId IN CASE WHEN oldAcrId IS NOT NULL THEN [1] ELSE [] END |
                            CREATE (asset)-[deletedRelationship:DELETED_FINGERPRINTED_AS]->(oldAcrId)
                            SET
                                deletedRelationship += assetToOldAcrId,
                                deletedRelationship.deletedAt = datetime(),
                                deletedRelationship.deletedBy = by
                            DELETE assetToOldAcrId
                        )
                        WITH DISTINCT source_asset, by, asset
                        OPTIONAL MATCH (track:Track { id: toInteger(source_asset.tuid) })
                        CALL apoc.util.validate(track IS NULL, "Could not find the track %s", [source_asset.tuid])
                        MERGE (track)-[trackHasAsset:HAS_ASSET]->(asset)
                            ON CREATE SET
                                trackHasAsset.createdAt = datetime(),
                                trackHasAsset.createdBy = by,
                                trackHasAsset.lastModifiedAt = datetime(),
                                trackHasAsset.lastModifiedBy = by
                    ',
                    {
                        batchSize: 1000
                    }
                )
                YIELD failedOperations, errorMessages, failedBatches, batch
                CALL apoc.util.validate(failedOperations > 0, "At least one sub-operation failed: %s", [reduce(all_errors = "", error IN keys(errorMessages) | all_errors + ", " + error)])
                CALL apoc.util.validate(failedBatches > 0, "At least one batch failed: %s", [reduce(all_errors = "", error IN keys(batch.errors) | all_errors + ", " + error)])
                RETURN 0
            ]]>
        </query>
        <query>
            CALL apoc.log.info("Finished acr_cloud data ingest part 82 of 169 at %s", [datetime()]);
        </query>

        <query>
            <![CDATA[
                CALL apoc.periodic.iterate(
                     "
                        WITH 'snowflake_orchard' AS url_alias,
                        '
                            SELECT * FROM facts.qa.jsonified_track_mapping ORDER BY ACR_ID ASC LIMIT 100000 OFFSET 8200000
                        '
                        AS sql
                        CALL apoc.load.jdbc(url_alias, sql)
                        YIELD row
                        return apoc.convert.fromJsonMap(row.NODE) AS row;
                    ",
                    '
                        WITH *, "database/distro-4707" AS by
                        MERGE (acrId:ACRID { id: row.acr_id })
                            ON CREATE SET
                                acrId.createdAt = datetime(),
                                acrId.createdBy = by,
                                acrId.lastModifiedAt = datetime(),
                                acrId.lastModifiedBy = by
                        MERGE (acrId)<-[acrIdToOsr:CONTAINS_FINGERPRINT]-(osr:OrchardSoundRecording)
                            ON CREATE SET
                                osr.id = apoc.create.uuid(),
                                osr.createdAt = datetime(),
                                osr.createdBy = by,
                                osr.lastModifiedAt = datetime(),
                                osr.lastModifiedBy = by,
                                acrIdToOsr.createdAt = datetime(),
                                acrIdToOsr.createdBy = by,
                                acrIdToOsr.lastModifiedAt = datetime(),
                                acrIdToOsr.lastModifiedBy = by
                        WITH *
                        UNWIND row.assets AS source_asset
                        MERGE (asset:OrchardAsset {
                            filename: source_asset.filename,
                            extension: "mp3",
                            source: "direct-delivery-db"
                        })
                            ON CREATE SET
                                asset.id = apoc.create.uuid(),
                                asset.createdAt = datetime(),
                                asset.createdBy = by,
                                asset.lastModifiedAt = datetime(),
                                asset.lastModifiedBy = by
                        MERGE (asset)-[assetToAcrId:FINGERPRINTED_AS]->(acrId)
                            ON CREATE SET
                                assetToAcrId.createdAt = datetime(),
                                assetToAcrId.createdBy = by
                            SET
                                assetToAcrId.lastModifiedAt = datetime(),
                                assetToAcrId.lastModifiedBy = by
                        WITH *
                        OPTIONAL MATCH (asset)-[assetToOldAcrId:FINGERPRINTED_AS]->(oldAcrId:ACRID)
                            WHERE oldAcrId <> acrId
                        FOREACH (hasOldAcrId IN CASE WHEN oldAcrId IS NOT NULL THEN [1] ELSE [] END |
                            CREATE (asset)-[deletedRelationship:DELETED_FINGERPRINTED_AS]->(oldAcrId)
                            SET
                                deletedRelationship += assetToOldAcrId,
                                deletedRelationship.deletedAt = datetime(),
                                deletedRelationship.deletedBy = by
                            DELETE assetToOldAcrId
                        )
                        WITH DISTINCT source_asset, by, asset
                        OPTIONAL MATCH (track:Track { id: toInteger(source_asset.tuid) })
                        CALL apoc.util.validate(track IS NULL, "Could not find the track %s", [source_asset.tuid])
                        MERGE (track)-[trackHasAsset:HAS_ASSET]->(asset)
                            ON CREATE SET
                                trackHasAsset.createdAt = datetime(),
                                trackHasAsset.createdBy = by,
                                trackHasAsset.lastModifiedAt = datetime(),
                                trackHasAsset.lastModifiedBy = by
                    ',
                    {
                        batchSize: 1000
                    }
                )
                YIELD failedOperations, errorMessages, failedBatches, batch
                CALL apoc.util.validate(failedOperations > 0, "At least one sub-operation failed: %s", [reduce(all_errors = "", error IN keys(errorMessages) | all_errors + ", " + error)])
                CALL apoc.util.validate(failedBatches > 0, "At least one batch failed: %s", [reduce(all_errors = "", error IN keys(batch.errors) | all_errors + ", " + error)])
                RETURN 0
            ]]>
        </query>
        <query>
            CALL apoc.log.info("Finished acr_cloud data ingest part 83 of 169 at %s", [datetime()]);
        </query>

        <query>
            <![CDATA[
                CALL apoc.periodic.iterate(
                     "
                        WITH 'snowflake_orchard' AS url_alias,
                        '
                            SELECT * FROM facts.qa.jsonified_track_mapping ORDER BY ACR_ID ASC LIMIT 100000 OFFSET 8300000
                        '
                        AS sql
                        CALL apoc.load.jdbc(url_alias, sql)
                        YIELD row
                        return apoc.convert.fromJsonMap(row.NODE) AS row;
                    ",
                    '
                        WITH *, "database/distro-4707" AS by
                        MERGE (acrId:ACRID { id: row.acr_id })
                            ON CREATE SET
                                acrId.createdAt = datetime(),
                                acrId.createdBy = by,
                                acrId.lastModifiedAt = datetime(),
                                acrId.lastModifiedBy = by
                        MERGE (acrId)<-[acrIdToOsr:CONTAINS_FINGERPRINT]-(osr:OrchardSoundRecording)
                            ON CREATE SET
                                osr.id = apoc.create.uuid(),
                                osr.createdAt = datetime(),
                                osr.createdBy = by,
                                osr.lastModifiedAt = datetime(),
                                osr.lastModifiedBy = by,
                                acrIdToOsr.createdAt = datetime(),
                                acrIdToOsr.createdBy = by,
                                acrIdToOsr.lastModifiedAt = datetime(),
                                acrIdToOsr.lastModifiedBy = by
                        WITH *
                        UNWIND row.assets AS source_asset
                        MERGE (asset:OrchardAsset {
                            filename: source_asset.filename,
                            extension: "mp3",
                            source: "direct-delivery-db"
                        })
                            ON CREATE SET
                                asset.id = apoc.create.uuid(),
                                asset.createdAt = datetime(),
                                asset.createdBy = by,
                                asset.lastModifiedAt = datetime(),
                                asset.lastModifiedBy = by
                        MERGE (asset)-[assetToAcrId:FINGERPRINTED_AS]->(acrId)
                            ON CREATE SET
                                assetToAcrId.createdAt = datetime(),
                                assetToAcrId.createdBy = by
                            SET
                                assetToAcrId.lastModifiedAt = datetime(),
                                assetToAcrId.lastModifiedBy = by
                        WITH *
                        OPTIONAL MATCH (asset)-[assetToOldAcrId:FINGERPRINTED_AS]->(oldAcrId:ACRID)
                            WHERE oldAcrId <> acrId
                        FOREACH (hasOldAcrId IN CASE WHEN oldAcrId IS NOT NULL THEN [1] ELSE [] END |
                            CREATE (asset)-[deletedRelationship:DELETED_FINGERPRINTED_AS]->(oldAcrId)
                            SET
                                deletedRelationship += assetToOldAcrId,
                                deletedRelationship.deletedAt = datetime(),
                                deletedRelationship.deletedBy = by
                            DELETE assetToOldAcrId
                        )
                        WITH DISTINCT source_asset, by, asset
                        OPTIONAL MATCH (track:Track { id: toInteger(source_asset.tuid) })
                        CALL apoc.util.validate(track IS NULL, "Could not find the track %s", [source_asset.tuid])
                        MERGE (track)-[trackHasAsset:HAS_ASSET]->(asset)
                            ON CREATE SET
                                trackHasAsset.createdAt = datetime(),
                                trackHasAsset.createdBy = by,
                                trackHasAsset.lastModifiedAt = datetime(),
                                trackHasAsset.lastModifiedBy = by
                    ',
                    {
                        batchSize: 1000
                    }
                )
                YIELD failedOperations, errorMessages, failedBatches, batch
                CALL apoc.util.validate(failedOperations > 0, "At least one sub-operation failed: %s", [reduce(all_errors = "", error IN keys(errorMessages) | all_errors + ", " + error)])
                CALL apoc.util.validate(failedBatches > 0, "At least one batch failed: %s", [reduce(all_errors = "", error IN keys(batch.errors) | all_errors + ", " + error)])
                RETURN 0
            ]]>
        </query>
        <query>
            CALL apoc.log.info("Finished acr_cloud data ingest part 84 of 169 at %s", [datetime()]);
        </query>

        <query>
            <![CDATA[
                CALL apoc.periodic.iterate(
                     "
                        WITH 'snowflake_orchard' AS url_alias,
                        '
                            SELECT * FROM facts.qa.jsonified_track_mapping ORDER BY ACR_ID ASC LIMIT 100000 OFFSET 8400000
                        '
                        AS sql
                        CALL apoc.load.jdbc(url_alias, sql)
                        YIELD row
                        return apoc.convert.fromJsonMap(row.NODE) AS row;
                    ",
                    '
                        WITH *, "database/distro-4707" AS by
                        MERGE (acrId:ACRID { id: row.acr_id })
                            ON CREATE SET
                                acrId.createdAt = datetime(),
                                acrId.createdBy = by,
                                acrId.lastModifiedAt = datetime(),
                                acrId.lastModifiedBy = by
                        MERGE (acrId)<-[acrIdToOsr:CONTAINS_FINGERPRINT]-(osr:OrchardSoundRecording)
                            ON CREATE SET
                                osr.id = apoc.create.uuid(),
                                osr.createdAt = datetime(),
                                osr.createdBy = by,
                                osr.lastModifiedAt = datetime(),
                                osr.lastModifiedBy = by,
                                acrIdToOsr.createdAt = datetime(),
                                acrIdToOsr.createdBy = by,
                                acrIdToOsr.lastModifiedAt = datetime(),
                                acrIdToOsr.lastModifiedBy = by
                        WITH *
                        UNWIND row.assets AS source_asset
                        MERGE (asset:OrchardAsset {
                            filename: source_asset.filename,
                            extension: "mp3",
                            source: "direct-delivery-db"
                        })
                            ON CREATE SET
                                asset.id = apoc.create.uuid(),
                                asset.createdAt = datetime(),
                                asset.createdBy = by,
                                asset.lastModifiedAt = datetime(),
                                asset.lastModifiedBy = by
                        MERGE (asset)-[assetToAcrId:FINGERPRINTED_AS]->(acrId)
                            ON CREATE SET
                                assetToAcrId.createdAt = datetime(),
                                assetToAcrId.createdBy = by
                            SET
                                assetToAcrId.lastModifiedAt = datetime(),
                                assetToAcrId.lastModifiedBy = by
                        WITH *
                        OPTIONAL MATCH (asset)-[assetToOldAcrId:FINGERPRINTED_AS]->(oldAcrId:ACRID)
                            WHERE oldAcrId <> acrId
                        FOREACH (hasOldAcrId IN CASE WHEN oldAcrId IS NOT NULL THEN [1] ELSE [] END |
                            CREATE (asset)-[deletedRelationship:DELETED_FINGERPRINTED_AS]->(oldAcrId)
                            SET
                                deletedRelationship += assetToOldAcrId,
                                deletedRelationship.deletedAt = datetime(),
                                deletedRelationship.deletedBy = by
                            DELETE assetToOldAcrId
                        )
                        WITH DISTINCT source_asset, by, asset
                        OPTIONAL MATCH (track:Track { id: toInteger(source_asset.tuid) })
                        CALL apoc.util.validate(track IS NULL, "Could not find the track %s", [source_asset.tuid])
                        MERGE (track)-[trackHasAsset:HAS_ASSET]->(asset)
                            ON CREATE SET
                                trackHasAsset.createdAt = datetime(),
                                trackHasAsset.createdBy = by,
                                trackHasAsset.lastModifiedAt = datetime(),
                                trackHasAsset.lastModifiedBy = by
                    ',
                    {
                        batchSize: 1000
                    }
                )
                YIELD failedOperations, errorMessages, failedBatches, batch
                CALL apoc.util.validate(failedOperations > 0, "At least one sub-operation failed: %s", [reduce(all_errors = "", error IN keys(errorMessages) | all_errors + ", " + error)])
                CALL apoc.util.validate(failedBatches > 0, "At least one batch failed: %s", [reduce(all_errors = "", error IN keys(batch.errors) | all_errors + ", " + error)])
                RETURN 0
            ]]>
        </query>
        <query>
            CALL apoc.log.info("Finished acr_cloud data ingest part 85 of 169 at %s", [datetime()]);
        </query>

        <query>
            <![CDATA[
                CALL apoc.periodic.iterate(
                     "
                        WITH 'snowflake_orchard' AS url_alias,
                        '
                            SELECT * FROM facts.qa.jsonified_track_mapping ORDER BY ACR_ID ASC LIMIT 100000 OFFSET 8500000
                        '
                        AS sql
                        CALL apoc.load.jdbc(url_alias, sql)
                        YIELD row
                        return apoc.convert.fromJsonMap(row.NODE) AS row;
                    ",
                    '
                        WITH *, "database/distro-4707" AS by
                        MERGE (acrId:ACRID { id: row.acr_id })
                            ON CREATE SET
                                acrId.createdAt = datetime(),
                                acrId.createdBy = by,
                                acrId.lastModifiedAt = datetime(),
                                acrId.lastModifiedBy = by
                        MERGE (acrId)<-[acrIdToOsr:CONTAINS_FINGERPRINT]-(osr:OrchardSoundRecording)
                            ON CREATE SET
                                osr.id = apoc.create.uuid(),
                                osr.createdAt = datetime(),
                                osr.createdBy = by,
                                osr.lastModifiedAt = datetime(),
                                osr.lastModifiedBy = by,
                                acrIdToOsr.createdAt = datetime(),
                                acrIdToOsr.createdBy = by,
                                acrIdToOsr.lastModifiedAt = datetime(),
                                acrIdToOsr.lastModifiedBy = by
                        WITH *
                        UNWIND row.assets AS source_asset
                        MERGE (asset:OrchardAsset {
                            filename: source_asset.filename,
                            extension: "mp3",
                            source: "direct-delivery-db"
                        })
                            ON CREATE SET
                                asset.id = apoc.create.uuid(),
                                asset.createdAt = datetime(),
                                asset.createdBy = by,
                                asset.lastModifiedAt = datetime(),
                                asset.lastModifiedBy = by
                        MERGE (asset)-[assetToAcrId:FINGERPRINTED_AS]->(acrId)
                            ON CREATE SET
                                assetToAcrId.createdAt = datetime(),
                                assetToAcrId.createdBy = by
                            SET
                                assetToAcrId.lastModifiedAt = datetime(),
                                assetToAcrId.lastModifiedBy = by
                        WITH *
                        OPTIONAL MATCH (asset)-[assetToOldAcrId:FINGERPRINTED_AS]->(oldAcrId:ACRID)
                            WHERE oldAcrId <> acrId
                        FOREACH (hasOldAcrId IN CASE WHEN oldAcrId IS NOT NULL THEN [1] ELSE [] END |
                            CREATE (asset)-[deletedRelationship:DELETED_FINGERPRINTED_AS]->(oldAcrId)
                            SET
                                deletedRelationship += assetToOldAcrId,
                                deletedRelationship.deletedAt = datetime(),
                                deletedRelationship.deletedBy = by
                            DELETE assetToOldAcrId
                        )
                        WITH DISTINCT source_asset, by, asset
                        OPTIONAL MATCH (track:Track { id: toInteger(source_asset.tuid) })
                        CALL apoc.util.validate(track IS NULL, "Could not find the track %s", [source_asset.tuid])
                        MERGE (track)-[trackHasAsset:HAS_ASSET]->(asset)
                            ON CREATE SET
                                trackHasAsset.createdAt = datetime(),
                                trackHasAsset.createdBy = by,
                                trackHasAsset.lastModifiedAt = datetime(),
                                trackHasAsset.lastModifiedBy = by
                    ',
                    {
                        batchSize: 1000
                    }
                )
                YIELD failedOperations, errorMessages, failedBatches, batch
                CALL apoc.util.validate(failedOperations > 0, "At least one sub-operation failed: %s", [reduce(all_errors = "", error IN keys(errorMessages) | all_errors + ", " + error)])
                CALL apoc.util.validate(failedBatches > 0, "At least one batch failed: %s", [reduce(all_errors = "", error IN keys(batch.errors) | all_errors + ", " + error)])
                RETURN 0
            ]]>
        </query>
        <query>
            CALL apoc.log.info("Finished acr_cloud data ingest part 86 of 169 at %s", [datetime()]);
        </query>

        <query>
            <![CDATA[
                CALL apoc.periodic.iterate(
                     "
                        WITH 'snowflake_orchard' AS url_alias,
                        '
                            SELECT * FROM facts.qa.jsonified_track_mapping ORDER BY ACR_ID ASC LIMIT 100000 OFFSET 8600000
                        '
                        AS sql
                        CALL apoc.load.jdbc(url_alias, sql)
                        YIELD row
                        return apoc.convert.fromJsonMap(row.NODE) AS row;
                    ",
                    '
                        WITH *, "database/distro-4707" AS by
                        MERGE (acrId:ACRID { id: row.acr_id })
                            ON CREATE SET
                                acrId.createdAt = datetime(),
                                acrId.createdBy = by,
                                acrId.lastModifiedAt = datetime(),
                                acrId.lastModifiedBy = by
                        MERGE (acrId)<-[acrIdToOsr:CONTAINS_FINGERPRINT]-(osr:OrchardSoundRecording)
                            ON CREATE SET
                                osr.id = apoc.create.uuid(),
                                osr.createdAt = datetime(),
                                osr.createdBy = by,
                                osr.lastModifiedAt = datetime(),
                                osr.lastModifiedBy = by,
                                acrIdToOsr.createdAt = datetime(),
                                acrIdToOsr.createdBy = by,
                                acrIdToOsr.lastModifiedAt = datetime(),
                                acrIdToOsr.lastModifiedBy = by
                        WITH *
                        UNWIND row.assets AS source_asset
                        MERGE (asset:OrchardAsset {
                            filename: source_asset.filename,
                            extension: "mp3",
                            source: "direct-delivery-db"
                        })
                            ON CREATE SET
                                asset.id = apoc.create.uuid(),
                                asset.createdAt = datetime(),
                                asset.createdBy = by,
                                asset.lastModifiedAt = datetime(),
                                asset.lastModifiedBy = by
                        MERGE (asset)-[assetToAcrId:FINGERPRINTED_AS]->(acrId)
                            ON CREATE SET
                                assetToAcrId.createdAt = datetime(),
                                assetToAcrId.createdBy = by
                            SET
                                assetToAcrId.lastModifiedAt = datetime(),
                                assetToAcrId.lastModifiedBy = by
                        WITH *
                        OPTIONAL MATCH (asset)-[assetToOldAcrId:FINGERPRINTED_AS]->(oldAcrId:ACRID)
                            WHERE oldAcrId <> acrId
                        FOREACH (hasOldAcrId IN CASE WHEN oldAcrId IS NOT NULL THEN [1] ELSE [] END |
                            CREATE (asset)-[deletedRelationship:DELETED_FINGERPRINTED_AS]->(oldAcrId)
                            SET
                                deletedRelationship += assetToOldAcrId,
                                deletedRelationship.deletedAt = datetime(),
                                deletedRelationship.deletedBy = by
                            DELETE assetToOldAcrId
                        )
                        WITH DISTINCT source_asset, by, asset
                        OPTIONAL MATCH (track:Track { id: toInteger(source_asset.tuid) })
                        CALL apoc.util.validate(track IS NULL, "Could not find the track %s", [source_asset.tuid])
                        MERGE (track)-[trackHasAsset:HAS_ASSET]->(asset)
                            ON CREATE SET
                                trackHasAsset.createdAt = datetime(),
                                trackHasAsset.createdBy = by,
                                trackHasAsset.lastModifiedAt = datetime(),
                                trackHasAsset.lastModifiedBy = by
                    ',
                    {
                        batchSize: 1000
                    }
                )
                YIELD failedOperations, errorMessages, failedBatches, batch
                CALL apoc.util.validate(failedOperations > 0, "At least one sub-operation failed: %s", [reduce(all_errors = "", error IN keys(errorMessages) | all_errors + ", " + error)])
                CALL apoc.util.validate(failedBatches > 0, "At least one batch failed: %s", [reduce(all_errors = "", error IN keys(batch.errors) | all_errors + ", " + error)])
                RETURN 0
            ]]>
        </query>
        <query>
            CALL apoc.log.info("Finished acr_cloud data ingest part 87 of 169 at %s", [datetime()]);
        </query>

        <query>
            <![CDATA[
                CALL apoc.periodic.iterate(
                     "
                        WITH 'snowflake_orchard' AS url_alias,
                        '
                            SELECT * FROM facts.qa.jsonified_track_mapping ORDER BY ACR_ID ASC LIMIT 100000 OFFSET 8700000
                        '
                        AS sql
                        CALL apoc.load.jdbc(url_alias, sql)
                        YIELD row
                        return apoc.convert.fromJsonMap(row.NODE) AS row;
                    ",
                    '
                        WITH *, "database/distro-4707" AS by
                        MERGE (acrId:ACRID { id: row.acr_id })
                            ON CREATE SET
                                acrId.createdAt = datetime(),
                                acrId.createdBy = by,
                                acrId.lastModifiedAt = datetime(),
                                acrId.lastModifiedBy = by
                        MERGE (acrId)<-[acrIdToOsr:CONTAINS_FINGERPRINT]-(osr:OrchardSoundRecording)
                            ON CREATE SET
                                osr.id = apoc.create.uuid(),
                                osr.createdAt = datetime(),
                                osr.createdBy = by,
                                osr.lastModifiedAt = datetime(),
                                osr.lastModifiedBy = by,
                                acrIdToOsr.createdAt = datetime(),
                                acrIdToOsr.createdBy = by,
                                acrIdToOsr.lastModifiedAt = datetime(),
                                acrIdToOsr.lastModifiedBy = by
                        WITH *
                        UNWIND row.assets AS source_asset
                        MERGE (asset:OrchardAsset {
                            filename: source_asset.filename,
                            extension: "mp3",
                            source: "direct-delivery-db"
                        })
                            ON CREATE SET
                                asset.id = apoc.create.uuid(),
                                asset.createdAt = datetime(),
                                asset.createdBy = by,
                                asset.lastModifiedAt = datetime(),
                                asset.lastModifiedBy = by
                        MERGE (asset)-[assetToAcrId:FINGERPRINTED_AS]->(acrId)
                            ON CREATE SET
                                assetToAcrId.createdAt = datetime(),
                                assetToAcrId.createdBy = by
                            SET
                                assetToAcrId.lastModifiedAt = datetime(),
                                assetToAcrId.lastModifiedBy = by
                        WITH *
                        OPTIONAL MATCH (asset)-[assetToOldAcrId:FINGERPRINTED_AS]->(oldAcrId:ACRID)
                            WHERE oldAcrId <> acrId
                        FOREACH (hasOldAcrId IN CASE WHEN oldAcrId IS NOT NULL THEN [1] ELSE [] END |
                            CREATE (asset)-[deletedRelationship:DELETED_FINGERPRINTED_AS]->(oldAcrId)
                            SET
                                deletedRelationship += assetToOldAcrId,
                                deletedRelationship.deletedAt = datetime(),
                                deletedRelationship.deletedBy = by
                            DELETE assetToOldAcrId
                        )
                        WITH DISTINCT source_asset, by, asset
                        OPTIONAL MATCH (track:Track { id: toInteger(source_asset.tuid) })
                        CALL apoc.util.validate(track IS NULL, "Could not find the track %s", [source_asset.tuid])
                        MERGE (track)-[trackHasAsset:HAS_ASSET]->(asset)
                            ON CREATE SET
                                trackHasAsset.createdAt = datetime(),
                                trackHasAsset.createdBy = by,
                                trackHasAsset.lastModifiedAt = datetime(),
                                trackHasAsset.lastModifiedBy = by
                    ',
                    {
                        batchSize: 1000
                    }
                )
                YIELD failedOperations, errorMessages, failedBatches, batch
                CALL apoc.util.validate(failedOperations > 0, "At least one sub-operation failed: %s", [reduce(all_errors = "", error IN keys(errorMessages) | all_errors + ", " + error)])
                CALL apoc.util.validate(failedBatches > 0, "At least one batch failed: %s", [reduce(all_errors = "", error IN keys(batch.errors) | all_errors + ", " + error)])
                RETURN 0
            ]]>
        </query>
        <query>
            CALL apoc.log.info("Finished acr_cloud data ingest part 88 of 169 at %s", [datetime()]);
        </query>

        <query>
            <![CDATA[
                CALL apoc.periodic.iterate(
                     "
                        WITH 'snowflake_orchard' AS url_alias,
                        '
                            SELECT * FROM facts.qa.jsonified_track_mapping ORDER BY ACR_ID ASC LIMIT 100000 OFFSET 8800000
                        '
                        AS sql
                        CALL apoc.load.jdbc(url_alias, sql)
                        YIELD row
                        return apoc.convert.fromJsonMap(row.NODE) AS row;
                    ",
                    '
                        WITH *, "database/distro-4707" AS by
                        MERGE (acrId:ACRID { id: row.acr_id })
                            ON CREATE SET
                                acrId.createdAt = datetime(),
                                acrId.createdBy = by,
                                acrId.lastModifiedAt = datetime(),
                                acrId.lastModifiedBy = by
                        MERGE (acrId)<-[acrIdToOsr:CONTAINS_FINGERPRINT]-(osr:OrchardSoundRecording)
                            ON CREATE SET
                                osr.id = apoc.create.uuid(),
                                osr.createdAt = datetime(),
                                osr.createdBy = by,
                                osr.lastModifiedAt = datetime(),
                                osr.lastModifiedBy = by,
                                acrIdToOsr.createdAt = datetime(),
                                acrIdToOsr.createdBy = by,
                                acrIdToOsr.lastModifiedAt = datetime(),
                                acrIdToOsr.lastModifiedBy = by
                        WITH *
                        UNWIND row.assets AS source_asset
                        MERGE (asset:OrchardAsset {
                            filename: source_asset.filename,
                            extension: "mp3",
                            source: "direct-delivery-db"
                        })
                            ON CREATE SET
                                asset.id = apoc.create.uuid(),
                                asset.createdAt = datetime(),
                                asset.createdBy = by,
                                asset.lastModifiedAt = datetime(),
                                asset.lastModifiedBy = by
                        MERGE (asset)-[assetToAcrId:FINGERPRINTED_AS]->(acrId)
                            ON CREATE SET
                                assetToAcrId.createdAt = datetime(),
                                assetToAcrId.createdBy = by
                            SET
                                assetToAcrId.lastModifiedAt = datetime(),
                                assetToAcrId.lastModifiedBy = by
                        WITH *
                        OPTIONAL MATCH (asset)-[assetToOldAcrId:FINGERPRINTED_AS]->(oldAcrId:ACRID)
                            WHERE oldAcrId <> acrId
                        FOREACH (hasOldAcrId IN CASE WHEN oldAcrId IS NOT NULL THEN [1] ELSE [] END |
                            CREATE (asset)-[deletedRelationship:DELETED_FINGERPRINTED_AS]->(oldAcrId)
                            SET
                                deletedRelationship += assetToOldAcrId,
                                deletedRelationship.deletedAt = datetime(),
                                deletedRelationship.deletedBy = by
                            DELETE assetToOldAcrId
                        )
                        WITH DISTINCT source_asset, by, asset
                        OPTIONAL MATCH (track:Track { id: toInteger(source_asset.tuid) })
                        CALL apoc.util.validate(track IS NULL, "Could not find the track %s", [source_asset.tuid])
                        MERGE (track)-[trackHasAsset:HAS_ASSET]->(asset)
                            ON CREATE SET
                                trackHasAsset.createdAt = datetime(),
                                trackHasAsset.createdBy = by,
                                trackHasAsset.lastModifiedAt = datetime(),
                                trackHasAsset.lastModifiedBy = by
                    ',
                    {
                        batchSize: 1000
                    }
                )
                YIELD failedOperations, errorMessages, failedBatches, batch
                CALL apoc.util.validate(failedOperations > 0, "At least one sub-operation failed: %s", [reduce(all_errors = "", error IN keys(errorMessages) | all_errors + ", " + error)])
                CALL apoc.util.validate(failedBatches > 0, "At least one batch failed: %s", [reduce(all_errors = "", error IN keys(batch.errors) | all_errors + ", " + error)])
                RETURN 0
            ]]>
        </query>
        <query>
            CALL apoc.log.info("Finished acr_cloud data ingest part 89 of 169 at %s", [datetime()]);
        </query>

        <query>
            <![CDATA[
                CALL apoc.periodic.iterate(
                     "
                        WITH 'snowflake_orchard' AS url_alias,
                        '
                            SELECT * FROM facts.qa.jsonified_track_mapping ORDER BY ACR_ID ASC LIMIT 100000 OFFSET 8900000
                        '
                        AS sql
                        CALL apoc.load.jdbc(url_alias, sql)
                        YIELD row
                        return apoc.convert.fromJsonMap(row.NODE) AS row;
                    ",
                    '
                        WITH *, "database/distro-4707" AS by
                        MERGE (acrId:ACRID { id: row.acr_id })
                            ON CREATE SET
                                acrId.createdAt = datetime(),
                                acrId.createdBy = by,
                                acrId.lastModifiedAt = datetime(),
                                acrId.lastModifiedBy = by
                        MERGE (acrId)<-[acrIdToOsr:CONTAINS_FINGERPRINT]-(osr:OrchardSoundRecording)
                            ON CREATE SET
                                osr.id = apoc.create.uuid(),
                                osr.createdAt = datetime(),
                                osr.createdBy = by,
                                osr.lastModifiedAt = datetime(),
                                osr.lastModifiedBy = by,
                                acrIdToOsr.createdAt = datetime(),
                                acrIdToOsr.createdBy = by,
                                acrIdToOsr.lastModifiedAt = datetime(),
                                acrIdToOsr.lastModifiedBy = by
                        WITH *
                        UNWIND row.assets AS source_asset
                        MERGE (asset:OrchardAsset {
                            filename: source_asset.filename,
                            extension: "mp3",
                            source: "direct-delivery-db"
                        })
                            ON CREATE SET
                                asset.id = apoc.create.uuid(),
                                asset.createdAt = datetime(),
                                asset.createdBy = by,
                                asset.lastModifiedAt = datetime(),
                                asset.lastModifiedBy = by
                        MERGE (asset)-[assetToAcrId:FINGERPRINTED_AS]->(acrId)
                            ON CREATE SET
                                assetToAcrId.createdAt = datetime(),
                                assetToAcrId.createdBy = by
                            SET
                                assetToAcrId.lastModifiedAt = datetime(),
                                assetToAcrId.lastModifiedBy = by
                        WITH *
                        OPTIONAL MATCH (asset)-[assetToOldAcrId:FINGERPRINTED_AS]->(oldAcrId:ACRID)
                            WHERE oldAcrId <> acrId
                        FOREACH (hasOldAcrId IN CASE WHEN oldAcrId IS NOT NULL THEN [1] ELSE [] END |
                            CREATE (asset)-[deletedRelationship:DELETED_FINGERPRINTED_AS]->(oldAcrId)
                            SET
                                deletedRelationship += assetToOldAcrId,
                                deletedRelationship.deletedAt = datetime(),
                                deletedRelationship.deletedBy = by
                            DELETE assetToOldAcrId
                        )
                        WITH DISTINCT source_asset, by, asset
                        OPTIONAL MATCH (track:Track { id: toInteger(source_asset.tuid) })
                        CALL apoc.util.validate(track IS NULL, "Could not find the track %s", [source_asset.tuid])
                        MERGE (track)-[trackHasAsset:HAS_ASSET]->(asset)
                            ON CREATE SET
                                trackHasAsset.createdAt = datetime(),
                                trackHasAsset.createdBy = by,
                                trackHasAsset.lastModifiedAt = datetime(),
                                trackHasAsset.lastModifiedBy = by
                    ',
                    {
                        batchSize: 1000
                    }
                )
                YIELD failedOperations, errorMessages, failedBatches, batch
                CALL apoc.util.validate(failedOperations > 0, "At least one sub-operation failed: %s", [reduce(all_errors = "", error IN keys(errorMessages) | all_errors + ", " + error)])
                CALL apoc.util.validate(failedBatches > 0, "At least one batch failed: %s", [reduce(all_errors = "", error IN keys(batch.errors) | all_errors + ", " + error)])
                RETURN 0
            ]]>
        </query>
        <query>
            CALL apoc.log.info("Finished acr_cloud data ingest part 90 of 169 at %s", [datetime()]);
        </query>

        <query>
            <![CDATA[
                CALL apoc.periodic.iterate(
                     "
                        WITH 'snowflake_orchard' AS url_alias,
                        '
                            SELECT * FROM facts.qa.jsonified_track_mapping ORDER BY ACR_ID ASC LIMIT 100000 OFFSET 9000000
                        '
                        AS sql
                        CALL apoc.load.jdbc(url_alias, sql)
                        YIELD row
                        return apoc.convert.fromJsonMap(row.NODE) AS row;
                    ",
                    '
                        WITH *, "database/distro-4707" AS by
                        MERGE (acrId:ACRID { id: row.acr_id })
                            ON CREATE SET
                                acrId.createdAt = datetime(),
                                acrId.createdBy = by,
                                acrId.lastModifiedAt = datetime(),
                                acrId.lastModifiedBy = by
                        MERGE (acrId)<-[acrIdToOsr:CONTAINS_FINGERPRINT]-(osr:OrchardSoundRecording)
                            ON CREATE SET
                                osr.id = apoc.create.uuid(),
                                osr.createdAt = datetime(),
                                osr.createdBy = by,
                                osr.lastModifiedAt = datetime(),
                                osr.lastModifiedBy = by,
                                acrIdToOsr.createdAt = datetime(),
                                acrIdToOsr.createdBy = by,
                                acrIdToOsr.lastModifiedAt = datetime(),
                                acrIdToOsr.lastModifiedBy = by
                        WITH *
                        UNWIND row.assets AS source_asset
                        MERGE (asset:OrchardAsset {
                            filename: source_asset.filename,
                            extension: "mp3",
                            source: "direct-delivery-db"
                        })
                            ON CREATE SET
                                asset.id = apoc.create.uuid(),
                                asset.createdAt = datetime(),
                                asset.createdBy = by,
                                asset.lastModifiedAt = datetime(),
                                asset.lastModifiedBy = by
                        MERGE (asset)-[assetToAcrId:FINGERPRINTED_AS]->(acrId)
                            ON CREATE SET
                                assetToAcrId.createdAt = datetime(),
                                assetToAcrId.createdBy = by
                            SET
                                assetToAcrId.lastModifiedAt = datetime(),
                                assetToAcrId.lastModifiedBy = by
                        WITH *
                        OPTIONAL MATCH (asset)-[assetToOldAcrId:FINGERPRINTED_AS]->(oldAcrId:ACRID)
                            WHERE oldAcrId <> acrId
                        FOREACH (hasOldAcrId IN CASE WHEN oldAcrId IS NOT NULL THEN [1] ELSE [] END |
                            CREATE (asset)-[deletedRelationship:DELETED_FINGERPRINTED_AS]->(oldAcrId)
                            SET
                                deletedRelationship += assetToOldAcrId,
                                deletedRelationship.deletedAt = datetime(),
                                deletedRelationship.deletedBy = by
                            DELETE assetToOldAcrId
                        )
                        WITH DISTINCT source_asset, by, asset
                        OPTIONAL MATCH (track:Track { id: toInteger(source_asset.tuid) })
                        CALL apoc.util.validate(track IS NULL, "Could not find the track %s", [source_asset.tuid])
                        MERGE (track)-[trackHasAsset:HAS_ASSET]->(asset)
                            ON CREATE SET
                                trackHasAsset.createdAt = datetime(),
                                trackHasAsset.createdBy = by,
                                trackHasAsset.lastModifiedAt = datetime(),
                                trackHasAsset.lastModifiedBy = by
                    ',
                    {
                        batchSize: 1000
                    }
                )
                YIELD failedOperations, errorMessages, failedBatches, batch
                CALL apoc.util.validate(failedOperations > 0, "At least one sub-operation failed: %s", [reduce(all_errors = "", error IN keys(errorMessages) | all_errors + ", " + error)])
                CALL apoc.util.validate(failedBatches > 0, "At least one batch failed: %s", [reduce(all_errors = "", error IN keys(batch.errors) | all_errors + ", " + error)])
                RETURN 0
            ]]>
        </query>
        <query>
            CALL apoc.log.info("Finished acr_cloud data ingest part 91 of 169 at %s", [datetime()]);
        </query>

        <query>
            <![CDATA[
                CALL apoc.periodic.iterate(
                     "
                        WITH 'snowflake_orchard' AS url_alias,
                        '
                            SELECT * FROM facts.qa.jsonified_track_mapping ORDER BY ACR_ID ASC LIMIT 100000 OFFSET 9100000
                        '
                        AS sql
                        CALL apoc.load.jdbc(url_alias, sql)
                        YIELD row
                        return apoc.convert.fromJsonMap(row.NODE) AS row;
                    ",
                    '
                        WITH *, "database/distro-4707" AS by
                        MERGE (acrId:ACRID { id: row.acr_id })
                            ON CREATE SET
                                acrId.createdAt = datetime(),
                                acrId.createdBy = by,
                                acrId.lastModifiedAt = datetime(),
                                acrId.lastModifiedBy = by
                        MERGE (acrId)<-[acrIdToOsr:CONTAINS_FINGERPRINT]-(osr:OrchardSoundRecording)
                            ON CREATE SET
                                osr.id = apoc.create.uuid(),
                                osr.createdAt = datetime(),
                                osr.createdBy = by,
                                osr.lastModifiedAt = datetime(),
                                osr.lastModifiedBy = by,
                                acrIdToOsr.createdAt = datetime(),
                                acrIdToOsr.createdBy = by,
                                acrIdToOsr.lastModifiedAt = datetime(),
                                acrIdToOsr.lastModifiedBy = by
                        WITH *
                        UNWIND row.assets AS source_asset
                        MERGE (asset:OrchardAsset {
                            filename: source_asset.filename,
                            extension: "mp3",
                            source: "direct-delivery-db"
                        })
                            ON CREATE SET
                                asset.id = apoc.create.uuid(),
                                asset.createdAt = datetime(),
                                asset.createdBy = by,
                                asset.lastModifiedAt = datetime(),
                                asset.lastModifiedBy = by
                        MERGE (asset)-[assetToAcrId:FINGERPRINTED_AS]->(acrId)
                            ON CREATE SET
                                assetToAcrId.createdAt = datetime(),
                                assetToAcrId.createdBy = by
                            SET
                                assetToAcrId.lastModifiedAt = datetime(),
                                assetToAcrId.lastModifiedBy = by
                        WITH *
                        OPTIONAL MATCH (asset)-[assetToOldAcrId:FINGERPRINTED_AS]->(oldAcrId:ACRID)
                            WHERE oldAcrId <> acrId
                        FOREACH (hasOldAcrId IN CASE WHEN oldAcrId IS NOT NULL THEN [1] ELSE [] END |
                            CREATE (asset)-[deletedRelationship:DELETED_FINGERPRINTED_AS]->(oldAcrId)
                            SET
                                deletedRelationship += assetToOldAcrId,
                                deletedRelationship.deletedAt = datetime(),
                                deletedRelationship.deletedBy = by
                            DELETE assetToOldAcrId
                        )
                        WITH DISTINCT source_asset, by, asset
                        OPTIONAL MATCH (track:Track { id: toInteger(source_asset.tuid) })
                        CALL apoc.util.validate(track IS NULL, "Could not find the track %s", [source_asset.tuid])
                        MERGE (track)-[trackHasAsset:HAS_ASSET]->(asset)
                            ON CREATE SET
                                trackHasAsset.createdAt = datetime(),
                                trackHasAsset.createdBy = by,
                                trackHasAsset.lastModifiedAt = datetime(),
                                trackHasAsset.lastModifiedBy = by
                    ',
                    {
                        batchSize: 1000
                    }
                )
                YIELD failedOperations, errorMessages, failedBatches, batch
                CALL apoc.util.validate(failedOperations > 0, "At least one sub-operation failed: %s", [reduce(all_errors = "", error IN keys(errorMessages) | all_errors + ", " + error)])
                CALL apoc.util.validate(failedBatches > 0, "At least one batch failed: %s", [reduce(all_errors = "", error IN keys(batch.errors) | all_errors + ", " + error)])
                RETURN 0
            ]]>
        </query>
        <query>
            CALL apoc.log.info("Finished acr_cloud data ingest part 92 of 169 at %s", [datetime()]);
        </query>

        <query>
            <![CDATA[
                CALL apoc.periodic.iterate(
                     "
                        WITH 'snowflake_orchard' AS url_alias,
                        '
                            SELECT * FROM facts.qa.jsonified_track_mapping ORDER BY ACR_ID ASC LIMIT 100000 OFFSET 9200000
                        '
                        AS sql
                        CALL apoc.load.jdbc(url_alias, sql)
                        YIELD row
                        return apoc.convert.fromJsonMap(row.NODE) AS row;
                    ",
                    '
                        WITH *, "database/distro-4707" AS by
                        MERGE (acrId:ACRID { id: row.acr_id })
                            ON CREATE SET
                                acrId.createdAt = datetime(),
                                acrId.createdBy = by,
                                acrId.lastModifiedAt = datetime(),
                                acrId.lastModifiedBy = by
                        MERGE (acrId)<-[acrIdToOsr:CONTAINS_FINGERPRINT]-(osr:OrchardSoundRecording)
                            ON CREATE SET
                                osr.id = apoc.create.uuid(),
                                osr.createdAt = datetime(),
                                osr.createdBy = by,
                                osr.lastModifiedAt = datetime(),
                                osr.lastModifiedBy = by,
                                acrIdToOsr.createdAt = datetime(),
                                acrIdToOsr.createdBy = by,
                                acrIdToOsr.lastModifiedAt = datetime(),
                                acrIdToOsr.lastModifiedBy = by
                        WITH *
                        UNWIND row.assets AS source_asset
                        MERGE (asset:OrchardAsset {
                            filename: source_asset.filename,
                            extension: "mp3",
                            source: "direct-delivery-db"
                        })
                            ON CREATE SET
                                asset.id = apoc.create.uuid(),
                                asset.createdAt = datetime(),
                                asset.createdBy = by,
                                asset.lastModifiedAt = datetime(),
                                asset.lastModifiedBy = by
                        MERGE (asset)-[assetToAcrId:FINGERPRINTED_AS]->(acrId)
                            ON CREATE SET
                                assetToAcrId.createdAt = datetime(),
                                assetToAcrId.createdBy = by
                            SET
                                assetToAcrId.lastModifiedAt = datetime(),
                                assetToAcrId.lastModifiedBy = by
                        WITH *
                        OPTIONAL MATCH (asset)-[assetToOldAcrId:FINGERPRINTED_AS]->(oldAcrId:ACRID)
                            WHERE oldAcrId <> acrId
                        FOREACH (hasOldAcrId IN CASE WHEN oldAcrId IS NOT NULL THEN [1] ELSE [] END |
                            CREATE (asset)-[deletedRelationship:DELETED_FINGERPRINTED_AS]->(oldAcrId)
                            SET
                                deletedRelationship += assetToOldAcrId,
                                deletedRelationship.deletedAt = datetime(),
                                deletedRelationship.deletedBy = by
                            DELETE assetToOldAcrId
                        )
                        WITH DISTINCT source_asset, by, asset
                        OPTIONAL MATCH (track:Track { id: toInteger(source_asset.tuid) })
                        CALL apoc.util.validate(track IS NULL, "Could not find the track %s", [source_asset.tuid])
                        MERGE (track)-[trackHasAsset:HAS_ASSET]->(asset)
                            ON CREATE SET
                                trackHasAsset.createdAt = datetime(),
                                trackHasAsset.createdBy = by,
                                trackHasAsset.lastModifiedAt = datetime(),
                                trackHasAsset.lastModifiedBy = by
                    ',
                    {
                        batchSize: 1000
                    }
                )
                YIELD failedOperations, errorMessages, failedBatches, batch
                CALL apoc.util.validate(failedOperations > 0, "At least one sub-operation failed: %s", [reduce(all_errors = "", error IN keys(errorMessages) | all_errors + ", " + error)])
                CALL apoc.util.validate(failedBatches > 0, "At least one batch failed: %s", [reduce(all_errors = "", error IN keys(batch.errors) | all_errors + ", " + error)])
                RETURN 0
            ]]>
        </query>
        <query>
            CALL apoc.log.info("Finished acr_cloud data ingest part 93 of 169 at %s", [datetime()]);
        </query>

        <query>
            <![CDATA[
                CALL apoc.periodic.iterate(
                     "
                        WITH 'snowflake_orchard' AS url_alias,
                        '
                            SELECT * FROM facts.qa.jsonified_track_mapping ORDER BY ACR_ID ASC LIMIT 100000 OFFSET 9300000
                        '
                        AS sql
                        CALL apoc.load.jdbc(url_alias, sql)
                        YIELD row
                        return apoc.convert.fromJsonMap(row.NODE) AS row;
                    ",
                    '
                        WITH *, "database/distro-4707" AS by
                        MERGE (acrId:ACRID { id: row.acr_id })
                            ON CREATE SET
                                acrId.createdAt = datetime(),
                                acrId.createdBy = by,
                                acrId.lastModifiedAt = datetime(),
                                acrId.lastModifiedBy = by
                        MERGE (acrId)<-[acrIdToOsr:CONTAINS_FINGERPRINT]-(osr:OrchardSoundRecording)
                            ON CREATE SET
                                osr.id = apoc.create.uuid(),
                                osr.createdAt = datetime(),
                                osr.createdBy = by,
                                osr.lastModifiedAt = datetime(),
                                osr.lastModifiedBy = by,
                                acrIdToOsr.createdAt = datetime(),
                                acrIdToOsr.createdBy = by,
                                acrIdToOsr.lastModifiedAt = datetime(),
                                acrIdToOsr.lastModifiedBy = by
                        WITH *
                        UNWIND row.assets AS source_asset
                        MERGE (asset:OrchardAsset {
                            filename: source_asset.filename,
                            extension: "mp3",
                            source: "direct-delivery-db"
                        })
                            ON CREATE SET
                                asset.id = apoc.create.uuid(),
                                asset.createdAt = datetime(),
                                asset.createdBy = by,
                                asset.lastModifiedAt = datetime(),
                                asset.lastModifiedBy = by
                        MERGE (asset)-[assetToAcrId:FINGERPRINTED_AS]->(acrId)
                            ON CREATE SET
                                assetToAcrId.createdAt = datetime(),
                                assetToAcrId.createdBy = by
                            SET
                                assetToAcrId.lastModifiedAt = datetime(),
                                assetToAcrId.lastModifiedBy = by
                        WITH *
                        OPTIONAL MATCH (asset)-[assetToOldAcrId:FINGERPRINTED_AS]->(oldAcrId:ACRID)
                            WHERE oldAcrId <> acrId
                        FOREACH (hasOldAcrId IN CASE WHEN oldAcrId IS NOT NULL THEN [1] ELSE [] END |
                            CREATE (asset)-[deletedRelationship:DELETED_FINGERPRINTED_AS]->(oldAcrId)
                            SET
                                deletedRelationship += assetToOldAcrId,
                                deletedRelationship.deletedAt = datetime(),
                                deletedRelationship.deletedBy = by
                            DELETE assetToOldAcrId
                        )
                        WITH DISTINCT source_asset, by, asset
                        OPTIONAL MATCH (track:Track { id: toInteger(source_asset.tuid) })
                        CALL apoc.util.validate(track IS NULL, "Could not find the track %s", [source_asset.tuid])
                        MERGE (track)-[trackHasAsset:HAS_ASSET]->(asset)
                            ON CREATE SET
                                trackHasAsset.createdAt = datetime(),
                                trackHasAsset.createdBy = by,
                                trackHasAsset.lastModifiedAt = datetime(),
                                trackHasAsset.lastModifiedBy = by
                    ',
                    {
                        batchSize: 1000
                    }
                )
                YIELD failedOperations, errorMessages, failedBatches, batch
                CALL apoc.util.validate(failedOperations > 0, "At least one sub-operation failed: %s", [reduce(all_errors = "", error IN keys(errorMessages) | all_errors + ", " + error)])
                CALL apoc.util.validate(failedBatches > 0, "At least one batch failed: %s", [reduce(all_errors = "", error IN keys(batch.errors) | all_errors + ", " + error)])
                RETURN 0
            ]]>
        </query>
        <query>
            CALL apoc.log.info("Finished acr_cloud data ingest part 94 of 169 at %s", [datetime()]);
        </query>

        <query>
            <![CDATA[
                CALL apoc.periodic.iterate(
                     "
                        WITH 'snowflake_orchard' AS url_alias,
                        '
                            SELECT * FROM facts.qa.jsonified_track_mapping ORDER BY ACR_ID ASC LIMIT 100000 OFFSET 9400000
                        '
                        AS sql
                        CALL apoc.load.jdbc(url_alias, sql)
                        YIELD row
                        return apoc.convert.fromJsonMap(row.NODE) AS row;
                    ",
                    '
                        WITH *, "database/distro-4707" AS by
                        MERGE (acrId:ACRID { id: row.acr_id })
                            ON CREATE SET
                                acrId.createdAt = datetime(),
                                acrId.createdBy = by,
                                acrId.lastModifiedAt = datetime(),
                                acrId.lastModifiedBy = by
                        MERGE (acrId)<-[acrIdToOsr:CONTAINS_FINGERPRINT]-(osr:OrchardSoundRecording)
                            ON CREATE SET
                                osr.id = apoc.create.uuid(),
                                osr.createdAt = datetime(),
                                osr.createdBy = by,
                                osr.lastModifiedAt = datetime(),
                                osr.lastModifiedBy = by,
                                acrIdToOsr.createdAt = datetime(),
                                acrIdToOsr.createdBy = by,
                                acrIdToOsr.lastModifiedAt = datetime(),
                                acrIdToOsr.lastModifiedBy = by
                        WITH *
                        UNWIND row.assets AS source_asset
                        MERGE (asset:OrchardAsset {
                            filename: source_asset.filename,
                            extension: "mp3",
                            source: "direct-delivery-db"
                        })
                            ON CREATE SET
                                asset.id = apoc.create.uuid(),
                                asset.createdAt = datetime(),
                                asset.createdBy = by,
                                asset.lastModifiedAt = datetime(),
                                asset.lastModifiedBy = by
                        MERGE (asset)-[assetToAcrId:FINGERPRINTED_AS]->(acrId)
                            ON CREATE SET
                                assetToAcrId.createdAt = datetime(),
                                assetToAcrId.createdBy = by
                            SET
                                assetToAcrId.lastModifiedAt = datetime(),
                                assetToAcrId.lastModifiedBy = by
                        WITH *
                        OPTIONAL MATCH (asset)-[assetToOldAcrId:FINGERPRINTED_AS]->(oldAcrId:ACRID)
                            WHERE oldAcrId <> acrId
                        FOREACH (hasOldAcrId IN CASE WHEN oldAcrId IS NOT NULL THEN [1] ELSE [] END |
                            CREATE (asset)-[deletedRelationship:DELETED_FINGERPRINTED_AS]->(oldAcrId)
                            SET
                                deletedRelationship += assetToOldAcrId,
                                deletedRelationship.deletedAt = datetime(),
                                deletedRelationship.deletedBy = by
                            DELETE assetToOldAcrId
                        )
                        WITH DISTINCT source_asset, by, asset
                        OPTIONAL MATCH (track:Track { id: toInteger(source_asset.tuid) })
                        CALL apoc.util.validate(track IS NULL, "Could not find the track %s", [source_asset.tuid])
                        MERGE (track)-[trackHasAsset:HAS_ASSET]->(asset)
                            ON CREATE SET
                                trackHasAsset.createdAt = datetime(),
                                trackHasAsset.createdBy = by,
                                trackHasAsset.lastModifiedAt = datetime(),
                                trackHasAsset.lastModifiedBy = by
                    ',
                    {
                        batchSize: 1000
                    }
                )
                YIELD failedOperations, errorMessages, failedBatches, batch
                CALL apoc.util.validate(failedOperations > 0, "At least one sub-operation failed: %s", [reduce(all_errors = "", error IN keys(errorMessages) | all_errors + ", " + error)])
                CALL apoc.util.validate(failedBatches > 0, "At least one batch failed: %s", [reduce(all_errors = "", error IN keys(batch.errors) | all_errors + ", " + error)])
                RETURN 0
            ]]>
        </query>
        <query>
            CALL apoc.log.info("Finished acr_cloud data ingest part 95 of 169 at %s", [datetime()]);
        </query>

        <query>
            <![CDATA[
                CALL apoc.periodic.iterate(
                     "
                        WITH 'snowflake_orchard' AS url_alias,
                        '
                            SELECT * FROM facts.qa.jsonified_track_mapping ORDER BY ACR_ID ASC LIMIT 100000 OFFSET 9500000
                        '
                        AS sql
                        CALL apoc.load.jdbc(url_alias, sql)
                        YIELD row
                        return apoc.convert.fromJsonMap(row.NODE) AS row;
                    ",
                    '
                        WITH *, "database/distro-4707" AS by
                        MERGE (acrId:ACRID { id: row.acr_id })
                            ON CREATE SET
                                acrId.createdAt = datetime(),
                                acrId.createdBy = by,
                                acrId.lastModifiedAt = datetime(),
                                acrId.lastModifiedBy = by
                        MERGE (acrId)<-[acrIdToOsr:CONTAINS_FINGERPRINT]-(osr:OrchardSoundRecording)
                            ON CREATE SET
                                osr.id = apoc.create.uuid(),
                                osr.createdAt = datetime(),
                                osr.createdBy = by,
                                osr.lastModifiedAt = datetime(),
                                osr.lastModifiedBy = by,
                                acrIdToOsr.createdAt = datetime(),
                                acrIdToOsr.createdBy = by,
                                acrIdToOsr.lastModifiedAt = datetime(),
                                acrIdToOsr.lastModifiedBy = by
                        WITH *
                        UNWIND row.assets AS source_asset
                        MERGE (asset:OrchardAsset {
                            filename: source_asset.filename,
                            extension: "mp3",
                            source: "direct-delivery-db"
                        })
                            ON CREATE SET
                                asset.id = apoc.create.uuid(),
                                asset.createdAt = datetime(),
                                asset.createdBy = by,
                                asset.lastModifiedAt = datetime(),
                                asset.lastModifiedBy = by
                        MERGE (asset)-[assetToAcrId:FINGERPRINTED_AS]->(acrId)
                            ON CREATE SET
                                assetToAcrId.createdAt = datetime(),
                                assetToAcrId.createdBy = by
                            SET
                                assetToAcrId.lastModifiedAt = datetime(),
                                assetToAcrId.lastModifiedBy = by
                        WITH *
                        OPTIONAL MATCH (asset)-[assetToOldAcrId:FINGERPRINTED_AS]->(oldAcrId:ACRID)
                            WHERE oldAcrId <> acrId
                        FOREACH (hasOldAcrId IN CASE WHEN oldAcrId IS NOT NULL THEN [1] ELSE [] END |
                            CREATE (asset)-[deletedRelationship:DELETED_FINGERPRINTED_AS]->(oldAcrId)
                            SET
                                deletedRelationship += assetToOldAcrId,
                                deletedRelationship.deletedAt = datetime(),
                                deletedRelationship.deletedBy = by
                            DELETE assetToOldAcrId
                        )
                        WITH DISTINCT source_asset, by, asset
                        OPTIONAL MATCH (track:Track { id: toInteger(source_asset.tuid) })
                        CALL apoc.util.validate(track IS NULL, "Could not find the track %s", [source_asset.tuid])
                        MERGE (track)-[trackHasAsset:HAS_ASSET]->(asset)
                            ON CREATE SET
                                trackHasAsset.createdAt = datetime(),
                                trackHasAsset.createdBy = by,
                                trackHasAsset.lastModifiedAt = datetime(),
                                trackHasAsset.lastModifiedBy = by
                    ',
                    {
                        batchSize: 1000
                    }
                )
                YIELD failedOperations, errorMessages, failedBatches, batch
                CALL apoc.util.validate(failedOperations > 0, "At least one sub-operation failed: %s", [reduce(all_errors = "", error IN keys(errorMessages) | all_errors + ", " + error)])
                CALL apoc.util.validate(failedBatches > 0, "At least one batch failed: %s", [reduce(all_errors = "", error IN keys(batch.errors) | all_errors + ", " + error)])
                RETURN 0
            ]]>
        </query>
        <query>
            CALL apoc.log.info("Finished acr_cloud data ingest part 96 of 169 at %s", [datetime()]);
        </query>

        <query>
            <![CDATA[
                CALL apoc.periodic.iterate(
                     "
                        WITH 'snowflake_orchard' AS url_alias,
                        '
                            SELECT * FROM facts.qa.jsonified_track_mapping ORDER BY ACR_ID ASC LIMIT 100000 OFFSET 9600000
                        '
                        AS sql
                        CALL apoc.load.jdbc(url_alias, sql)
                        YIELD row
                        return apoc.convert.fromJsonMap(row.NODE) AS row;
                    ",
                    '
                        WITH *, "database/distro-4707" AS by
                        MERGE (acrId:ACRID { id: row.acr_id })
                            ON CREATE SET
                                acrId.createdAt = datetime(),
                                acrId.createdBy = by,
                                acrId.lastModifiedAt = datetime(),
                                acrId.lastModifiedBy = by
                        MERGE (acrId)<-[acrIdToOsr:CONTAINS_FINGERPRINT]-(osr:OrchardSoundRecording)
                            ON CREATE SET
                                osr.id = apoc.create.uuid(),
                                osr.createdAt = datetime(),
                                osr.createdBy = by,
                                osr.lastModifiedAt = datetime(),
                                osr.lastModifiedBy = by,
                                acrIdToOsr.createdAt = datetime(),
                                acrIdToOsr.createdBy = by,
                                acrIdToOsr.lastModifiedAt = datetime(),
                                acrIdToOsr.lastModifiedBy = by
                        WITH *
                        UNWIND row.assets AS source_asset
                        MERGE (asset:OrchardAsset {
                            filename: source_asset.filename,
                            extension: "mp3",
                            source: "direct-delivery-db"
                        })
                            ON CREATE SET
                                asset.id = apoc.create.uuid(),
                                asset.createdAt = datetime(),
                                asset.createdBy = by,
                                asset.lastModifiedAt = datetime(),
                                asset.lastModifiedBy = by
                        MERGE (asset)-[assetToAcrId:FINGERPRINTED_AS]->(acrId)
                            ON CREATE SET
                                assetToAcrId.createdAt = datetime(),
                                assetToAcrId.createdBy = by
                            SET
                                assetToAcrId.lastModifiedAt = datetime(),
                                assetToAcrId.lastModifiedBy = by
                        WITH *
                        OPTIONAL MATCH (asset)-[assetToOldAcrId:FINGERPRINTED_AS]->(oldAcrId:ACRID)
                            WHERE oldAcrId <> acrId
                        FOREACH (hasOldAcrId IN CASE WHEN oldAcrId IS NOT NULL THEN [1] ELSE [] END |
                            CREATE (asset)-[deletedRelationship:DELETED_FINGERPRINTED_AS]->(oldAcrId)
                            SET
                                deletedRelationship += assetToOldAcrId,
                                deletedRelationship.deletedAt = datetime(),
                                deletedRelationship.deletedBy = by
                            DELETE assetToOldAcrId
                        )
                        WITH DISTINCT source_asset, by, asset
                        OPTIONAL MATCH (track:Track { id: toInteger(source_asset.tuid) })
                        CALL apoc.util.validate(track IS NULL, "Could not find the track %s", [source_asset.tuid])
                        MERGE (track)-[trackHasAsset:HAS_ASSET]->(asset)
                            ON CREATE SET
                                trackHasAsset.createdAt = datetime(),
                                trackHasAsset.createdBy = by,
                                trackHasAsset.lastModifiedAt = datetime(),
                                trackHasAsset.lastModifiedBy = by
                    ',
                    {
                        batchSize: 1000
                    }
                )
                YIELD failedOperations, errorMessages, failedBatches, batch
                CALL apoc.util.validate(failedOperations > 0, "At least one sub-operation failed: %s", [reduce(all_errors = "", error IN keys(errorMessages) | all_errors + ", " + error)])
                CALL apoc.util.validate(failedBatches > 0, "At least one batch failed: %s", [reduce(all_errors = "", error IN keys(batch.errors) | all_errors + ", " + error)])
                RETURN 0
            ]]>
        </query>
        <query>
            CALL apoc.log.info("Finished acr_cloud data ingest part 97 of 169 at %s", [datetime()]);
        </query>

        <query>
            <![CDATA[
                CALL apoc.periodic.iterate(
                     "
                        WITH 'snowflake_orchard' AS url_alias,
                        '
                            SELECT * FROM facts.qa.jsonified_track_mapping ORDER BY ACR_ID ASC LIMIT 100000 OFFSET 9700000
                        '
                        AS sql
                        CALL apoc.load.jdbc(url_alias, sql)
                        YIELD row
                        return apoc.convert.fromJsonMap(row.NODE) AS row;
                    ",
                    '
                        WITH *, "database/distro-4707" AS by
                        MERGE (acrId:ACRID { id: row.acr_id })
                            ON CREATE SET
                                acrId.createdAt = datetime(),
                                acrId.createdBy = by,
                                acrId.lastModifiedAt = datetime(),
                                acrId.lastModifiedBy = by
                        MERGE (acrId)<-[acrIdToOsr:CONTAINS_FINGERPRINT]-(osr:OrchardSoundRecording)
                            ON CREATE SET
                                osr.id = apoc.create.uuid(),
                                osr.createdAt = datetime(),
                                osr.createdBy = by,
                                osr.lastModifiedAt = datetime(),
                                osr.lastModifiedBy = by,
                                acrIdToOsr.createdAt = datetime(),
                                acrIdToOsr.createdBy = by,
                                acrIdToOsr.lastModifiedAt = datetime(),
                                acrIdToOsr.lastModifiedBy = by
                        WITH *
                        UNWIND row.assets AS source_asset
                        MERGE (asset:OrchardAsset {
                            filename: source_asset.filename,
                            extension: "mp3",
                            source: "direct-delivery-db"
                        })
                            ON CREATE SET
                                asset.id = apoc.create.uuid(),
                                asset.createdAt = datetime(),
                                asset.createdBy = by,
                                asset.lastModifiedAt = datetime(),
                                asset.lastModifiedBy = by
                        MERGE (asset)-[assetToAcrId:FINGERPRINTED_AS]->(acrId)
                            ON CREATE SET
                                assetToAcrId.createdAt = datetime(),
                                assetToAcrId.createdBy = by
                            SET
                                assetToAcrId.lastModifiedAt = datetime(),
                                assetToAcrId.lastModifiedBy = by
                        WITH *
                        OPTIONAL MATCH (asset)-[assetToOldAcrId:FINGERPRINTED_AS]->(oldAcrId:ACRID)
                            WHERE oldAcrId <> acrId
                        FOREACH (hasOldAcrId IN CASE WHEN oldAcrId IS NOT NULL THEN [1] ELSE [] END |
                            CREATE (asset)-[deletedRelationship:DELETED_FINGERPRINTED_AS]->(oldAcrId)
                            SET
                                deletedRelationship += assetToOldAcrId,
                                deletedRelationship.deletedAt = datetime(),
                                deletedRelationship.deletedBy = by
                            DELETE assetToOldAcrId
                        )
                        WITH DISTINCT source_asset, by, asset
                        OPTIONAL MATCH (track:Track { id: toInteger(source_asset.tuid) })
                        CALL apoc.util.validate(track IS NULL, "Could not find the track %s", [source_asset.tuid])
                        MERGE (track)-[trackHasAsset:HAS_ASSET]->(asset)
                            ON CREATE SET
                                trackHasAsset.createdAt = datetime(),
                                trackHasAsset.createdBy = by,
                                trackHasAsset.lastModifiedAt = datetime(),
                                trackHasAsset.lastModifiedBy = by
                    ',
                    {
                        batchSize: 1000
                    }
                )
                YIELD failedOperations, errorMessages, failedBatches, batch
                CALL apoc.util.validate(failedOperations > 0, "At least one sub-operation failed: %s", [reduce(all_errors = "", error IN keys(errorMessages) | all_errors + ", " + error)])
                CALL apoc.util.validate(failedBatches > 0, "At least one batch failed: %s", [reduce(all_errors = "", error IN keys(batch.errors) | all_errors + ", " + error)])
                RETURN 0
            ]]>
        </query>
        <query>
            CALL apoc.log.info("Finished acr_cloud data ingest part 98 of 169 at %s", [datetime()]);
        </query>

        <query>
            <![CDATA[
                CALL apoc.periodic.iterate(
                     "
                        WITH 'snowflake_orchard' AS url_alias,
                        '
                            SELECT * FROM facts.qa.jsonified_track_mapping ORDER BY ACR_ID ASC LIMIT 100000 OFFSET 9800000
                        '
                        AS sql
                        CALL apoc.load.jdbc(url_alias, sql)
                        YIELD row
                        return apoc.convert.fromJsonMap(row.NODE) AS row;
                    ",
                    '
                        WITH *, "database/distro-4707" AS by
                        MERGE (acrId:ACRID { id: row.acr_id })
                            ON CREATE SET
                                acrId.createdAt = datetime(),
                                acrId.createdBy = by,
                                acrId.lastModifiedAt = datetime(),
                                acrId.lastModifiedBy = by
                        MERGE (acrId)<-[acrIdToOsr:CONTAINS_FINGERPRINT]-(osr:OrchardSoundRecording)
                            ON CREATE SET
                                osr.id = apoc.create.uuid(),
                                osr.createdAt = datetime(),
                                osr.createdBy = by,
                                osr.lastModifiedAt = datetime(),
                                osr.lastModifiedBy = by,
                                acrIdToOsr.createdAt = datetime(),
                                acrIdToOsr.createdBy = by,
                                acrIdToOsr.lastModifiedAt = datetime(),
                                acrIdToOsr.lastModifiedBy = by
                        WITH *
                        UNWIND row.assets AS source_asset
                        MERGE (asset:OrchardAsset {
                            filename: source_asset.filename,
                            extension: "mp3",
                            source: "direct-delivery-db"
                        })
                            ON CREATE SET
                                asset.id = apoc.create.uuid(),
                                asset.createdAt = datetime(),
                                asset.createdBy = by,
                                asset.lastModifiedAt = datetime(),
                                asset.lastModifiedBy = by
                        MERGE (asset)-[assetToAcrId:FINGERPRINTED_AS]->(acrId)
                            ON CREATE SET
                                assetToAcrId.createdAt = datetime(),
                                assetToAcrId.createdBy = by
                            SET
                                assetToAcrId.lastModifiedAt = datetime(),
                                assetToAcrId.lastModifiedBy = by
                        WITH *
                        OPTIONAL MATCH (asset)-[assetToOldAcrId:FINGERPRINTED_AS]->(oldAcrId:ACRID)
                            WHERE oldAcrId <> acrId
                        FOREACH (hasOldAcrId IN CASE WHEN oldAcrId IS NOT NULL THEN [1] ELSE [] END |
                            CREATE (asset)-[deletedRelationship:DELETED_FINGERPRINTED_AS]->(oldAcrId)
                            SET
                                deletedRelationship += assetToOldAcrId,
                                deletedRelationship.deletedAt = datetime(),
                                deletedRelationship.deletedBy = by
                            DELETE assetToOldAcrId
                        )
                        WITH DISTINCT source_asset, by, asset
                        OPTIONAL MATCH (track:Track { id: toInteger(source_asset.tuid) })
                        CALL apoc.util.validate(track IS NULL, "Could not find the track %s", [source_asset.tuid])
                        MERGE (track)-[trackHasAsset:HAS_ASSET]->(asset)
                            ON CREATE SET
                                trackHasAsset.createdAt = datetime(),
                                trackHasAsset.createdBy = by,
                                trackHasAsset.lastModifiedAt = datetime(),
                                trackHasAsset.lastModifiedBy = by
                    ',
                    {
                        batchSize: 1000
                    }
                )
                YIELD failedOperations, errorMessages, failedBatches, batch
                CALL apoc.util.validate(failedOperations > 0, "At least one sub-operation failed: %s", [reduce(all_errors = "", error IN keys(errorMessages) | all_errors + ", " + error)])
                CALL apoc.util.validate(failedBatches > 0, "At least one batch failed: %s", [reduce(all_errors = "", error IN keys(batch.errors) | all_errors + ", " + error)])
                RETURN 0
            ]]>
        </query>
        <query>
            CALL apoc.log.info("Finished acr_cloud data ingest part 99 of 169 at %s", [datetime()]);
        </query>

        <query>
            <![CDATA[
                CALL apoc.periodic.iterate(
                     "
                        WITH 'snowflake_orchard' AS url_alias,
                        '
                            SELECT * FROM facts.qa.jsonified_track_mapping ORDER BY ACR_ID ASC LIMIT 100000 OFFSET 9900000
                        '
                        AS sql
                        CALL apoc.load.jdbc(url_alias, sql)
                        YIELD row
                        return apoc.convert.fromJsonMap(row.NODE) AS row;
                    ",
                    '
                        WITH *, "database/distro-4707" AS by
                        MERGE (acrId:ACRID { id: row.acr_id })
                            ON CREATE SET
                                acrId.createdAt = datetime(),
                                acrId.createdBy = by,
                                acrId.lastModifiedAt = datetime(),
                                acrId.lastModifiedBy = by
                        MERGE (acrId)<-[acrIdToOsr:CONTAINS_FINGERPRINT]-(osr:OrchardSoundRecording)
                            ON CREATE SET
                                osr.id = apoc.create.uuid(),
                                osr.createdAt = datetime(),
                                osr.createdBy = by,
                                osr.lastModifiedAt = datetime(),
                                osr.lastModifiedBy = by,
                                acrIdToOsr.createdAt = datetime(),
                                acrIdToOsr.createdBy = by,
                                acrIdToOsr.lastModifiedAt = datetime(),
                                acrIdToOsr.lastModifiedBy = by
                        WITH *
                        UNWIND row.assets AS source_asset
                        MERGE (asset:OrchardAsset {
                            filename: source_asset.filename,
                            extension: "mp3",
                            source: "direct-delivery-db"
                        })
                            ON CREATE SET
                                asset.id = apoc.create.uuid(),
                                asset.createdAt = datetime(),
                                asset.createdBy = by,
                                asset.lastModifiedAt = datetime(),
                                asset.lastModifiedBy = by
                        MERGE (asset)-[assetToAcrId:FINGERPRINTED_AS]->(acrId)
                            ON CREATE SET
                                assetToAcrId.createdAt = datetime(),
                                assetToAcrId.createdBy = by
                            SET
                                assetToAcrId.lastModifiedAt = datetime(),
                                assetToAcrId.lastModifiedBy = by
                        WITH *
                        OPTIONAL MATCH (asset)-[assetToOldAcrId:FINGERPRINTED_AS]->(oldAcrId:ACRID)
                            WHERE oldAcrId <> acrId
                        FOREACH (hasOldAcrId IN CASE WHEN oldAcrId IS NOT NULL THEN [1] ELSE [] END |
                            CREATE (asset)-[deletedRelationship:DELETED_FINGERPRINTED_AS]->(oldAcrId)
                            SET
                                deletedRelationship += assetToOldAcrId,
                                deletedRelationship.deletedAt = datetime(),
                                deletedRelationship.deletedBy = by
                            DELETE assetToOldAcrId
                        )
                        WITH DISTINCT source_asset, by, asset
                        OPTIONAL MATCH (track:Track { id: toInteger(source_asset.tuid) })
                        CALL apoc.util.validate(track IS NULL, "Could not find the track %s", [source_asset.tuid])
                        MERGE (track)-[trackHasAsset:HAS_ASSET]->(asset)
                            ON CREATE SET
                                trackHasAsset.createdAt = datetime(),
                                trackHasAsset.createdBy = by,
                                trackHasAsset.lastModifiedAt = datetime(),
                                trackHasAsset.lastModifiedBy = by
                    ',
                    {
                        batchSize: 1000
                    }
                )
                YIELD failedOperations, errorMessages, failedBatches, batch
                CALL apoc.util.validate(failedOperations > 0, "At least one sub-operation failed: %s", [reduce(all_errors = "", error IN keys(errorMessages) | all_errors + ", " + error)])
                CALL apoc.util.validate(failedBatches > 0, "At least one batch failed: %s", [reduce(all_errors = "", error IN keys(batch.errors) | all_errors + ", " + error)])
                RETURN 0
            ]]>
        </query>
        <query>
            CALL apoc.log.info("Finished acr_cloud data ingest part 100 of 169 at %s", [datetime()]);
        </query>

        <query>
            <![CDATA[
                CALL apoc.periodic.iterate(
                     "
                        WITH 'snowflake_orchard' AS url_alias,
                        '
                            SELECT * FROM facts.qa.jsonified_track_mapping ORDER BY ACR_ID ASC LIMIT 100000 OFFSET 10000000
                        '
                        AS sql
                        CALL apoc.load.jdbc(url_alias, sql)
                        YIELD row
                        return apoc.convert.fromJsonMap(row.NODE) AS row;
                    ",
                    '
                        WITH *, "database/distro-4707" AS by
                        MERGE (acrId:ACRID { id: row.acr_id })
                            ON CREATE SET
                                acrId.createdAt = datetime(),
                                acrId.createdBy = by,
                                acrId.lastModifiedAt = datetime(),
                                acrId.lastModifiedBy = by
                        MERGE (acrId)<-[acrIdToOsr:CONTAINS_FINGERPRINT]-(osr:OrchardSoundRecording)
                            ON CREATE SET
                                osr.id = apoc.create.uuid(),
                                osr.createdAt = datetime(),
                                osr.createdBy = by,
                                osr.lastModifiedAt = datetime(),
                                osr.lastModifiedBy = by,
                                acrIdToOsr.createdAt = datetime(),
                                acrIdToOsr.createdBy = by,
                                acrIdToOsr.lastModifiedAt = datetime(),
                                acrIdToOsr.lastModifiedBy = by
                        WITH *
                        UNWIND row.assets AS source_asset
                        MERGE (asset:OrchardAsset {
                            filename: source_asset.filename,
                            extension: "mp3",
                            source: "direct-delivery-db"
                        })
                            ON CREATE SET
                                asset.id = apoc.create.uuid(),
                                asset.createdAt = datetime(),
                                asset.createdBy = by,
                                asset.lastModifiedAt = datetime(),
                                asset.lastModifiedBy = by
                        MERGE (asset)-[assetToAcrId:FINGERPRINTED_AS]->(acrId)
                            ON CREATE SET
                                assetToAcrId.createdAt = datetime(),
                                assetToAcrId.createdBy = by
                            SET
                                assetToAcrId.lastModifiedAt = datetime(),
                                assetToAcrId.lastModifiedBy = by
                        WITH *
                        OPTIONAL MATCH (asset)-[assetToOldAcrId:FINGERPRINTED_AS]->(oldAcrId:ACRID)
                            WHERE oldAcrId <> acrId
                        FOREACH (hasOldAcrId IN CASE WHEN oldAcrId IS NOT NULL THEN [1] ELSE [] END |
                            CREATE (asset)-[deletedRelationship:DELETED_FINGERPRINTED_AS]->(oldAcrId)
                            SET
                                deletedRelationship += assetToOldAcrId,
                                deletedRelationship.deletedAt = datetime(),
                                deletedRelationship.deletedBy = by
                            DELETE assetToOldAcrId
                        )
                        WITH DISTINCT source_asset, by, asset
                        OPTIONAL MATCH (track:Track { id: toInteger(source_asset.tuid) })
                        CALL apoc.util.validate(track IS NULL, "Could not find the track %s", [source_asset.tuid])
                        MERGE (track)-[trackHasAsset:HAS_ASSET]->(asset)
                            ON CREATE SET
                                trackHasAsset.createdAt = datetime(),
                                trackHasAsset.createdBy = by,
                                trackHasAsset.lastModifiedAt = datetime(),
                                trackHasAsset.lastModifiedBy = by
                    ',
                    {
                        batchSize: 1000
                    }
                )
                YIELD failedOperations, errorMessages, failedBatches, batch
                CALL apoc.util.validate(failedOperations > 0, "At least one sub-operation failed: %s", [reduce(all_errors = "", error IN keys(errorMessages) | all_errors + ", " + error)])
                CALL apoc.util.validate(failedBatches > 0, "At least one batch failed: %s", [reduce(all_errors = "", error IN keys(batch.errors) | all_errors + ", " + error)])
                RETURN 0
            ]]>
        </query>
        <query>
            CALL apoc.log.info("Finished acr_cloud data ingest part 101 of 169 at %s", [datetime()]);
        </query>

        <query>
            <![CDATA[
                CALL apoc.periodic.iterate(
                     "
                        WITH 'snowflake_orchard' AS url_alias,
                        '
                            SELECT * FROM facts.qa.jsonified_track_mapping ORDER BY ACR_ID ASC LIMIT 100000 OFFSET 10100000
                        '
                        AS sql
                        CALL apoc.load.jdbc(url_alias, sql)
                        YIELD row
                        return apoc.convert.fromJsonMap(row.NODE) AS row;
                    ",
                    '
                        WITH *, "database/distro-4707" AS by
                        MERGE (acrId:ACRID { id: row.acr_id })
                            ON CREATE SET
                                acrId.createdAt = datetime(),
                                acrId.createdBy = by,
                                acrId.lastModifiedAt = datetime(),
                                acrId.lastModifiedBy = by
                        MERGE (acrId)<-[acrIdToOsr:CONTAINS_FINGERPRINT]-(osr:OrchardSoundRecording)
                            ON CREATE SET
                                osr.id = apoc.create.uuid(),
                                osr.createdAt = datetime(),
                                osr.createdBy = by,
                                osr.lastModifiedAt = datetime(),
                                osr.lastModifiedBy = by,
                                acrIdToOsr.createdAt = datetime(),
                                acrIdToOsr.createdBy = by,
                                acrIdToOsr.lastModifiedAt = datetime(),
                                acrIdToOsr.lastModifiedBy = by
                        WITH *
                        UNWIND row.assets AS source_asset
                        MERGE (asset:OrchardAsset {
                            filename: source_asset.filename,
                            extension: "mp3",
                            source: "direct-delivery-db"
                        })
                            ON CREATE SET
                                asset.id = apoc.create.uuid(),
                                asset.createdAt = datetime(),
                                asset.createdBy = by,
                                asset.lastModifiedAt = datetime(),
                                asset.lastModifiedBy = by
                        MERGE (asset)-[assetToAcrId:FINGERPRINTED_AS]->(acrId)
                            ON CREATE SET
                                assetToAcrId.createdAt = datetime(),
                                assetToAcrId.createdBy = by
                            SET
                                assetToAcrId.lastModifiedAt = datetime(),
                                assetToAcrId.lastModifiedBy = by
                        WITH *
                        OPTIONAL MATCH (asset)-[assetToOldAcrId:FINGERPRINTED_AS]->(oldAcrId:ACRID)
                            WHERE oldAcrId <> acrId
                        FOREACH (hasOldAcrId IN CASE WHEN oldAcrId IS NOT NULL THEN [1] ELSE [] END |
                            CREATE (asset)-[deletedRelationship:DELETED_FINGERPRINTED_AS]->(oldAcrId)
                            SET
                                deletedRelationship += assetToOldAcrId,
                                deletedRelationship.deletedAt = datetime(),
                                deletedRelationship.deletedBy = by
                            DELETE assetToOldAcrId
                        )
                        WITH DISTINCT source_asset, by, asset
                        OPTIONAL MATCH (track:Track { id: toInteger(source_asset.tuid) })
                        CALL apoc.util.validate(track IS NULL, "Could not find the track %s", [source_asset.tuid])
                        MERGE (track)-[trackHasAsset:HAS_ASSET]->(asset)
                            ON CREATE SET
                                trackHasAsset.createdAt = datetime(),
                                trackHasAsset.createdBy = by,
                                trackHasAsset.lastModifiedAt = datetime(),
                                trackHasAsset.lastModifiedBy = by
                    ',
                    {
                        batchSize: 1000
                    }
                )
                YIELD failedOperations, errorMessages, failedBatches, batch
                CALL apoc.util.validate(failedOperations > 0, "At least one sub-operation failed: %s", [reduce(all_errors = "", error IN keys(errorMessages) | all_errors + ", " + error)])
                CALL apoc.util.validate(failedBatches > 0, "At least one batch failed: %s", [reduce(all_errors = "", error IN keys(batch.errors) | all_errors + ", " + error)])
                RETURN 0
            ]]>
        </query>
        <query>
            CALL apoc.log.info("Finished acr_cloud data ingest part 102 of 169 at %s", [datetime()]);
        </query>

        <query>
            <![CDATA[
                CALL apoc.periodic.iterate(
                     "
                        WITH 'snowflake_orchard' AS url_alias,
                        '
                            SELECT * FROM facts.qa.jsonified_track_mapping ORDER BY ACR_ID ASC LIMIT 100000 OFFSET 10200000
                        '
                        AS sql
                        CALL apoc.load.jdbc(url_alias, sql)
                        YIELD row
                        return apoc.convert.fromJsonMap(row.NODE) AS row;
                    ",
                    '
                        WITH *, "database/distro-4707" AS by
                        MERGE (acrId:ACRID { id: row.acr_id })
                            ON CREATE SET
                                acrId.createdAt = datetime(),
                                acrId.createdBy = by,
                                acrId.lastModifiedAt = datetime(),
                                acrId.lastModifiedBy = by
                        MERGE (acrId)<-[acrIdToOsr:CONTAINS_FINGERPRINT]-(osr:OrchardSoundRecording)
                            ON CREATE SET
                                osr.id = apoc.create.uuid(),
                                osr.createdAt = datetime(),
                                osr.createdBy = by,
                                osr.lastModifiedAt = datetime(),
                                osr.lastModifiedBy = by,
                                acrIdToOsr.createdAt = datetime(),
                                acrIdToOsr.createdBy = by,
                                acrIdToOsr.lastModifiedAt = datetime(),
                                acrIdToOsr.lastModifiedBy = by
                        WITH *
                        UNWIND row.assets AS source_asset
                        MERGE (asset:OrchardAsset {
                            filename: source_asset.filename,
                            extension: "mp3",
                            source: "direct-delivery-db"
                        })
                            ON CREATE SET
                                asset.id = apoc.create.uuid(),
                                asset.createdAt = datetime(),
                                asset.createdBy = by,
                                asset.lastModifiedAt = datetime(),
                                asset.lastModifiedBy = by
                        MERGE (asset)-[assetToAcrId:FINGERPRINTED_AS]->(acrId)
                            ON CREATE SET
                                assetToAcrId.createdAt = datetime(),
                                assetToAcrId.createdBy = by
                            SET
                                assetToAcrId.lastModifiedAt = datetime(),
                                assetToAcrId.lastModifiedBy = by
                        WITH *
                        OPTIONAL MATCH (asset)-[assetToOldAcrId:FINGERPRINTED_AS]->(oldAcrId:ACRID)
                            WHERE oldAcrId <> acrId
                        FOREACH (hasOldAcrId IN CASE WHEN oldAcrId IS NOT NULL THEN [1] ELSE [] END |
                            CREATE (asset)-[deletedRelationship:DELETED_FINGERPRINTED_AS]->(oldAcrId)
                            SET
                                deletedRelationship += assetToOldAcrId,
                                deletedRelationship.deletedAt = datetime(),
                                deletedRelationship.deletedBy = by
                            DELETE assetToOldAcrId
                        )
                        WITH DISTINCT source_asset, by, asset
                        OPTIONAL MATCH (track:Track { id: toInteger(source_asset.tuid) })
                        CALL apoc.util.validate(track IS NULL, "Could not find the track %s", [source_asset.tuid])
                        MERGE (track)-[trackHasAsset:HAS_ASSET]->(asset)
                            ON CREATE SET
                                trackHasAsset.createdAt = datetime(),
                                trackHasAsset.createdBy = by,
                                trackHasAsset.lastModifiedAt = datetime(),
                                trackHasAsset.lastModifiedBy = by
                    ',
                    {
                        batchSize: 1000
                    }
                )
                YIELD failedOperations, errorMessages, failedBatches, batch
                CALL apoc.util.validate(failedOperations > 0, "At least one sub-operation failed: %s", [reduce(all_errors = "", error IN keys(errorMessages) | all_errors + ", " + error)])
                CALL apoc.util.validate(failedBatches > 0, "At least one batch failed: %s", [reduce(all_errors = "", error IN keys(batch.errors) | all_errors + ", " + error)])
                RETURN 0
            ]]>
        </query>
        <query>
            CALL apoc.log.info("Finished acr_cloud data ingest part 103 of 169 at %s", [datetime()]);
        </query>

        <query>
            <![CDATA[
                CALL apoc.periodic.iterate(
                     "
                        WITH 'snowflake_orchard' AS url_alias,
                        '
                            SELECT * FROM facts.qa.jsonified_track_mapping ORDER BY ACR_ID ASC LIMIT 100000 OFFSET 10300000
                        '
                        AS sql
                        CALL apoc.load.jdbc(url_alias, sql)
                        YIELD row
                        return apoc.convert.fromJsonMap(row.NODE) AS row;
                    ",
                    '
                        WITH *, "database/distro-4707" AS by
                        MERGE (acrId:ACRID { id: row.acr_id })
                            ON CREATE SET
                                acrId.createdAt = datetime(),
                                acrId.createdBy = by,
                                acrId.lastModifiedAt = datetime(),
                                acrId.lastModifiedBy = by
                        MERGE (acrId)<-[acrIdToOsr:CONTAINS_FINGERPRINT]-(osr:OrchardSoundRecording)
                            ON CREATE SET
                                osr.id = apoc.create.uuid(),
                                osr.createdAt = datetime(),
                                osr.createdBy = by,
                                osr.lastModifiedAt = datetime(),
                                osr.lastModifiedBy = by,
                                acrIdToOsr.createdAt = datetime(),
                                acrIdToOsr.createdBy = by,
                                acrIdToOsr.lastModifiedAt = datetime(),
                                acrIdToOsr.lastModifiedBy = by
                        WITH *
                        UNWIND row.assets AS source_asset
                        MERGE (asset:OrchardAsset {
                            filename: source_asset.filename,
                            extension: "mp3",
                            source: "direct-delivery-db"
                        })
                            ON CREATE SET
                                asset.id = apoc.create.uuid(),
                                asset.createdAt = datetime(),
                                asset.createdBy = by,
                                asset.lastModifiedAt = datetime(),
                                asset.lastModifiedBy = by
                        MERGE (asset)-[assetToAcrId:FINGERPRINTED_AS]->(acrId)
                            ON CREATE SET
                                assetToAcrId.createdAt = datetime(),
                                assetToAcrId.createdBy = by
                            SET
                                assetToAcrId.lastModifiedAt = datetime(),
                                assetToAcrId.lastModifiedBy = by
                        WITH *
                        OPTIONAL MATCH (asset)-[assetToOldAcrId:FINGERPRINTED_AS]->(oldAcrId:ACRID)
                            WHERE oldAcrId <> acrId
                        FOREACH (hasOldAcrId IN CASE WHEN oldAcrId IS NOT NULL THEN [1] ELSE [] END |
                            CREATE (asset)-[deletedRelationship:DELETED_FINGERPRINTED_AS]->(oldAcrId)
                            SET
                                deletedRelationship += assetToOldAcrId,
                                deletedRelationship.deletedAt = datetime(),
                                deletedRelationship.deletedBy = by
                            DELETE assetToOldAcrId
                        )
                        WITH DISTINCT source_asset, by, asset
                        OPTIONAL MATCH (track:Track { id: toInteger(source_asset.tuid) })
                        CALL apoc.util.validate(track IS NULL, "Could not find the track %s", [source_asset.tuid])
                        MERGE (track)-[trackHasAsset:HAS_ASSET]->(asset)
                            ON CREATE SET
                                trackHasAsset.createdAt = datetime(),
                                trackHasAsset.createdBy = by,
                                trackHasAsset.lastModifiedAt = datetime(),
                                trackHasAsset.lastModifiedBy = by
                    ',
                    {
                        batchSize: 1000
                    }
                )
                YIELD failedOperations, errorMessages, failedBatches, batch
                CALL apoc.util.validate(failedOperations > 0, "At least one sub-operation failed: %s", [reduce(all_errors = "", error IN keys(errorMessages) | all_errors + ", " + error)])
                CALL apoc.util.validate(failedBatches > 0, "At least one batch failed: %s", [reduce(all_errors = "", error IN keys(batch.errors) | all_errors + ", " + error)])
                RETURN 0
            ]]>
        </query>
        <query>
            CALL apoc.log.info("Finished acr_cloud data ingest part 104 of 169 at %s", [datetime()]);
        </query>

        <query>
            <![CDATA[
                CALL apoc.periodic.iterate(
                     "
                        WITH 'snowflake_orchard' AS url_alias,
                        '
                            SELECT * FROM facts.qa.jsonified_track_mapping ORDER BY ACR_ID ASC LIMIT 100000 OFFSET 10400000
                        '
                        AS sql
                        CALL apoc.load.jdbc(url_alias, sql)
                        YIELD row
                        return apoc.convert.fromJsonMap(row.NODE) AS row;
                    ",
                    '
                        WITH *, "database/distro-4707" AS by
                        MERGE (acrId:ACRID { id: row.acr_id })
                            ON CREATE SET
                                acrId.createdAt = datetime(),
                                acrId.createdBy = by,
                                acrId.lastModifiedAt = datetime(),
                                acrId.lastModifiedBy = by
                        MERGE (acrId)<-[acrIdToOsr:CONTAINS_FINGERPRINT]-(osr:OrchardSoundRecording)
                            ON CREATE SET
                                osr.id = apoc.create.uuid(),
                                osr.createdAt = datetime(),
                                osr.createdBy = by,
                                osr.lastModifiedAt = datetime(),
                                osr.lastModifiedBy = by,
                                acrIdToOsr.createdAt = datetime(),
                                acrIdToOsr.createdBy = by,
                                acrIdToOsr.lastModifiedAt = datetime(),
                                acrIdToOsr.lastModifiedBy = by
                        WITH *
                        UNWIND row.assets AS source_asset
                        MERGE (asset:OrchardAsset {
                            filename: source_asset.filename,
                            extension: "mp3",
                            source: "direct-delivery-db"
                        })
                            ON CREATE SET
                                asset.id = apoc.create.uuid(),
                                asset.createdAt = datetime(),
                                asset.createdBy = by,
                                asset.lastModifiedAt = datetime(),
                                asset.lastModifiedBy = by
                        MERGE (asset)-[assetToAcrId:FINGERPRINTED_AS]->(acrId)
                            ON CREATE SET
                                assetToAcrId.createdAt = datetime(),
                                assetToAcrId.createdBy = by
                            SET
                                assetToAcrId.lastModifiedAt = datetime(),
                                assetToAcrId.lastModifiedBy = by
                        WITH *
                        OPTIONAL MATCH (asset)-[assetToOldAcrId:FINGERPRINTED_AS]->(oldAcrId:ACRID)
                            WHERE oldAcrId <> acrId
                        FOREACH (hasOldAcrId IN CASE WHEN oldAcrId IS NOT NULL THEN [1] ELSE [] END |
                            CREATE (asset)-[deletedRelationship:DELETED_FINGERPRINTED_AS]->(oldAcrId)
                            SET
                                deletedRelationship += assetToOldAcrId,
                                deletedRelationship.deletedAt = datetime(),
                                deletedRelationship.deletedBy = by
                            DELETE assetToOldAcrId
                        )
                        WITH DISTINCT source_asset, by, asset
                        OPTIONAL MATCH (track:Track { id: toInteger(source_asset.tuid) })
                        CALL apoc.util.validate(track IS NULL, "Could not find the track %s", [source_asset.tuid])
                        MERGE (track)-[trackHasAsset:HAS_ASSET]->(asset)
                            ON CREATE SET
                                trackHasAsset.createdAt = datetime(),
                                trackHasAsset.createdBy = by,
                                trackHasAsset.lastModifiedAt = datetime(),
                                trackHasAsset.lastModifiedBy = by
                    ',
                    {
                        batchSize: 1000
                    }
                )
                YIELD failedOperations, errorMessages, failedBatches, batch
                CALL apoc.util.validate(failedOperations > 0, "At least one sub-operation failed: %s", [reduce(all_errors = "", error IN keys(errorMessages) | all_errors + ", " + error)])
                CALL apoc.util.validate(failedBatches > 0, "At least one batch failed: %s", [reduce(all_errors = "", error IN keys(batch.errors) | all_errors + ", " + error)])
                RETURN 0
            ]]>
        </query>
        <query>
            CALL apoc.log.info("Finished acr_cloud data ingest part 105 of 169 at %s", [datetime()]);
        </query>

        <query>
            <![CDATA[
                CALL apoc.periodic.iterate(
                     "
                        WITH 'snowflake_orchard' AS url_alias,
                        '
                            SELECT * FROM facts.qa.jsonified_track_mapping ORDER BY ACR_ID ASC LIMIT 100000 OFFSET 10500000
                        '
                        AS sql
                        CALL apoc.load.jdbc(url_alias, sql)
                        YIELD row
                        return apoc.convert.fromJsonMap(row.NODE) AS row;
                    ",
                    '
                        WITH *, "database/distro-4707" AS by
                        MERGE (acrId:ACRID { id: row.acr_id })
                            ON CREATE SET
                                acrId.createdAt = datetime(),
                                acrId.createdBy = by,
                                acrId.lastModifiedAt = datetime(),
                                acrId.lastModifiedBy = by
                        MERGE (acrId)<-[acrIdToOsr:CONTAINS_FINGERPRINT]-(osr:OrchardSoundRecording)
                            ON CREATE SET
                                osr.id = apoc.create.uuid(),
                                osr.createdAt = datetime(),
                                osr.createdBy = by,
                                osr.lastModifiedAt = datetime(),
                                osr.lastModifiedBy = by,
                                acrIdToOsr.createdAt = datetime(),
                                acrIdToOsr.createdBy = by,
                                acrIdToOsr.lastModifiedAt = datetime(),
                                acrIdToOsr.lastModifiedBy = by
                        WITH *
                        UNWIND row.assets AS source_asset
                        MERGE (asset:OrchardAsset {
                            filename: source_asset.filename,
                            extension: "mp3",
                            source: "direct-delivery-db"
                        })
                            ON CREATE SET
                                asset.id = apoc.create.uuid(),
                                asset.createdAt = datetime(),
                                asset.createdBy = by,
                                asset.lastModifiedAt = datetime(),
                                asset.lastModifiedBy = by
                        MERGE (asset)-[assetToAcrId:FINGERPRINTED_AS]->(acrId)
                            ON CREATE SET
                                assetToAcrId.createdAt = datetime(),
                                assetToAcrId.createdBy = by
                            SET
                                assetToAcrId.lastModifiedAt = datetime(),
                                assetToAcrId.lastModifiedBy = by
                        WITH *
                        OPTIONAL MATCH (asset)-[assetToOldAcrId:FINGERPRINTED_AS]->(oldAcrId:ACRID)
                            WHERE oldAcrId <> acrId
                        FOREACH (hasOldAcrId IN CASE WHEN oldAcrId IS NOT NULL THEN [1] ELSE [] END |
                            CREATE (asset)-[deletedRelationship:DELETED_FINGERPRINTED_AS]->(oldAcrId)
                            SET
                                deletedRelationship += assetToOldAcrId,
                                deletedRelationship.deletedAt = datetime(),
                                deletedRelationship.deletedBy = by
                            DELETE assetToOldAcrId
                        )
                        WITH DISTINCT source_asset, by, asset
                        OPTIONAL MATCH (track:Track { id: toInteger(source_asset.tuid) })
                        CALL apoc.util.validate(track IS NULL, "Could not find the track %s", [source_asset.tuid])
                        MERGE (track)-[trackHasAsset:HAS_ASSET]->(asset)
                            ON CREATE SET
                                trackHasAsset.createdAt = datetime(),
                                trackHasAsset.createdBy = by,
                                trackHasAsset.lastModifiedAt = datetime(),
                                trackHasAsset.lastModifiedBy = by
                    ',
                    {
                        batchSize: 1000
                    }
                )
                YIELD failedOperations, errorMessages, failedBatches, batch
                CALL apoc.util.validate(failedOperations > 0, "At least one sub-operation failed: %s", [reduce(all_errors = "", error IN keys(errorMessages) | all_errors + ", " + error)])
                CALL apoc.util.validate(failedBatches > 0, "At least one batch failed: %s", [reduce(all_errors = "", error IN keys(batch.errors) | all_errors + ", " + error)])
                RETURN 0
            ]]>
        </query>
        <query>
            CALL apoc.log.info("Finished acr_cloud data ingest part 106 of 169 at %s", [datetime()]);
        </query>

        <query>
            <![CDATA[
                CALL apoc.periodic.iterate(
                     "
                        WITH 'snowflake_orchard' AS url_alias,
                        '
                            SELECT * FROM facts.qa.jsonified_track_mapping ORDER BY ACR_ID ASC LIMIT 100000 OFFSET 10600000
                        '
                        AS sql
                        CALL apoc.load.jdbc(url_alias, sql)
                        YIELD row
                        return apoc.convert.fromJsonMap(row.NODE) AS row;
                    ",
                    '
                        WITH *, "database/distro-4707" AS by
                        MERGE (acrId:ACRID { id: row.acr_id })
                            ON CREATE SET
                                acrId.createdAt = datetime(),
                                acrId.createdBy = by,
                                acrId.lastModifiedAt = datetime(),
                                acrId.lastModifiedBy = by
                        MERGE (acrId)<-[acrIdToOsr:CONTAINS_FINGERPRINT]-(osr:OrchardSoundRecording)
                            ON CREATE SET
                                osr.id = apoc.create.uuid(),
                                osr.createdAt = datetime(),
                                osr.createdBy = by,
                                osr.lastModifiedAt = datetime(),
                                osr.lastModifiedBy = by,
                                acrIdToOsr.createdAt = datetime(),
                                acrIdToOsr.createdBy = by,
                                acrIdToOsr.lastModifiedAt = datetime(),
                                acrIdToOsr.lastModifiedBy = by
                        WITH *
                        UNWIND row.assets AS source_asset
                        MERGE (asset:OrchardAsset {
                            filename: source_asset.filename,
                            extension: "mp3",
                            source: "direct-delivery-db"
                        })
                            ON CREATE SET
                                asset.id = apoc.create.uuid(),
                                asset.createdAt = datetime(),
                                asset.createdBy = by,
                                asset.lastModifiedAt = datetime(),
                                asset.lastModifiedBy = by
                        MERGE (asset)-[assetToAcrId:FINGERPRINTED_AS]->(acrId)
                            ON CREATE SET
                                assetToAcrId.createdAt = datetime(),
                                assetToAcrId.createdBy = by
                            SET
                                assetToAcrId.lastModifiedAt = datetime(),
                                assetToAcrId.lastModifiedBy = by
                        WITH *
                        OPTIONAL MATCH (asset)-[assetToOldAcrId:FINGERPRINTED_AS]->(oldAcrId:ACRID)
                            WHERE oldAcrId <> acrId
                        FOREACH (hasOldAcrId IN CASE WHEN oldAcrId IS NOT NULL THEN [1] ELSE [] END |
                            CREATE (asset)-[deletedRelationship:DELETED_FINGERPRINTED_AS]->(oldAcrId)
                            SET
                                deletedRelationship += assetToOldAcrId,
                                deletedRelationship.deletedAt = datetime(),
                                deletedRelationship.deletedBy = by
                            DELETE assetToOldAcrId
                        )
                        WITH DISTINCT source_asset, by, asset
                        OPTIONAL MATCH (track:Track { id: toInteger(source_asset.tuid) })
                        CALL apoc.util.validate(track IS NULL, "Could not find the track %s", [source_asset.tuid])
                        MERGE (track)-[trackHasAsset:HAS_ASSET]->(asset)
                            ON CREATE SET
                                trackHasAsset.createdAt = datetime(),
                                trackHasAsset.createdBy = by,
                                trackHasAsset.lastModifiedAt = datetime(),
                                trackHasAsset.lastModifiedBy = by
                    ',
                    {
                        batchSize: 1000
                    }
                )
                YIELD failedOperations, errorMessages, failedBatches, batch
                CALL apoc.util.validate(failedOperations > 0, "At least one sub-operation failed: %s", [reduce(all_errors = "", error IN keys(errorMessages) | all_errors + ", " + error)])
                CALL apoc.util.validate(failedBatches > 0, "At least one batch failed: %s", [reduce(all_errors = "", error IN keys(batch.errors) | all_errors + ", " + error)])
                RETURN 0
            ]]>
        </query>
        <query>
            CALL apoc.log.info("Finished acr_cloud data ingest part 107 of 169 at %s", [datetime()]);
        </query>

        <query>
            <![CDATA[
                CALL apoc.periodic.iterate(
                     "
                        WITH 'snowflake_orchard' AS url_alias,
                        '
                            SELECT * FROM facts.qa.jsonified_track_mapping ORDER BY ACR_ID ASC LIMIT 100000 OFFSET 10700000
                        '
                        AS sql
                        CALL apoc.load.jdbc(url_alias, sql)
                        YIELD row
                        return apoc.convert.fromJsonMap(row.NODE) AS row;
                    ",
                    '
                        WITH *, "database/distro-4707" AS by
                        MERGE (acrId:ACRID { id: row.acr_id })
                            ON CREATE SET
                                acrId.createdAt = datetime(),
                                acrId.createdBy = by,
                                acrId.lastModifiedAt = datetime(),
                                acrId.lastModifiedBy = by
                        MERGE (acrId)<-[acrIdToOsr:CONTAINS_FINGERPRINT]-(osr:OrchardSoundRecording)
                            ON CREATE SET
                                osr.id = apoc.create.uuid(),
                                osr.createdAt = datetime(),
                                osr.createdBy = by,
                                osr.lastModifiedAt = datetime(),
                                osr.lastModifiedBy = by,
                                acrIdToOsr.createdAt = datetime(),
                                acrIdToOsr.createdBy = by,
                                acrIdToOsr.lastModifiedAt = datetime(),
                                acrIdToOsr.lastModifiedBy = by
                        WITH *
                        UNWIND row.assets AS source_asset
                        MERGE (asset:OrchardAsset {
                            filename: source_asset.filename,
                            extension: "mp3",
                            source: "direct-delivery-db"
                        })
                            ON CREATE SET
                                asset.id = apoc.create.uuid(),
                                asset.createdAt = datetime(),
                                asset.createdBy = by,
                                asset.lastModifiedAt = datetime(),
                                asset.lastModifiedBy = by
                        MERGE (asset)-[assetToAcrId:FINGERPRINTED_AS]->(acrId)
                            ON CREATE SET
                                assetToAcrId.createdAt = datetime(),
                                assetToAcrId.createdBy = by
                            SET
                                assetToAcrId.lastModifiedAt = datetime(),
                                assetToAcrId.lastModifiedBy = by
                        WITH *
                        OPTIONAL MATCH (asset)-[assetToOldAcrId:FINGERPRINTED_AS]->(oldAcrId:ACRID)
                            WHERE oldAcrId <> acrId
                        FOREACH (hasOldAcrId IN CASE WHEN oldAcrId IS NOT NULL THEN [1] ELSE [] END |
                            CREATE (asset)-[deletedRelationship:DELETED_FINGERPRINTED_AS]->(oldAcrId)
                            SET
                                deletedRelationship += assetToOldAcrId,
                                deletedRelationship.deletedAt = datetime(),
                                deletedRelationship.deletedBy = by
                            DELETE assetToOldAcrId
                        )
                        WITH DISTINCT source_asset, by, asset
                        OPTIONAL MATCH (track:Track { id: toInteger(source_asset.tuid) })
                        CALL apoc.util.validate(track IS NULL, "Could not find the track %s", [source_asset.tuid])
                        MERGE (track)-[trackHasAsset:HAS_ASSET]->(asset)
                            ON CREATE SET
                                trackHasAsset.createdAt = datetime(),
                                trackHasAsset.createdBy = by,
                                trackHasAsset.lastModifiedAt = datetime(),
                                trackHasAsset.lastModifiedBy = by
                    ',
                    {
                        batchSize: 1000
                    }
                )
                YIELD failedOperations, errorMessages, failedBatches, batch
                CALL apoc.util.validate(failedOperations > 0, "At least one sub-operation failed: %s", [reduce(all_errors = "", error IN keys(errorMessages) | all_errors + ", " + error)])
                CALL apoc.util.validate(failedBatches > 0, "At least one batch failed: %s", [reduce(all_errors = "", error IN keys(batch.errors) | all_errors + ", " + error)])
                RETURN 0
            ]]>
        </query>
        <query>
            CALL apoc.log.info("Finished acr_cloud data ingest part 108 of 169 at %s", [datetime()]);
        </query>

        <query>
            <![CDATA[
                CALL apoc.periodic.iterate(
                     "
                        WITH 'snowflake_orchard' AS url_alias,
                        '
                            SELECT * FROM facts.qa.jsonified_track_mapping ORDER BY ACR_ID ASC LIMIT 100000 OFFSET 10800000
                        '
                        AS sql
                        CALL apoc.load.jdbc(url_alias, sql)
                        YIELD row
                        return apoc.convert.fromJsonMap(row.NODE) AS row;
                    ",
                    '
                        WITH *, "database/distro-4707" AS by
                        MERGE (acrId:ACRID { id: row.acr_id })
                            ON CREATE SET
                                acrId.createdAt = datetime(),
                                acrId.createdBy = by,
                                acrId.lastModifiedAt = datetime(),
                                acrId.lastModifiedBy = by
                        MERGE (acrId)<-[acrIdToOsr:CONTAINS_FINGERPRINT]-(osr:OrchardSoundRecording)
                            ON CREATE SET
                                osr.id = apoc.create.uuid(),
                                osr.createdAt = datetime(),
                                osr.createdBy = by,
                                osr.lastModifiedAt = datetime(),
                                osr.lastModifiedBy = by,
                                acrIdToOsr.createdAt = datetime(),
                                acrIdToOsr.createdBy = by,
                                acrIdToOsr.lastModifiedAt = datetime(),
                                acrIdToOsr.lastModifiedBy = by
                        WITH *
                        UNWIND row.assets AS source_asset
                        MERGE (asset:OrchardAsset {
                            filename: source_asset.filename,
                            extension: "mp3",
                            source: "direct-delivery-db"
                        })
                            ON CREATE SET
                                asset.id = apoc.create.uuid(),
                                asset.createdAt = datetime(),
                                asset.createdBy = by,
                                asset.lastModifiedAt = datetime(),
                                asset.lastModifiedBy = by
                        MERGE (asset)-[assetToAcrId:FINGERPRINTED_AS]->(acrId)
                            ON CREATE SET
                                assetToAcrId.createdAt = datetime(),
                                assetToAcrId.createdBy = by
                            SET
                                assetToAcrId.lastModifiedAt = datetime(),
                                assetToAcrId.lastModifiedBy = by
                        WITH *
                        OPTIONAL MATCH (asset)-[assetToOldAcrId:FINGERPRINTED_AS]->(oldAcrId:ACRID)
                            WHERE oldAcrId <> acrId
                        FOREACH (hasOldAcrId IN CASE WHEN oldAcrId IS NOT NULL THEN [1] ELSE [] END |
                            CREATE (asset)-[deletedRelationship:DELETED_FINGERPRINTED_AS]->(oldAcrId)
                            SET
                                deletedRelationship += assetToOldAcrId,
                                deletedRelationship.deletedAt = datetime(),
                                deletedRelationship.deletedBy = by
                            DELETE assetToOldAcrId
                        )
                        WITH DISTINCT source_asset, by, asset
                        OPTIONAL MATCH (track:Track { id: toInteger(source_asset.tuid) })
                        CALL apoc.util.validate(track IS NULL, "Could not find the track %s", [source_asset.tuid])
                        MERGE (track)-[trackHasAsset:HAS_ASSET]->(asset)
                            ON CREATE SET
                                trackHasAsset.createdAt = datetime(),
                                trackHasAsset.createdBy = by,
                                trackHasAsset.lastModifiedAt = datetime(),
                                trackHasAsset.lastModifiedBy = by
                    ',
                    {
                        batchSize: 1000
                    }
                )
                YIELD failedOperations, errorMessages, failedBatches, batch
                CALL apoc.util.validate(failedOperations > 0, "At least one sub-operation failed: %s", [reduce(all_errors = "", error IN keys(errorMessages) | all_errors + ", " + error)])
                CALL apoc.util.validate(failedBatches > 0, "At least one batch failed: %s", [reduce(all_errors = "", error IN keys(batch.errors) | all_errors + ", " + error)])
                RETURN 0
            ]]>
        </query>
        <query>
            CALL apoc.log.info("Finished acr_cloud data ingest part 109 of 169 at %s", [datetime()]);
        </query>

        <query>
            <![CDATA[
                CALL apoc.periodic.iterate(
                     "
                        WITH 'snowflake_orchard' AS url_alias,
                        '
                            SELECT * FROM facts.qa.jsonified_track_mapping ORDER BY ACR_ID ASC LIMIT 100000 OFFSET 10900000
                        '
                        AS sql
                        CALL apoc.load.jdbc(url_alias, sql)
                        YIELD row
                        return apoc.convert.fromJsonMap(row.NODE) AS row;
                    ",
                    '
                        WITH *, "database/distro-4707" AS by
                        MERGE (acrId:ACRID { id: row.acr_id })
                            ON CREATE SET
                                acrId.createdAt = datetime(),
                                acrId.createdBy = by,
                                acrId.lastModifiedAt = datetime(),
                                acrId.lastModifiedBy = by
                        MERGE (acrId)<-[acrIdToOsr:CONTAINS_FINGERPRINT]-(osr:OrchardSoundRecording)
                            ON CREATE SET
                                osr.id = apoc.create.uuid(),
                                osr.createdAt = datetime(),
                                osr.createdBy = by,
                                osr.lastModifiedAt = datetime(),
                                osr.lastModifiedBy = by,
                                acrIdToOsr.createdAt = datetime(),
                                acrIdToOsr.createdBy = by,
                                acrIdToOsr.lastModifiedAt = datetime(),
                                acrIdToOsr.lastModifiedBy = by
                        WITH *
                        UNWIND row.assets AS source_asset
                        MERGE (asset:OrchardAsset {
                            filename: source_asset.filename,
                            extension: "mp3",
                            source: "direct-delivery-db"
                        })
                            ON CREATE SET
                                asset.id = apoc.create.uuid(),
                                asset.createdAt = datetime(),
                                asset.createdBy = by,
                                asset.lastModifiedAt = datetime(),
                                asset.lastModifiedBy = by
                        MERGE (asset)-[assetToAcrId:FINGERPRINTED_AS]->(acrId)
                            ON CREATE SET
                                assetToAcrId.createdAt = datetime(),
                                assetToAcrId.createdBy = by
                            SET
                                assetToAcrId.lastModifiedAt = datetime(),
                                assetToAcrId.lastModifiedBy = by
                        WITH *
                        OPTIONAL MATCH (asset)-[assetToOldAcrId:FINGERPRINTED_AS]->(oldAcrId:ACRID)
                            WHERE oldAcrId <> acrId
                        FOREACH (hasOldAcrId IN CASE WHEN oldAcrId IS NOT NULL THEN [1] ELSE [] END |
                            CREATE (asset)-[deletedRelationship:DELETED_FINGERPRINTED_AS]->(oldAcrId)
                            SET
                                deletedRelationship += assetToOldAcrId,
                                deletedRelationship.deletedAt = datetime(),
                                deletedRelationship.deletedBy = by
                            DELETE assetToOldAcrId
                        )
                        WITH DISTINCT source_asset, by, asset
                        OPTIONAL MATCH (track:Track { id: toInteger(source_asset.tuid) })
                        CALL apoc.util.validate(track IS NULL, "Could not find the track %s", [source_asset.tuid])
                        MERGE (track)-[trackHasAsset:HAS_ASSET]->(asset)
                            ON CREATE SET
                                trackHasAsset.createdAt = datetime(),
                                trackHasAsset.createdBy = by,
                                trackHasAsset.lastModifiedAt = datetime(),
                                trackHasAsset.lastModifiedBy = by
                    ',
                    {
                        batchSize: 1000
                    }
                )
                YIELD failedOperations, errorMessages, failedBatches, batch
                CALL apoc.util.validate(failedOperations > 0, "At least one sub-operation failed: %s", [reduce(all_errors = "", error IN keys(errorMessages) | all_errors + ", " + error)])
                CALL apoc.util.validate(failedBatches > 0, "At least one batch failed: %s", [reduce(all_errors = "", error IN keys(batch.errors) | all_errors + ", " + error)])
                RETURN 0
            ]]>
        </query>
        <query>
            CALL apoc.log.info("Finished acr_cloud data ingest part 110 of 169 at %s", [datetime()]);
        </query>

        <query>
            <![CDATA[
                CALL apoc.periodic.iterate(
                     "
                        WITH 'snowflake_orchard' AS url_alias,
                        '
                            SELECT * FROM facts.qa.jsonified_track_mapping ORDER BY ACR_ID ASC LIMIT 100000 OFFSET 11000000
                        '
                        AS sql
                        CALL apoc.load.jdbc(url_alias, sql)
                        YIELD row
                        return apoc.convert.fromJsonMap(row.NODE) AS row;
                    ",
                    '
                        WITH *, "database/distro-4707" AS by
                        MERGE (acrId:ACRID { id: row.acr_id })
                            ON CREATE SET
                                acrId.createdAt = datetime(),
                                acrId.createdBy = by,
                                acrId.lastModifiedAt = datetime(),
                                acrId.lastModifiedBy = by
                        MERGE (acrId)<-[acrIdToOsr:CONTAINS_FINGERPRINT]-(osr:OrchardSoundRecording)
                            ON CREATE SET
                                osr.id = apoc.create.uuid(),
                                osr.createdAt = datetime(),
                                osr.createdBy = by,
                                osr.lastModifiedAt = datetime(),
                                osr.lastModifiedBy = by,
                                acrIdToOsr.createdAt = datetime(),
                                acrIdToOsr.createdBy = by,
                                acrIdToOsr.lastModifiedAt = datetime(),
                                acrIdToOsr.lastModifiedBy = by
                        WITH *
                        UNWIND row.assets AS source_asset
                        MERGE (asset:OrchardAsset {
                            filename: source_asset.filename,
                            extension: "mp3",
                            source: "direct-delivery-db"
                        })
                            ON CREATE SET
                                asset.id = apoc.create.uuid(),
                                asset.createdAt = datetime(),
                                asset.createdBy = by,
                                asset.lastModifiedAt = datetime(),
                                asset.lastModifiedBy = by
                        MERGE (asset)-[assetToAcrId:FINGERPRINTED_AS]->(acrId)
                            ON CREATE SET
                                assetToAcrId.createdAt = datetime(),
                                assetToAcrId.createdBy = by
                            SET
                                assetToAcrId.lastModifiedAt = datetime(),
                                assetToAcrId.lastModifiedBy = by
                        WITH *
                        OPTIONAL MATCH (asset)-[assetToOldAcrId:FINGERPRINTED_AS]->(oldAcrId:ACRID)
                            WHERE oldAcrId <> acrId
                        FOREACH (hasOldAcrId IN CASE WHEN oldAcrId IS NOT NULL THEN [1] ELSE [] END |
                            CREATE (asset)-[deletedRelationship:DELETED_FINGERPRINTED_AS]->(oldAcrId)
                            SET
                                deletedRelationship += assetToOldAcrId,
                                deletedRelationship.deletedAt = datetime(),
                                deletedRelationship.deletedBy = by
                            DELETE assetToOldAcrId
                        )
                        WITH DISTINCT source_asset, by, asset
                        OPTIONAL MATCH (track:Track { id: toInteger(source_asset.tuid) })
                        CALL apoc.util.validate(track IS NULL, "Could not find the track %s", [source_asset.tuid])
                        MERGE (track)-[trackHasAsset:HAS_ASSET]->(asset)
                            ON CREATE SET
                                trackHasAsset.createdAt = datetime(),
                                trackHasAsset.createdBy = by,
                                trackHasAsset.lastModifiedAt = datetime(),
                                trackHasAsset.lastModifiedBy = by
                    ',
                    {
                        batchSize: 1000
                    }
                )
                YIELD failedOperations, errorMessages, failedBatches, batch
                CALL apoc.util.validate(failedOperations > 0, "At least one sub-operation failed: %s", [reduce(all_errors = "", error IN keys(errorMessages) | all_errors + ", " + error)])
                CALL apoc.util.validate(failedBatches > 0, "At least one batch failed: %s", [reduce(all_errors = "", error IN keys(batch.errors) | all_errors + ", " + error)])
                RETURN 0
            ]]>
        </query>
        <query>
            CALL apoc.log.info("Finished acr_cloud data ingest part 111 of 169 at %s", [datetime()]);
        </query>

        <query>
            <![CDATA[
                CALL apoc.periodic.iterate(
                     "
                        WITH 'snowflake_orchard' AS url_alias,
                        '
                            SELECT * FROM facts.qa.jsonified_track_mapping ORDER BY ACR_ID ASC LIMIT 100000 OFFSET 11100000
                        '
                        AS sql
                        CALL apoc.load.jdbc(url_alias, sql)
                        YIELD row
                        return apoc.convert.fromJsonMap(row.NODE) AS row;
                    ",
                    '
                        WITH *, "database/distro-4707" AS by
                        MERGE (acrId:ACRID { id: row.acr_id })
                            ON CREATE SET
                                acrId.createdAt = datetime(),
                                acrId.createdBy = by,
                                acrId.lastModifiedAt = datetime(),
                                acrId.lastModifiedBy = by
                        MERGE (acrId)<-[acrIdToOsr:CONTAINS_FINGERPRINT]-(osr:OrchardSoundRecording)
                            ON CREATE SET
                                osr.id = apoc.create.uuid(),
                                osr.createdAt = datetime(),
                                osr.createdBy = by,
                                osr.lastModifiedAt = datetime(),
                                osr.lastModifiedBy = by,
                                acrIdToOsr.createdAt = datetime(),
                                acrIdToOsr.createdBy = by,
                                acrIdToOsr.lastModifiedAt = datetime(),
                                acrIdToOsr.lastModifiedBy = by
                        WITH *
                        UNWIND row.assets AS source_asset
                        MERGE (asset:OrchardAsset {
                            filename: source_asset.filename,
                            extension: "mp3",
                            source: "direct-delivery-db"
                        })
                            ON CREATE SET
                                asset.id = apoc.create.uuid(),
                                asset.createdAt = datetime(),
                                asset.createdBy = by,
                                asset.lastModifiedAt = datetime(),
                                asset.lastModifiedBy = by
                        MERGE (asset)-[assetToAcrId:FINGERPRINTED_AS]->(acrId)
                            ON CREATE SET
                                assetToAcrId.createdAt = datetime(),
                                assetToAcrId.createdBy = by
                            SET
                                assetToAcrId.lastModifiedAt = datetime(),
                                assetToAcrId.lastModifiedBy = by
                        WITH *
                        OPTIONAL MATCH (asset)-[assetToOldAcrId:FINGERPRINTED_AS]->(oldAcrId:ACRID)
                            WHERE oldAcrId <> acrId
                        FOREACH (hasOldAcrId IN CASE WHEN oldAcrId IS NOT NULL THEN [1] ELSE [] END |
                            CREATE (asset)-[deletedRelationship:DELETED_FINGERPRINTED_AS]->(oldAcrId)
                            SET
                                deletedRelationship += assetToOldAcrId,
                                deletedRelationship.deletedAt = datetime(),
                                deletedRelationship.deletedBy = by
                            DELETE assetToOldAcrId
                        )
                        WITH DISTINCT source_asset, by, asset
                        OPTIONAL MATCH (track:Track { id: toInteger(source_asset.tuid) })
                        CALL apoc.util.validate(track IS NULL, "Could not find the track %s", [source_asset.tuid])
                        MERGE (track)-[trackHasAsset:HAS_ASSET]->(asset)
                            ON CREATE SET
                                trackHasAsset.createdAt = datetime(),
                                trackHasAsset.createdBy = by,
                                trackHasAsset.lastModifiedAt = datetime(),
                                trackHasAsset.lastModifiedBy = by
                    ',
                    {
                        batchSize: 1000
                    }
                )
                YIELD failedOperations, errorMessages, failedBatches, batch
                CALL apoc.util.validate(failedOperations > 0, "At least one sub-operation failed: %s", [reduce(all_errors = "", error IN keys(errorMessages) | all_errors + ", " + error)])
                CALL apoc.util.validate(failedBatches > 0, "At least one batch failed: %s", [reduce(all_errors = "", error IN keys(batch.errors) | all_errors + ", " + error)])
                RETURN 0
            ]]>
        </query>
        <query>
            CALL apoc.log.info("Finished acr_cloud data ingest part 112 of 169 at %s", [datetime()]);
        </query>

        <query>
            <![CDATA[
                CALL apoc.periodic.iterate(
                     "
                        WITH 'snowflake_orchard' AS url_alias,
                        '
                            SELECT * FROM facts.qa.jsonified_track_mapping ORDER BY ACR_ID ASC LIMIT 100000 OFFSET 11200000
                        '
                        AS sql
                        CALL apoc.load.jdbc(url_alias, sql)
                        YIELD row
                        return apoc.convert.fromJsonMap(row.NODE) AS row;
                    ",
                    '
                        WITH *, "database/distro-4707" AS by
                        MERGE (acrId:ACRID { id: row.acr_id })
                            ON CREATE SET
                                acrId.createdAt = datetime(),
                                acrId.createdBy = by,
                                acrId.lastModifiedAt = datetime(),
                                acrId.lastModifiedBy = by
                        MERGE (acrId)<-[acrIdToOsr:CONTAINS_FINGERPRINT]-(osr:OrchardSoundRecording)
                            ON CREATE SET
                                osr.id = apoc.create.uuid(),
                                osr.createdAt = datetime(),
                                osr.createdBy = by,
                                osr.lastModifiedAt = datetime(),
                                osr.lastModifiedBy = by,
                                acrIdToOsr.createdAt = datetime(),
                                acrIdToOsr.createdBy = by,
                                acrIdToOsr.lastModifiedAt = datetime(),
                                acrIdToOsr.lastModifiedBy = by
                        WITH *
                        UNWIND row.assets AS source_asset
                        MERGE (asset:OrchardAsset {
                            filename: source_asset.filename,
                            extension: "mp3",
                            source: "direct-delivery-db"
                        })
                            ON CREATE SET
                                asset.id = apoc.create.uuid(),
                                asset.createdAt = datetime(),
                                asset.createdBy = by,
                                asset.lastModifiedAt = datetime(),
                                asset.lastModifiedBy = by
                        MERGE (asset)-[assetToAcrId:FINGERPRINTED_AS]->(acrId)
                            ON CREATE SET
                                assetToAcrId.createdAt = datetime(),
                                assetToAcrId.createdBy = by
                            SET
                                assetToAcrId.lastModifiedAt = datetime(),
                                assetToAcrId.lastModifiedBy = by
                        WITH *
                        OPTIONAL MATCH (asset)-[assetToOldAcrId:FINGERPRINTED_AS]->(oldAcrId:ACRID)
                            WHERE oldAcrId <> acrId
                        FOREACH (hasOldAcrId IN CASE WHEN oldAcrId IS NOT NULL THEN [1] ELSE [] END |
                            CREATE (asset)-[deletedRelationship:DELETED_FINGERPRINTED_AS]->(oldAcrId)
                            SET
                                deletedRelationship += assetToOldAcrId,
                                deletedRelationship.deletedAt = datetime(),
                                deletedRelationship.deletedBy = by
                            DELETE assetToOldAcrId
                        )
                        WITH DISTINCT source_asset, by, asset
                        OPTIONAL MATCH (track:Track { id: toInteger(source_asset.tuid) })
                        CALL apoc.util.validate(track IS NULL, "Could not find the track %s", [source_asset.tuid])
                        MERGE (track)-[trackHasAsset:HAS_ASSET]->(asset)
                            ON CREATE SET
                                trackHasAsset.createdAt = datetime(),
                                trackHasAsset.createdBy = by,
                                trackHasAsset.lastModifiedAt = datetime(),
                                trackHasAsset.lastModifiedBy = by
                    ',
                    {
                        batchSize: 1000
                    }
                )
                YIELD failedOperations, errorMessages, failedBatches, batch
                CALL apoc.util.validate(failedOperations > 0, "At least one sub-operation failed: %s", [reduce(all_errors = "", error IN keys(errorMessages) | all_errors + ", " + error)])
                CALL apoc.util.validate(failedBatches > 0, "At least one batch failed: %s", [reduce(all_errors = "", error IN keys(batch.errors) | all_errors + ", " + error)])
                RETURN 0
            ]]>
        </query>
        <query>
            CALL apoc.log.info("Finished acr_cloud data ingest part 113 of 169 at %s", [datetime()]);
        </query>

        <query>
            <![CDATA[
                CALL apoc.periodic.iterate(
                     "
                        WITH 'snowflake_orchard' AS url_alias,
                        '
                            SELECT * FROM facts.qa.jsonified_track_mapping ORDER BY ACR_ID ASC LIMIT 100000 OFFSET 11300000
                        '
                        AS sql
                        CALL apoc.load.jdbc(url_alias, sql)
                        YIELD row
                        return apoc.convert.fromJsonMap(row.NODE) AS row;
                    ",
                    '
                        WITH *, "database/distro-4707" AS by
                        MERGE (acrId:ACRID { id: row.acr_id })
                            ON CREATE SET
                                acrId.createdAt = datetime(),
                                acrId.createdBy = by,
                                acrId.lastModifiedAt = datetime(),
                                acrId.lastModifiedBy = by
                        MERGE (acrId)<-[acrIdToOsr:CONTAINS_FINGERPRINT]-(osr:OrchardSoundRecording)
                            ON CREATE SET
                                osr.id = apoc.create.uuid(),
                                osr.createdAt = datetime(),
                                osr.createdBy = by,
                                osr.lastModifiedAt = datetime(),
                                osr.lastModifiedBy = by,
                                acrIdToOsr.createdAt = datetime(),
                                acrIdToOsr.createdBy = by,
                                acrIdToOsr.lastModifiedAt = datetime(),
                                acrIdToOsr.lastModifiedBy = by
                        WITH *
                        UNWIND row.assets AS source_asset
                        MERGE (asset:OrchardAsset {
                            filename: source_asset.filename,
                            extension: "mp3",
                            source: "direct-delivery-db"
                        })
                            ON CREATE SET
                                asset.id = apoc.create.uuid(),
                                asset.createdAt = datetime(),
                                asset.createdBy = by,
                                asset.lastModifiedAt = datetime(),
                                asset.lastModifiedBy = by
                        MERGE (asset)-[assetToAcrId:FINGERPRINTED_AS]->(acrId)
                            ON CREATE SET
                                assetToAcrId.createdAt = datetime(),
                                assetToAcrId.createdBy = by
                            SET
                                assetToAcrId.lastModifiedAt = datetime(),
                                assetToAcrId.lastModifiedBy = by
                        WITH *
                        OPTIONAL MATCH (asset)-[assetToOldAcrId:FINGERPRINTED_AS]->(oldAcrId:ACRID)
                            WHERE oldAcrId <> acrId
                        FOREACH (hasOldAcrId IN CASE WHEN oldAcrId IS NOT NULL THEN [1] ELSE [] END |
                            CREATE (asset)-[deletedRelationship:DELETED_FINGERPRINTED_AS]->(oldAcrId)
                            SET
                                deletedRelationship += assetToOldAcrId,
                                deletedRelationship.deletedAt = datetime(),
                                deletedRelationship.deletedBy = by
                            DELETE assetToOldAcrId
                        )
                        WITH DISTINCT source_asset, by, asset
                        OPTIONAL MATCH (track:Track { id: toInteger(source_asset.tuid) })
                        CALL apoc.util.validate(track IS NULL, "Could not find the track %s", [source_asset.tuid])
                        MERGE (track)-[trackHasAsset:HAS_ASSET]->(asset)
                            ON CREATE SET
                                trackHasAsset.createdAt = datetime(),
                                trackHasAsset.createdBy = by,
                                trackHasAsset.lastModifiedAt = datetime(),
                                trackHasAsset.lastModifiedBy = by
                    ',
                    {
                        batchSize: 1000
                    }
                )
                YIELD failedOperations, errorMessages, failedBatches, batch
                CALL apoc.util.validate(failedOperations > 0, "At least one sub-operation failed: %s", [reduce(all_errors = "", error IN keys(errorMessages) | all_errors + ", " + error)])
                CALL apoc.util.validate(failedBatches > 0, "At least one batch failed: %s", [reduce(all_errors = "", error IN keys(batch.errors) | all_errors + ", " + error)])
                RETURN 0
            ]]>
        </query>
        <query>
            CALL apoc.log.info("Finished acr_cloud data ingest part 114 of 169 at %s", [datetime()]);
        </query>

        <query>
            <![CDATA[
                CALL apoc.periodic.iterate(
                     "
                        WITH 'snowflake_orchard' AS url_alias,
                        '
                            SELECT * FROM facts.qa.jsonified_track_mapping ORDER BY ACR_ID ASC LIMIT 100000 OFFSET 11400000
                        '
                        AS sql
                        CALL apoc.load.jdbc(url_alias, sql)
                        YIELD row
                        return apoc.convert.fromJsonMap(row.NODE) AS row;
                    ",
                    '
                        WITH *, "database/distro-4707" AS by
                        MERGE (acrId:ACRID { id: row.acr_id })
                            ON CREATE SET
                                acrId.createdAt = datetime(),
                                acrId.createdBy = by,
                                acrId.lastModifiedAt = datetime(),
                                acrId.lastModifiedBy = by
                        MERGE (acrId)<-[acrIdToOsr:CONTAINS_FINGERPRINT]-(osr:OrchardSoundRecording)
                            ON CREATE SET
                                osr.id = apoc.create.uuid(),
                                osr.createdAt = datetime(),
                                osr.createdBy = by,
                                osr.lastModifiedAt = datetime(),
                                osr.lastModifiedBy = by,
                                acrIdToOsr.createdAt = datetime(),
                                acrIdToOsr.createdBy = by,
                                acrIdToOsr.lastModifiedAt = datetime(),
                                acrIdToOsr.lastModifiedBy = by
                        WITH *
                        UNWIND row.assets AS source_asset
                        MERGE (asset:OrchardAsset {
                            filename: source_asset.filename,
                            extension: "mp3",
                            source: "direct-delivery-db"
                        })
                            ON CREATE SET
                                asset.id = apoc.create.uuid(),
                                asset.createdAt = datetime(),
                                asset.createdBy = by,
                                asset.lastModifiedAt = datetime(),
                                asset.lastModifiedBy = by
                        MERGE (asset)-[assetToAcrId:FINGERPRINTED_AS]->(acrId)
                            ON CREATE SET
                                assetToAcrId.createdAt = datetime(),
                                assetToAcrId.createdBy = by
                            SET
                                assetToAcrId.lastModifiedAt = datetime(),
                                assetToAcrId.lastModifiedBy = by
                        WITH *
                        OPTIONAL MATCH (asset)-[assetToOldAcrId:FINGERPRINTED_AS]->(oldAcrId:ACRID)
                            WHERE oldAcrId <> acrId
                        FOREACH (hasOldAcrId IN CASE WHEN oldAcrId IS NOT NULL THEN [1] ELSE [] END |
                            CREATE (asset)-[deletedRelationship:DELETED_FINGERPRINTED_AS]->(oldAcrId)
                            SET
                                deletedRelationship += assetToOldAcrId,
                                deletedRelationship.deletedAt = datetime(),
                                deletedRelationship.deletedBy = by
                            DELETE assetToOldAcrId
                        )
                        WITH DISTINCT source_asset, by, asset
                        OPTIONAL MATCH (track:Track { id: toInteger(source_asset.tuid) })
                        CALL apoc.util.validate(track IS NULL, "Could not find the track %s", [source_asset.tuid])
                        MERGE (track)-[trackHasAsset:HAS_ASSET]->(asset)
                            ON CREATE SET
                                trackHasAsset.createdAt = datetime(),
                                trackHasAsset.createdBy = by,
                                trackHasAsset.lastModifiedAt = datetime(),
                                trackHasAsset.lastModifiedBy = by
                    ',
                    {
                        batchSize: 1000
                    }
                )
                YIELD failedOperations, errorMessages, failedBatches, batch
                CALL apoc.util.validate(failedOperations > 0, "At least one sub-operation failed: %s", [reduce(all_errors = "", error IN keys(errorMessages) | all_errors + ", " + error)])
                CALL apoc.util.validate(failedBatches > 0, "At least one batch failed: %s", [reduce(all_errors = "", error IN keys(batch.errors) | all_errors + ", " + error)])
                RETURN 0
            ]]>
        </query>
        <query>
            CALL apoc.log.info("Finished acr_cloud data ingest part 115 of 169 at %s", [datetime()]);
        </query>

        <query>
            <![CDATA[
                CALL apoc.periodic.iterate(
                     "
                        WITH 'snowflake_orchard' AS url_alias,
                        '
                            SELECT * FROM facts.qa.jsonified_track_mapping ORDER BY ACR_ID ASC LIMIT 100000 OFFSET 11500000
                        '
                        AS sql
                        CALL apoc.load.jdbc(url_alias, sql)
                        YIELD row
                        return apoc.convert.fromJsonMap(row.NODE) AS row;
                    ",
                    '
                        WITH *, "database/distro-4707" AS by
                        MERGE (acrId:ACRID { id: row.acr_id })
                            ON CREATE SET
                                acrId.createdAt = datetime(),
                                acrId.createdBy = by,
                                acrId.lastModifiedAt = datetime(),
                                acrId.lastModifiedBy = by
                        MERGE (acrId)<-[acrIdToOsr:CONTAINS_FINGERPRINT]-(osr:OrchardSoundRecording)
                            ON CREATE SET
                                osr.id = apoc.create.uuid(),
                                osr.createdAt = datetime(),
                                osr.createdBy = by,
                                osr.lastModifiedAt = datetime(),
                                osr.lastModifiedBy = by,
                                acrIdToOsr.createdAt = datetime(),
                                acrIdToOsr.createdBy = by,
                                acrIdToOsr.lastModifiedAt = datetime(),
                                acrIdToOsr.lastModifiedBy = by
                        WITH *
                        UNWIND row.assets AS source_asset
                        MERGE (asset:OrchardAsset {
                            filename: source_asset.filename,
                            extension: "mp3",
                            source: "direct-delivery-db"
                        })
                            ON CREATE SET
                                asset.id = apoc.create.uuid(),
                                asset.createdAt = datetime(),
                                asset.createdBy = by,
                                asset.lastModifiedAt = datetime(),
                                asset.lastModifiedBy = by
                        MERGE (asset)-[assetToAcrId:FINGERPRINTED_AS]->(acrId)
                            ON CREATE SET
                                assetToAcrId.createdAt = datetime(),
                                assetToAcrId.createdBy = by
                            SET
                                assetToAcrId.lastModifiedAt = datetime(),
                                assetToAcrId.lastModifiedBy = by
                        WITH *
                        OPTIONAL MATCH (asset)-[assetToOldAcrId:FINGERPRINTED_AS]->(oldAcrId:ACRID)
                            WHERE oldAcrId <> acrId
                        FOREACH (hasOldAcrId IN CASE WHEN oldAcrId IS NOT NULL THEN [1] ELSE [] END |
                            CREATE (asset)-[deletedRelationship:DELETED_FINGERPRINTED_AS]->(oldAcrId)
                            SET
                                deletedRelationship += assetToOldAcrId,
                                deletedRelationship.deletedAt = datetime(),
                                deletedRelationship.deletedBy = by
                            DELETE assetToOldAcrId
                        )
                        WITH DISTINCT source_asset, by, asset
                        OPTIONAL MATCH (track:Track { id: toInteger(source_asset.tuid) })
                        CALL apoc.util.validate(track IS NULL, "Could not find the track %s", [source_asset.tuid])
                        MERGE (track)-[trackHasAsset:HAS_ASSET]->(asset)
                            ON CREATE SET
                                trackHasAsset.createdAt = datetime(),
                                trackHasAsset.createdBy = by,
                                trackHasAsset.lastModifiedAt = datetime(),
                                trackHasAsset.lastModifiedBy = by
                    ',
                    {
                        batchSize: 1000
                    }
                )
                YIELD failedOperations, errorMessages, failedBatches, batch
                CALL apoc.util.validate(failedOperations > 0, "At least one sub-operation failed: %s", [reduce(all_errors = "", error IN keys(errorMessages) | all_errors + ", " + error)])
                CALL apoc.util.validate(failedBatches > 0, "At least one batch failed: %s", [reduce(all_errors = "", error IN keys(batch.errors) | all_errors + ", " + error)])
                RETURN 0
            ]]>
        </query>
        <query>
            CALL apoc.log.info("Finished acr_cloud data ingest part 116 of 169 at %s", [datetime()]);
        </query>

        <query>
            <![CDATA[
                CALL apoc.periodic.iterate(
                     "
                        WITH 'snowflake_orchard' AS url_alias,
                        '
                            SELECT * FROM facts.qa.jsonified_track_mapping ORDER BY ACR_ID ASC LIMIT 100000 OFFSET 11600000
                        '
                        AS sql
                        CALL apoc.load.jdbc(url_alias, sql)
                        YIELD row
                        return apoc.convert.fromJsonMap(row.NODE) AS row;
                    ",
                    '
                        WITH *, "database/distro-4707" AS by
                        MERGE (acrId:ACRID { id: row.acr_id })
                            ON CREATE SET
                                acrId.createdAt = datetime(),
                                acrId.createdBy = by,
                                acrId.lastModifiedAt = datetime(),
                                acrId.lastModifiedBy = by
                        MERGE (acrId)<-[acrIdToOsr:CONTAINS_FINGERPRINT]-(osr:OrchardSoundRecording)
                            ON CREATE SET
                                osr.id = apoc.create.uuid(),
                                osr.createdAt = datetime(),
                                osr.createdBy = by,
                                osr.lastModifiedAt = datetime(),
                                osr.lastModifiedBy = by,
                                acrIdToOsr.createdAt = datetime(),
                                acrIdToOsr.createdBy = by,
                                acrIdToOsr.lastModifiedAt = datetime(),
                                acrIdToOsr.lastModifiedBy = by
                        WITH *
                        UNWIND row.assets AS source_asset
                        MERGE (asset:OrchardAsset {
                            filename: source_asset.filename,
                            extension: "mp3",
                            source: "direct-delivery-db"
                        })
                            ON CREATE SET
                                asset.id = apoc.create.uuid(),
                                asset.createdAt = datetime(),
                                asset.createdBy = by,
                                asset.lastModifiedAt = datetime(),
                                asset.lastModifiedBy = by
                        MERGE (asset)-[assetToAcrId:FINGERPRINTED_AS]->(acrId)
                            ON CREATE SET
                                assetToAcrId.createdAt = datetime(),
                                assetToAcrId.createdBy = by
                            SET
                                assetToAcrId.lastModifiedAt = datetime(),
                                assetToAcrId.lastModifiedBy = by
                        WITH *
                        OPTIONAL MATCH (asset)-[assetToOldAcrId:FINGERPRINTED_AS]->(oldAcrId:ACRID)
                            WHERE oldAcrId <> acrId
                        FOREACH (hasOldAcrId IN CASE WHEN oldAcrId IS NOT NULL THEN [1] ELSE [] END |
                            CREATE (asset)-[deletedRelationship:DELETED_FINGERPRINTED_AS]->(oldAcrId)
                            SET
                                deletedRelationship += assetToOldAcrId,
                                deletedRelationship.deletedAt = datetime(),
                                deletedRelationship.deletedBy = by
                            DELETE assetToOldAcrId
                        )
                        WITH DISTINCT source_asset, by, asset
                        OPTIONAL MATCH (track:Track { id: toInteger(source_asset.tuid) })
                        CALL apoc.util.validate(track IS NULL, "Could not find the track %s", [source_asset.tuid])
                        MERGE (track)-[trackHasAsset:HAS_ASSET]->(asset)
                            ON CREATE SET
                                trackHasAsset.createdAt = datetime(),
                                trackHasAsset.createdBy = by,
                                trackHasAsset.lastModifiedAt = datetime(),
                                trackHasAsset.lastModifiedBy = by
                    ',
                    {
                        batchSize: 1000
                    }
                )
                YIELD failedOperations, errorMessages, failedBatches, batch
                CALL apoc.util.validate(failedOperations > 0, "At least one sub-operation failed: %s", [reduce(all_errors = "", error IN keys(errorMessages) | all_errors + ", " + error)])
                CALL apoc.util.validate(failedBatches > 0, "At least one batch failed: %s", [reduce(all_errors = "", error IN keys(batch.errors) | all_errors + ", " + error)])
                RETURN 0
            ]]>
        </query>
        <query>
            CALL apoc.log.info("Finished acr_cloud data ingest part 117 of 169 at %s", [datetime()]);
        </query>

        <query>
            <![CDATA[
                CALL apoc.periodic.iterate(
                     "
                        WITH 'snowflake_orchard' AS url_alias,
                        '
                            SELECT * FROM facts.qa.jsonified_track_mapping ORDER BY ACR_ID ASC LIMIT 100000 OFFSET 11700000
                        '
                        AS sql
                        CALL apoc.load.jdbc(url_alias, sql)
                        YIELD row
                        return apoc.convert.fromJsonMap(row.NODE) AS row;
                    ",
                    '
                        WITH *, "database/distro-4707" AS by
                        MERGE (acrId:ACRID { id: row.acr_id })
                            ON CREATE SET
                                acrId.createdAt = datetime(),
                                acrId.createdBy = by,
                                acrId.lastModifiedAt = datetime(),
                                acrId.lastModifiedBy = by
                        MERGE (acrId)<-[acrIdToOsr:CONTAINS_FINGERPRINT]-(osr:OrchardSoundRecording)
                            ON CREATE SET
                                osr.id = apoc.create.uuid(),
                                osr.createdAt = datetime(),
                                osr.createdBy = by,
                                osr.lastModifiedAt = datetime(),
                                osr.lastModifiedBy = by,
                                acrIdToOsr.createdAt = datetime(),
                                acrIdToOsr.createdBy = by,
                                acrIdToOsr.lastModifiedAt = datetime(),
                                acrIdToOsr.lastModifiedBy = by
                        WITH *
                        UNWIND row.assets AS source_asset
                        MERGE (asset:OrchardAsset {
                            filename: source_asset.filename,
                            extension: "mp3",
                            source: "direct-delivery-db"
                        })
                            ON CREATE SET
                                asset.id = apoc.create.uuid(),
                                asset.createdAt = datetime(),
                                asset.createdBy = by,
                                asset.lastModifiedAt = datetime(),
                                asset.lastModifiedBy = by
                        MERGE (asset)-[assetToAcrId:FINGERPRINTED_AS]->(acrId)
                            ON CREATE SET
                                assetToAcrId.createdAt = datetime(),
                                assetToAcrId.createdBy = by
                            SET
                                assetToAcrId.lastModifiedAt = datetime(),
                                assetToAcrId.lastModifiedBy = by
                        WITH *
                        OPTIONAL MATCH (asset)-[assetToOldAcrId:FINGERPRINTED_AS]->(oldAcrId:ACRID)
                            WHERE oldAcrId <> acrId
                        FOREACH (hasOldAcrId IN CASE WHEN oldAcrId IS NOT NULL THEN [1] ELSE [] END |
                            CREATE (asset)-[deletedRelationship:DELETED_FINGERPRINTED_AS]->(oldAcrId)
                            SET
                                deletedRelationship += assetToOldAcrId,
                                deletedRelationship.deletedAt = datetime(),
                                deletedRelationship.deletedBy = by
                            DELETE assetToOldAcrId
                        )
                        WITH DISTINCT source_asset, by, asset
                        OPTIONAL MATCH (track:Track { id: toInteger(source_asset.tuid) })
                        CALL apoc.util.validate(track IS NULL, "Could not find the track %s", [source_asset.tuid])
                        MERGE (track)-[trackHasAsset:HAS_ASSET]->(asset)
                            ON CREATE SET
                                trackHasAsset.createdAt = datetime(),
                                trackHasAsset.createdBy = by,
                                trackHasAsset.lastModifiedAt = datetime(),
                                trackHasAsset.lastModifiedBy = by
                    ',
                    {
                        batchSize: 1000
                    }
                )
                YIELD failedOperations, errorMessages, failedBatches, batch
                CALL apoc.util.validate(failedOperations > 0, "At least one sub-operation failed: %s", [reduce(all_errors = "", error IN keys(errorMessages) | all_errors + ", " + error)])
                CALL apoc.util.validate(failedBatches > 0, "At least one batch failed: %s", [reduce(all_errors = "", error IN keys(batch.errors) | all_errors + ", " + error)])
                RETURN 0
            ]]>
        </query>
        <query>
            CALL apoc.log.info("Finished acr_cloud data ingest part 118 of 169 at %s", [datetime()]);
        </query>

        <query>
            <![CDATA[
                CALL apoc.periodic.iterate(
                     "
                        WITH 'snowflake_orchard' AS url_alias,
                        '
                            SELECT * FROM facts.qa.jsonified_track_mapping ORDER BY ACR_ID ASC LIMIT 100000 OFFSET 11800000
                        '
                        AS sql
                        CALL apoc.load.jdbc(url_alias, sql)
                        YIELD row
                        return apoc.convert.fromJsonMap(row.NODE) AS row;
                    ",
                    '
                        WITH *, "database/distro-4707" AS by
                        MERGE (acrId:ACRID { id: row.acr_id })
                            ON CREATE SET
                                acrId.createdAt = datetime(),
                                acrId.createdBy = by,
                                acrId.lastModifiedAt = datetime(),
                                acrId.lastModifiedBy = by
                        MERGE (acrId)<-[acrIdToOsr:CONTAINS_FINGERPRINT]-(osr:OrchardSoundRecording)
                            ON CREATE SET
                                osr.id = apoc.create.uuid(),
                                osr.createdAt = datetime(),
                                osr.createdBy = by,
                                osr.lastModifiedAt = datetime(),
                                osr.lastModifiedBy = by,
                                acrIdToOsr.createdAt = datetime(),
                                acrIdToOsr.createdBy = by,
                                acrIdToOsr.lastModifiedAt = datetime(),
                                acrIdToOsr.lastModifiedBy = by
                        WITH *
                        UNWIND row.assets AS source_asset
                        MERGE (asset:OrchardAsset {
                            filename: source_asset.filename,
                            extension: "mp3",
                            source: "direct-delivery-db"
                        })
                            ON CREATE SET
                                asset.id = apoc.create.uuid(),
                                asset.createdAt = datetime(),
                                asset.createdBy = by,
                                asset.lastModifiedAt = datetime(),
                                asset.lastModifiedBy = by
                        MERGE (asset)-[assetToAcrId:FINGERPRINTED_AS]->(acrId)
                            ON CREATE SET
                                assetToAcrId.createdAt = datetime(),
                                assetToAcrId.createdBy = by
                            SET
                                assetToAcrId.lastModifiedAt = datetime(),
                                assetToAcrId.lastModifiedBy = by
                        WITH *
                        OPTIONAL MATCH (asset)-[assetToOldAcrId:FINGERPRINTED_AS]->(oldAcrId:ACRID)
                            WHERE oldAcrId <> acrId
                        FOREACH (hasOldAcrId IN CASE WHEN oldAcrId IS NOT NULL THEN [1] ELSE [] END |
                            CREATE (asset)-[deletedRelationship:DELETED_FINGERPRINTED_AS]->(oldAcrId)
                            SET
                                deletedRelationship += assetToOldAcrId,
                                deletedRelationship.deletedAt = datetime(),
                                deletedRelationship.deletedBy = by
                            DELETE assetToOldAcrId
                        )
                        WITH DISTINCT source_asset, by, asset
                        OPTIONAL MATCH (track:Track { id: toInteger(source_asset.tuid) })
                        CALL apoc.util.validate(track IS NULL, "Could not find the track %s", [source_asset.tuid])
                        MERGE (track)-[trackHasAsset:HAS_ASSET]->(asset)
                            ON CREATE SET
                                trackHasAsset.createdAt = datetime(),
                                trackHasAsset.createdBy = by,
                                trackHasAsset.lastModifiedAt = datetime(),
                                trackHasAsset.lastModifiedBy = by
                    ',
                    {
                        batchSize: 1000
                    }
                )
                YIELD failedOperations, errorMessages, failedBatches, batch
                CALL apoc.util.validate(failedOperations > 0, "At least one sub-operation failed: %s", [reduce(all_errors = "", error IN keys(errorMessages) | all_errors + ", " + error)])
                CALL apoc.util.validate(failedBatches > 0, "At least one batch failed: %s", [reduce(all_errors = "", error IN keys(batch.errors) | all_errors + ", " + error)])
                RETURN 0
            ]]>
        </query>
        <query>
            CALL apoc.log.info("Finished acr_cloud data ingest part 119 of 169 at %s", [datetime()]);
        </query>

        <query>
            <![CDATA[
                CALL apoc.periodic.iterate(
                     "
                        WITH 'snowflake_orchard' AS url_alias,
                        '
                            SELECT * FROM facts.qa.jsonified_track_mapping ORDER BY ACR_ID ASC LIMIT 100000 OFFSET 11900000
                        '
                        AS sql
                        CALL apoc.load.jdbc(url_alias, sql)
                        YIELD row
                        return apoc.convert.fromJsonMap(row.NODE) AS row;
                    ",
                    '
                        WITH *, "database/distro-4707" AS by
                        MERGE (acrId:ACRID { id: row.acr_id })
                            ON CREATE SET
                                acrId.createdAt = datetime(),
                                acrId.createdBy = by,
                                acrId.lastModifiedAt = datetime(),
                                acrId.lastModifiedBy = by
                        MERGE (acrId)<-[acrIdToOsr:CONTAINS_FINGERPRINT]-(osr:OrchardSoundRecording)
                            ON CREATE SET
                                osr.id = apoc.create.uuid(),
                                osr.createdAt = datetime(),
                                osr.createdBy = by,
                                osr.lastModifiedAt = datetime(),
                                osr.lastModifiedBy = by,
                                acrIdToOsr.createdAt = datetime(),
                                acrIdToOsr.createdBy = by,
                                acrIdToOsr.lastModifiedAt = datetime(),
                                acrIdToOsr.lastModifiedBy = by
                        WITH *
                        UNWIND row.assets AS source_asset
                        MERGE (asset:OrchardAsset {
                            filename: source_asset.filename,
                            extension: "mp3",
                            source: "direct-delivery-db"
                        })
                            ON CREATE SET
                                asset.id = apoc.create.uuid(),
                                asset.createdAt = datetime(),
                                asset.createdBy = by,
                                asset.lastModifiedAt = datetime(),
                                asset.lastModifiedBy = by
                        MERGE (asset)-[assetToAcrId:FINGERPRINTED_AS]->(acrId)
                            ON CREATE SET
                                assetToAcrId.createdAt = datetime(),
                                assetToAcrId.createdBy = by
                            SET
                                assetToAcrId.lastModifiedAt = datetime(),
                                assetToAcrId.lastModifiedBy = by
                        WITH *
                        OPTIONAL MATCH (asset)-[assetToOldAcrId:FINGERPRINTED_AS]->(oldAcrId:ACRID)
                            WHERE oldAcrId <> acrId
                        FOREACH (hasOldAcrId IN CASE WHEN oldAcrId IS NOT NULL THEN [1] ELSE [] END |
                            CREATE (asset)-[deletedRelationship:DELETED_FINGERPRINTED_AS]->(oldAcrId)
                            SET
                                deletedRelationship += assetToOldAcrId,
                                deletedRelationship.deletedAt = datetime(),
                                deletedRelationship.deletedBy = by
                            DELETE assetToOldAcrId
                        )
                        WITH DISTINCT source_asset, by, asset
                        OPTIONAL MATCH (track:Track { id: toInteger(source_asset.tuid) })
                        CALL apoc.util.validate(track IS NULL, "Could not find the track %s", [source_asset.tuid])
                        MERGE (track)-[trackHasAsset:HAS_ASSET]->(asset)
                            ON CREATE SET
                                trackHasAsset.createdAt = datetime(),
                                trackHasAsset.createdBy = by,
                                trackHasAsset.lastModifiedAt = datetime(),
                                trackHasAsset.lastModifiedBy = by
                    ',
                    {
                        batchSize: 1000
                    }
                )
                YIELD failedOperations, errorMessages, failedBatches, batch
                CALL apoc.util.validate(failedOperations > 0, "At least one sub-operation failed: %s", [reduce(all_errors = "", error IN keys(errorMessages) | all_errors + ", " + error)])
                CALL apoc.util.validate(failedBatches > 0, "At least one batch failed: %s", [reduce(all_errors = "", error IN keys(batch.errors) | all_errors + ", " + error)])
                RETURN 0
            ]]>
        </query>
        <query>
            CALL apoc.log.info("Finished acr_cloud data ingest part 120 of 169 at %s", [datetime()]);
        </query>

        <query>
            <![CDATA[
                CALL apoc.periodic.iterate(
                     "
                        WITH 'snowflake_orchard' AS url_alias,
                        '
                            SELECT * FROM facts.qa.jsonified_track_mapping ORDER BY ACR_ID ASC LIMIT 100000 OFFSET 12000000
                        '
                        AS sql
                        CALL apoc.load.jdbc(url_alias, sql)
                        YIELD row
                        return apoc.convert.fromJsonMap(row.NODE) AS row;
                    ",
                    '
                        WITH *, "database/distro-4707" AS by
                        MERGE (acrId:ACRID { id: row.acr_id })
                            ON CREATE SET
                                acrId.createdAt = datetime(),
                                acrId.createdBy = by,
                                acrId.lastModifiedAt = datetime(),
                                acrId.lastModifiedBy = by
                        MERGE (acrId)<-[acrIdToOsr:CONTAINS_FINGERPRINT]-(osr:OrchardSoundRecording)
                            ON CREATE SET
                                osr.id = apoc.create.uuid(),
                                osr.createdAt = datetime(),
                                osr.createdBy = by,
                                osr.lastModifiedAt = datetime(),
                                osr.lastModifiedBy = by,
                                acrIdToOsr.createdAt = datetime(),
                                acrIdToOsr.createdBy = by,
                                acrIdToOsr.lastModifiedAt = datetime(),
                                acrIdToOsr.lastModifiedBy = by
                        WITH *
                        UNWIND row.assets AS source_asset
                        MERGE (asset:OrchardAsset {
                            filename: source_asset.filename,
                            extension: "mp3",
                            source: "direct-delivery-db"
                        })
                            ON CREATE SET
                                asset.id = apoc.create.uuid(),
                                asset.createdAt = datetime(),
                                asset.createdBy = by,
                                asset.lastModifiedAt = datetime(),
                                asset.lastModifiedBy = by
                        MERGE (asset)-[assetToAcrId:FINGERPRINTED_AS]->(acrId)
                            ON CREATE SET
                                assetToAcrId.createdAt = datetime(),
                                assetToAcrId.createdBy = by
                            SET
                                assetToAcrId.lastModifiedAt = datetime(),
                                assetToAcrId.lastModifiedBy = by
                        WITH *
                        OPTIONAL MATCH (asset)-[assetToOldAcrId:FINGERPRINTED_AS]->(oldAcrId:ACRID)
                            WHERE oldAcrId <> acrId
                        FOREACH (hasOldAcrId IN CASE WHEN oldAcrId IS NOT NULL THEN [1] ELSE [] END |
                            CREATE (asset)-[deletedRelationship:DELETED_FINGERPRINTED_AS]->(oldAcrId)
                            SET
                                deletedRelationship += assetToOldAcrId,
                                deletedRelationship.deletedAt = datetime(),
                                deletedRelationship.deletedBy = by
                            DELETE assetToOldAcrId
                        )
                        WITH DISTINCT source_asset, by, asset
                        OPTIONAL MATCH (track:Track { id: toInteger(source_asset.tuid) })
                        CALL apoc.util.validate(track IS NULL, "Could not find the track %s", [source_asset.tuid])
                        MERGE (track)-[trackHasAsset:HAS_ASSET]->(asset)
                            ON CREATE SET
                                trackHasAsset.createdAt = datetime(),
                                trackHasAsset.createdBy = by,
                                trackHasAsset.lastModifiedAt = datetime(),
                                trackHasAsset.lastModifiedBy = by
                    ',
                    {
                        batchSize: 1000
                    }
                )
                YIELD failedOperations, errorMessages, failedBatches, batch
                CALL apoc.util.validate(failedOperations > 0, "At least one sub-operation failed: %s", [reduce(all_errors = "", error IN keys(errorMessages) | all_errors + ", " + error)])
                CALL apoc.util.validate(failedBatches > 0, "At least one batch failed: %s", [reduce(all_errors = "", error IN keys(batch.errors) | all_errors + ", " + error)])
                RETURN 0
            ]]>
        </query>
        <query>
            CALL apoc.log.info("Finished acr_cloud data ingest part 121 of 169 at %s", [datetime()]);
        </query>

        <query>
            <![CDATA[
                CALL apoc.periodic.iterate(
                     "
                        WITH 'snowflake_orchard' AS url_alias,
                        '
                            SELECT * FROM facts.qa.jsonified_track_mapping ORDER BY ACR_ID ASC LIMIT 100000 OFFSET 12100000
                        '
                        AS sql
                        CALL apoc.load.jdbc(url_alias, sql)
                        YIELD row
                        return apoc.convert.fromJsonMap(row.NODE) AS row;
                    ",
                    '
                        WITH *, "database/distro-4707" AS by
                        MERGE (acrId:ACRID { id: row.acr_id })
                            ON CREATE SET
                                acrId.createdAt = datetime(),
                                acrId.createdBy = by,
                                acrId.lastModifiedAt = datetime(),
                                acrId.lastModifiedBy = by
                        MERGE (acrId)<-[acrIdToOsr:CONTAINS_FINGERPRINT]-(osr:OrchardSoundRecording)
                            ON CREATE SET
                                osr.id = apoc.create.uuid(),
                                osr.createdAt = datetime(),
                                osr.createdBy = by,
                                osr.lastModifiedAt = datetime(),
                                osr.lastModifiedBy = by,
                                acrIdToOsr.createdAt = datetime(),
                                acrIdToOsr.createdBy = by,
                                acrIdToOsr.lastModifiedAt = datetime(),
                                acrIdToOsr.lastModifiedBy = by
                        WITH *
                        UNWIND row.assets AS source_asset
                        MERGE (asset:OrchardAsset {
                            filename: source_asset.filename,
                            extension: "mp3",
                            source: "direct-delivery-db"
                        })
                            ON CREATE SET
                                asset.id = apoc.create.uuid(),
                                asset.createdAt = datetime(),
                                asset.createdBy = by,
                                asset.lastModifiedAt = datetime(),
                                asset.lastModifiedBy = by
                        MERGE (asset)-[assetToAcrId:FINGERPRINTED_AS]->(acrId)
                            ON CREATE SET
                                assetToAcrId.createdAt = datetime(),
                                assetToAcrId.createdBy = by
                            SET
                                assetToAcrId.lastModifiedAt = datetime(),
                                assetToAcrId.lastModifiedBy = by
                        WITH *
                        OPTIONAL MATCH (asset)-[assetToOldAcrId:FINGERPRINTED_AS]->(oldAcrId:ACRID)
                            WHERE oldAcrId <> acrId
                        FOREACH (hasOldAcrId IN CASE WHEN oldAcrId IS NOT NULL THEN [1] ELSE [] END |
                            CREATE (asset)-[deletedRelationship:DELETED_FINGERPRINTED_AS]->(oldAcrId)
                            SET
                                deletedRelationship += assetToOldAcrId,
                                deletedRelationship.deletedAt = datetime(),
                                deletedRelationship.deletedBy = by
                            DELETE assetToOldAcrId
                        )
                        WITH DISTINCT source_asset, by, asset
                        OPTIONAL MATCH (track:Track { id: toInteger(source_asset.tuid) })
                        CALL apoc.util.validate(track IS NULL, "Could not find the track %s", [source_asset.tuid])
                        MERGE (track)-[trackHasAsset:HAS_ASSET]->(asset)
                            ON CREATE SET
                                trackHasAsset.createdAt = datetime(),
                                trackHasAsset.createdBy = by,
                                trackHasAsset.lastModifiedAt = datetime(),
                                trackHasAsset.lastModifiedBy = by
                    ',
                    {
                        batchSize: 1000
                    }
                )
                YIELD failedOperations, errorMessages, failedBatches, batch
                CALL apoc.util.validate(failedOperations > 0, "At least one sub-operation failed: %s", [reduce(all_errors = "", error IN keys(errorMessages) | all_errors + ", " + error)])
                CALL apoc.util.validate(failedBatches > 0, "At least one batch failed: %s", [reduce(all_errors = "", error IN keys(batch.errors) | all_errors + ", " + error)])
                RETURN 0
            ]]>
        </query>
        <query>
            CALL apoc.log.info("Finished acr_cloud data ingest part 122 of 169 at %s", [datetime()]);
        </query>

        <query>
            <![CDATA[
                CALL apoc.periodic.iterate(
                     "
                        WITH 'snowflake_orchard' AS url_alias,
                        '
                            SELECT * FROM facts.qa.jsonified_track_mapping ORDER BY ACR_ID ASC LIMIT 100000 OFFSET 12200000
                        '
                        AS sql
                        CALL apoc.load.jdbc(url_alias, sql)
                        YIELD row
                        return apoc.convert.fromJsonMap(row.NODE) AS row;
                    ",
                    '
                        WITH *, "database/distro-4707" AS by
                        MERGE (acrId:ACRID { id: row.acr_id })
                            ON CREATE SET
                                acrId.createdAt = datetime(),
                                acrId.createdBy = by,
                                acrId.lastModifiedAt = datetime(),
                                acrId.lastModifiedBy = by
                        MERGE (acrId)<-[acrIdToOsr:CONTAINS_FINGERPRINT]-(osr:OrchardSoundRecording)
                            ON CREATE SET
                                osr.id = apoc.create.uuid(),
                                osr.createdAt = datetime(),
                                osr.createdBy = by,
                                osr.lastModifiedAt = datetime(),
                                osr.lastModifiedBy = by,
                                acrIdToOsr.createdAt = datetime(),
                                acrIdToOsr.createdBy = by,
                                acrIdToOsr.lastModifiedAt = datetime(),
                                acrIdToOsr.lastModifiedBy = by
                        WITH *
                        UNWIND row.assets AS source_asset
                        MERGE (asset:OrchardAsset {
                            filename: source_asset.filename,
                            extension: "mp3",
                            source: "direct-delivery-db"
                        })
                            ON CREATE SET
                                asset.id = apoc.create.uuid(),
                                asset.createdAt = datetime(),
                                asset.createdBy = by,
                                asset.lastModifiedAt = datetime(),
                                asset.lastModifiedBy = by
                        MERGE (asset)-[assetToAcrId:FINGERPRINTED_AS]->(acrId)
                            ON CREATE SET
                                assetToAcrId.createdAt = datetime(),
                                assetToAcrId.createdBy = by
                            SET
                                assetToAcrId.lastModifiedAt = datetime(),
                                assetToAcrId.lastModifiedBy = by
                        WITH *
                        OPTIONAL MATCH (asset)-[assetToOldAcrId:FINGERPRINTED_AS]->(oldAcrId:ACRID)
                            WHERE oldAcrId <> acrId
                        FOREACH (hasOldAcrId IN CASE WHEN oldAcrId IS NOT NULL THEN [1] ELSE [] END |
                            CREATE (asset)-[deletedRelationship:DELETED_FINGERPRINTED_AS]->(oldAcrId)
                            SET
                                deletedRelationship += assetToOldAcrId,
                                deletedRelationship.deletedAt = datetime(),
                                deletedRelationship.deletedBy = by
                            DELETE assetToOldAcrId
                        )
                        WITH DISTINCT source_asset, by, asset
                        OPTIONAL MATCH (track:Track { id: toInteger(source_asset.tuid) })
                        CALL apoc.util.validate(track IS NULL, "Could not find the track %s", [source_asset.tuid])
                        MERGE (track)-[trackHasAsset:HAS_ASSET]->(asset)
                            ON CREATE SET
                                trackHasAsset.createdAt = datetime(),
                                trackHasAsset.createdBy = by,
                                trackHasAsset.lastModifiedAt = datetime(),
                                trackHasAsset.lastModifiedBy = by
                    ',
                    {
                        batchSize: 1000
                    }
                )
                YIELD failedOperations, errorMessages, failedBatches, batch
                CALL apoc.util.validate(failedOperations > 0, "At least one sub-operation failed: %s", [reduce(all_errors = "", error IN keys(errorMessages) | all_errors + ", " + error)])
                CALL apoc.util.validate(failedBatches > 0, "At least one batch failed: %s", [reduce(all_errors = "", error IN keys(batch.errors) | all_errors + ", " + error)])
                RETURN 0
            ]]>
        </query>
        <query>
            CALL apoc.log.info("Finished acr_cloud data ingest part 123 of 169 at %s", [datetime()]);
        </query>

        <query>
            <![CDATA[
                CALL apoc.periodic.iterate(
                     "
                        WITH 'snowflake_orchard' AS url_alias,
                        '
                            SELECT * FROM facts.qa.jsonified_track_mapping ORDER BY ACR_ID ASC LIMIT 100000 OFFSET 12300000
                        '
                        AS sql
                        CALL apoc.load.jdbc(url_alias, sql)
                        YIELD row
                        return apoc.convert.fromJsonMap(row.NODE) AS row;
                    ",
                    '
                        WITH *, "database/distro-4707" AS by
                        MERGE (acrId:ACRID { id: row.acr_id })
                            ON CREATE SET
                                acrId.createdAt = datetime(),
                                acrId.createdBy = by,
                                acrId.lastModifiedAt = datetime(),
                                acrId.lastModifiedBy = by
                        MERGE (acrId)<-[acrIdToOsr:CONTAINS_FINGERPRINT]-(osr:OrchardSoundRecording)
                            ON CREATE SET
                                osr.id = apoc.create.uuid(),
                                osr.createdAt = datetime(),
                                osr.createdBy = by,
                                osr.lastModifiedAt = datetime(),
                                osr.lastModifiedBy = by,
                                acrIdToOsr.createdAt = datetime(),
                                acrIdToOsr.createdBy = by,
                                acrIdToOsr.lastModifiedAt = datetime(),
                                acrIdToOsr.lastModifiedBy = by
                        WITH *
                        UNWIND row.assets AS source_asset
                        MERGE (asset:OrchardAsset {
                            filename: source_asset.filename,
                            extension: "mp3",
                            source: "direct-delivery-db"
                        })
                            ON CREATE SET
                                asset.id = apoc.create.uuid(),
                                asset.createdAt = datetime(),
                                asset.createdBy = by,
                                asset.lastModifiedAt = datetime(),
                                asset.lastModifiedBy = by
                        MERGE (asset)-[assetToAcrId:FINGERPRINTED_AS]->(acrId)
                            ON CREATE SET
                                assetToAcrId.createdAt = datetime(),
                                assetToAcrId.createdBy = by
                            SET
                                assetToAcrId.lastModifiedAt = datetime(),
                                assetToAcrId.lastModifiedBy = by
                        WITH *
                        OPTIONAL MATCH (asset)-[assetToOldAcrId:FINGERPRINTED_AS]->(oldAcrId:ACRID)
                            WHERE oldAcrId <> acrId
                        FOREACH (hasOldAcrId IN CASE WHEN oldAcrId IS NOT NULL THEN [1] ELSE [] END |
                            CREATE (asset)-[deletedRelationship:DELETED_FINGERPRINTED_AS]->(oldAcrId)
                            SET
                                deletedRelationship += assetToOldAcrId,
                                deletedRelationship.deletedAt = datetime(),
                                deletedRelationship.deletedBy = by
                            DELETE assetToOldAcrId
                        )
                        WITH DISTINCT source_asset, by, asset
                        OPTIONAL MATCH (track:Track { id: toInteger(source_asset.tuid) })
                        CALL apoc.util.validate(track IS NULL, "Could not find the track %s", [source_asset.tuid])
                        MERGE (track)-[trackHasAsset:HAS_ASSET]->(asset)
                            ON CREATE SET
                                trackHasAsset.createdAt = datetime(),
                                trackHasAsset.createdBy = by,
                                trackHasAsset.lastModifiedAt = datetime(),
                                trackHasAsset.lastModifiedBy = by
                    ',
                    {
                        batchSize: 1000
                    }
                )
                YIELD failedOperations, errorMessages, failedBatches, batch
                CALL apoc.util.validate(failedOperations > 0, "At least one sub-operation failed: %s", [reduce(all_errors = "", error IN keys(errorMessages) | all_errors + ", " + error)])
                CALL apoc.util.validate(failedBatches > 0, "At least one batch failed: %s", [reduce(all_errors = "", error IN keys(batch.errors) | all_errors + ", " + error)])
                RETURN 0
            ]]>
        </query>
        <query>
            CALL apoc.log.info("Finished acr_cloud data ingest part 124 of 169 at %s", [datetime()]);
        </query>

        <query>
            <![CDATA[
                CALL apoc.periodic.iterate(
                     "
                        WITH 'snowflake_orchard' AS url_alias,
                        '
                            SELECT * FROM facts.qa.jsonified_track_mapping ORDER BY ACR_ID ASC LIMIT 100000 OFFSET 12400000
                        '
                        AS sql
                        CALL apoc.load.jdbc(url_alias, sql)
                        YIELD row
                        return apoc.convert.fromJsonMap(row.NODE) AS row;
                    ",
                    '
                        WITH *, "database/distro-4707" AS by
                        MERGE (acrId:ACRID { id: row.acr_id })
                            ON CREATE SET
                                acrId.createdAt = datetime(),
                                acrId.createdBy = by,
                                acrId.lastModifiedAt = datetime(),
                                acrId.lastModifiedBy = by
                        MERGE (acrId)<-[acrIdToOsr:CONTAINS_FINGERPRINT]-(osr:OrchardSoundRecording)
                            ON CREATE SET
                                osr.id = apoc.create.uuid(),
                                osr.createdAt = datetime(),
                                osr.createdBy = by,
                                osr.lastModifiedAt = datetime(),
                                osr.lastModifiedBy = by,
                                acrIdToOsr.createdAt = datetime(),
                                acrIdToOsr.createdBy = by,
                                acrIdToOsr.lastModifiedAt = datetime(),
                                acrIdToOsr.lastModifiedBy = by
                        WITH *
                        UNWIND row.assets AS source_asset
                        MERGE (asset:OrchardAsset {
                            filename: source_asset.filename,
                            extension: "mp3",
                            source: "direct-delivery-db"
                        })
                            ON CREATE SET
                                asset.id = apoc.create.uuid(),
                                asset.createdAt = datetime(),
                                asset.createdBy = by,
                                asset.lastModifiedAt = datetime(),
                                asset.lastModifiedBy = by
                        MERGE (asset)-[assetToAcrId:FINGERPRINTED_AS]->(acrId)
                            ON CREATE SET
                                assetToAcrId.createdAt = datetime(),
                                assetToAcrId.createdBy = by
                            SET
                                assetToAcrId.lastModifiedAt = datetime(),
                                assetToAcrId.lastModifiedBy = by
                        WITH *
                        OPTIONAL MATCH (asset)-[assetToOldAcrId:FINGERPRINTED_AS]->(oldAcrId:ACRID)
                            WHERE oldAcrId <> acrId
                        FOREACH (hasOldAcrId IN CASE WHEN oldAcrId IS NOT NULL THEN [1] ELSE [] END |
                            CREATE (asset)-[deletedRelationship:DELETED_FINGERPRINTED_AS]->(oldAcrId)
                            SET
                                deletedRelationship += assetToOldAcrId,
                                deletedRelationship.deletedAt = datetime(),
                                deletedRelationship.deletedBy = by
                            DELETE assetToOldAcrId
                        )
                        WITH DISTINCT source_asset, by, asset
                        OPTIONAL MATCH (track:Track { id: toInteger(source_asset.tuid) })
                        CALL apoc.util.validate(track IS NULL, "Could not find the track %s", [source_asset.tuid])
                        MERGE (track)-[trackHasAsset:HAS_ASSET]->(asset)
                            ON CREATE SET
                                trackHasAsset.createdAt = datetime(),
                                trackHasAsset.createdBy = by,
                                trackHasAsset.lastModifiedAt = datetime(),
                                trackHasAsset.lastModifiedBy = by
                    ',
                    {
                        batchSize: 1000
                    }
                )
                YIELD failedOperations, errorMessages, failedBatches, batch
                CALL apoc.util.validate(failedOperations > 0, "At least one sub-operation failed: %s", [reduce(all_errors = "", error IN keys(errorMessages) | all_errors + ", " + error)])
                CALL apoc.util.validate(failedBatches > 0, "At least one batch failed: %s", [reduce(all_errors = "", error IN keys(batch.errors) | all_errors + ", " + error)])
                RETURN 0
            ]]>
        </query>
        <query>
            CALL apoc.log.info("Finished acr_cloud data ingest part 125 of 169 at %s", [datetime()]);
        </query>

        <query>
            <![CDATA[
                CALL apoc.periodic.iterate(
                     "
                        WITH 'snowflake_orchard' AS url_alias,
                        '
                            SELECT * FROM facts.qa.jsonified_track_mapping ORDER BY ACR_ID ASC LIMIT 100000 OFFSET 12500000
                        '
                        AS sql
                        CALL apoc.load.jdbc(url_alias, sql)
                        YIELD row
                        return apoc.convert.fromJsonMap(row.NODE) AS row;
                    ",
                    '
                        WITH *, "database/distro-4707" AS by
                        MERGE (acrId:ACRID { id: row.acr_id })
                            ON CREATE SET
                                acrId.createdAt = datetime(),
                                acrId.createdBy = by,
                                acrId.lastModifiedAt = datetime(),
                                acrId.lastModifiedBy = by
                        MERGE (acrId)<-[acrIdToOsr:CONTAINS_FINGERPRINT]-(osr:OrchardSoundRecording)
                            ON CREATE SET
                                osr.id = apoc.create.uuid(),
                                osr.createdAt = datetime(),
                                osr.createdBy = by,
                                osr.lastModifiedAt = datetime(),
                                osr.lastModifiedBy = by,
                                acrIdToOsr.createdAt = datetime(),
                                acrIdToOsr.createdBy = by,
                                acrIdToOsr.lastModifiedAt = datetime(),
                                acrIdToOsr.lastModifiedBy = by
                        WITH *
                        UNWIND row.assets AS source_asset
                        MERGE (asset:OrchardAsset {
                            filename: source_asset.filename,
                            extension: "mp3",
                            source: "direct-delivery-db"
                        })
                            ON CREATE SET
                                asset.id = apoc.create.uuid(),
                                asset.createdAt = datetime(),
                                asset.createdBy = by,
                                asset.lastModifiedAt = datetime(),
                                asset.lastModifiedBy = by
                        MERGE (asset)-[assetToAcrId:FINGERPRINTED_AS]->(acrId)
                            ON CREATE SET
                                assetToAcrId.createdAt = datetime(),
                                assetToAcrId.createdBy = by
                            SET
                                assetToAcrId.lastModifiedAt = datetime(),
                                assetToAcrId.lastModifiedBy = by
                        WITH *
                        OPTIONAL MATCH (asset)-[assetToOldAcrId:FINGERPRINTED_AS]->(oldAcrId:ACRID)
                            WHERE oldAcrId <> acrId
                        FOREACH (hasOldAcrId IN CASE WHEN oldAcrId IS NOT NULL THEN [1] ELSE [] END |
                            CREATE (asset)-[deletedRelationship:DELETED_FINGERPRINTED_AS]->(oldAcrId)
                            SET
                                deletedRelationship += assetToOldAcrId,
                                deletedRelationship.deletedAt = datetime(),
                                deletedRelationship.deletedBy = by
                            DELETE assetToOldAcrId
                        )
                        WITH DISTINCT source_asset, by, asset
                        OPTIONAL MATCH (track:Track { id: toInteger(source_asset.tuid) })
                        CALL apoc.util.validate(track IS NULL, "Could not find the track %s", [source_asset.tuid])
                        MERGE (track)-[trackHasAsset:HAS_ASSET]->(asset)
                            ON CREATE SET
                                trackHasAsset.createdAt = datetime(),
                                trackHasAsset.createdBy = by,
                                trackHasAsset.lastModifiedAt = datetime(),
                                trackHasAsset.lastModifiedBy = by
                    ',
                    {
                        batchSize: 1000
                    }
                )
                YIELD failedOperations, errorMessages, failedBatches, batch
                CALL apoc.util.validate(failedOperations > 0, "At least one sub-operation failed: %s", [reduce(all_errors = "", error IN keys(errorMessages) | all_errors + ", " + error)])
                CALL apoc.util.validate(failedBatches > 0, "At least one batch failed: %s", [reduce(all_errors = "", error IN keys(batch.errors) | all_errors + ", " + error)])
                RETURN 0
            ]]>
        </query>
        <query>
            CALL apoc.log.info("Finished acr_cloud data ingest part 126 of 169 at %s", [datetime()]);
        </query>

        <query>
            <![CDATA[
                CALL apoc.periodic.iterate(
                     "
                        WITH 'snowflake_orchard' AS url_alias,
                        '
                            SELECT * FROM facts.qa.jsonified_track_mapping ORDER BY ACR_ID ASC LIMIT 100000 OFFSET 12600000
                        '
                        AS sql
                        CALL apoc.load.jdbc(url_alias, sql)
                        YIELD row
                        return apoc.convert.fromJsonMap(row.NODE) AS row;
                    ",
                    '
                        WITH *, "database/distro-4707" AS by
                        MERGE (acrId:ACRID { id: row.acr_id })
                            ON CREATE SET
                                acrId.createdAt = datetime(),
                                acrId.createdBy = by,
                                acrId.lastModifiedAt = datetime(),
                                acrId.lastModifiedBy = by
                        MERGE (acrId)<-[acrIdToOsr:CONTAINS_FINGERPRINT]-(osr:OrchardSoundRecording)
                            ON CREATE SET
                                osr.id = apoc.create.uuid(),
                                osr.createdAt = datetime(),
                                osr.createdBy = by,
                                osr.lastModifiedAt = datetime(),
                                osr.lastModifiedBy = by,
                                acrIdToOsr.createdAt = datetime(),
                                acrIdToOsr.createdBy = by,
                                acrIdToOsr.lastModifiedAt = datetime(),
                                acrIdToOsr.lastModifiedBy = by
                        WITH *
                        UNWIND row.assets AS source_asset
                        MERGE (asset:OrchardAsset {
                            filename: source_asset.filename,
                            extension: "mp3",
                            source: "direct-delivery-db"
                        })
                            ON CREATE SET
                                asset.id = apoc.create.uuid(),
                                asset.createdAt = datetime(),
                                asset.createdBy = by,
                                asset.lastModifiedAt = datetime(),
                                asset.lastModifiedBy = by
                        MERGE (asset)-[assetToAcrId:FINGERPRINTED_AS]->(acrId)
                            ON CREATE SET
                                assetToAcrId.createdAt = datetime(),
                                assetToAcrId.createdBy = by
                            SET
                                assetToAcrId.lastModifiedAt = datetime(),
                                assetToAcrId.lastModifiedBy = by
                        WITH *
                        OPTIONAL MATCH (asset)-[assetToOldAcrId:FINGERPRINTED_AS]->(oldAcrId:ACRID)
                            WHERE oldAcrId <> acrId
                        FOREACH (hasOldAcrId IN CASE WHEN oldAcrId IS NOT NULL THEN [1] ELSE [] END |
                            CREATE (asset)-[deletedRelationship:DELETED_FINGERPRINTED_AS]->(oldAcrId)
                            SET
                                deletedRelationship += assetToOldAcrId,
                                deletedRelationship.deletedAt = datetime(),
                                deletedRelationship.deletedBy = by
                            DELETE assetToOldAcrId
                        )
                        WITH DISTINCT source_asset, by, asset
                        OPTIONAL MATCH (track:Track { id: toInteger(source_asset.tuid) })
                        CALL apoc.util.validate(track IS NULL, "Could not find the track %s", [source_asset.tuid])
                        MERGE (track)-[trackHasAsset:HAS_ASSET]->(asset)
                            ON CREATE SET
                                trackHasAsset.createdAt = datetime(),
                                trackHasAsset.createdBy = by,
                                trackHasAsset.lastModifiedAt = datetime(),
                                trackHasAsset.lastModifiedBy = by
                    ',
                    {
                        batchSize: 1000
                    }
                )
                YIELD failedOperations, errorMessages, failedBatches, batch
                CALL apoc.util.validate(failedOperations > 0, "At least one sub-operation failed: %s", [reduce(all_errors = "", error IN keys(errorMessages) | all_errors + ", " + error)])
                CALL apoc.util.validate(failedBatches > 0, "At least one batch failed: %s", [reduce(all_errors = "", error IN keys(batch.errors) | all_errors + ", " + error)])
                RETURN 0
            ]]>
        </query>
        <query>
            CALL apoc.log.info("Finished acr_cloud data ingest part 127 of 169 at %s", [datetime()]);
        </query>

        <query>
            <![CDATA[
                CALL apoc.periodic.iterate(
                     "
                        WITH 'snowflake_orchard' AS url_alias,
                        '
                            SELECT * FROM facts.qa.jsonified_track_mapping ORDER BY ACR_ID ASC LIMIT 100000 OFFSET 12700000
                        '
                        AS sql
                        CALL apoc.load.jdbc(url_alias, sql)
                        YIELD row
                        return apoc.convert.fromJsonMap(row.NODE) AS row;
                    ",
                    '
                        WITH *, "database/distro-4707" AS by
                        MERGE (acrId:ACRID { id: row.acr_id })
                            ON CREATE SET
                                acrId.createdAt = datetime(),
                                acrId.createdBy = by,
                                acrId.lastModifiedAt = datetime(),
                                acrId.lastModifiedBy = by
                        MERGE (acrId)<-[acrIdToOsr:CONTAINS_FINGERPRINT]-(osr:OrchardSoundRecording)
                            ON CREATE SET
                                osr.id = apoc.create.uuid(),
                                osr.createdAt = datetime(),
                                osr.createdBy = by,
                                osr.lastModifiedAt = datetime(),
                                osr.lastModifiedBy = by,
                                acrIdToOsr.createdAt = datetime(),
                                acrIdToOsr.createdBy = by,
                                acrIdToOsr.lastModifiedAt = datetime(),
                                acrIdToOsr.lastModifiedBy = by
                        WITH *
                        UNWIND row.assets AS source_asset
                        MERGE (asset:OrchardAsset {
                            filename: source_asset.filename,
                            extension: "mp3",
                            source: "direct-delivery-db"
                        })
                            ON CREATE SET
                                asset.id = apoc.create.uuid(),
                                asset.createdAt = datetime(),
                                asset.createdBy = by,
                                asset.lastModifiedAt = datetime(),
                                asset.lastModifiedBy = by
                        MERGE (asset)-[assetToAcrId:FINGERPRINTED_AS]->(acrId)
                            ON CREATE SET
                                assetToAcrId.createdAt = datetime(),
                                assetToAcrId.createdBy = by
                            SET
                                assetToAcrId.lastModifiedAt = datetime(),
                                assetToAcrId.lastModifiedBy = by
                        WITH *
                        OPTIONAL MATCH (asset)-[assetToOldAcrId:FINGERPRINTED_AS]->(oldAcrId:ACRID)
                            WHERE oldAcrId <> acrId
                        FOREACH (hasOldAcrId IN CASE WHEN oldAcrId IS NOT NULL THEN [1] ELSE [] END |
                            CREATE (asset)-[deletedRelationship:DELETED_FINGERPRINTED_AS]->(oldAcrId)
                            SET
                                deletedRelationship += assetToOldAcrId,
                                deletedRelationship.deletedAt = datetime(),
                                deletedRelationship.deletedBy = by
                            DELETE assetToOldAcrId
                        )
                        WITH DISTINCT source_asset, by, asset
                        OPTIONAL MATCH (track:Track { id: toInteger(source_asset.tuid) })
                        CALL apoc.util.validate(track IS NULL, "Could not find the track %s", [source_asset.tuid])
                        MERGE (track)-[trackHasAsset:HAS_ASSET]->(asset)
                            ON CREATE SET
                                trackHasAsset.createdAt = datetime(),
                                trackHasAsset.createdBy = by,
                                trackHasAsset.lastModifiedAt = datetime(),
                                trackHasAsset.lastModifiedBy = by
                    ',
                    {
                        batchSize: 1000
                    }
                )
                YIELD failedOperations, errorMessages, failedBatches, batch
                CALL apoc.util.validate(failedOperations > 0, "At least one sub-operation failed: %s", [reduce(all_errors = "", error IN keys(errorMessages) | all_errors + ", " + error)])
                CALL apoc.util.validate(failedBatches > 0, "At least one batch failed: %s", [reduce(all_errors = "", error IN keys(batch.errors) | all_errors + ", " + error)])
                RETURN 0
            ]]>
        </query>
        <query>
            CALL apoc.log.info("Finished acr_cloud data ingest part 128 of 169 at %s", [datetime()]);
        </query>

        <query>
            <![CDATA[
                CALL apoc.periodic.iterate(
                     "
                        WITH 'snowflake_orchard' AS url_alias,
                        '
                            SELECT * FROM facts.qa.jsonified_track_mapping ORDER BY ACR_ID ASC LIMIT 100000 OFFSET 12800000
                        '
                        AS sql
                        CALL apoc.load.jdbc(url_alias, sql)
                        YIELD row
                        return apoc.convert.fromJsonMap(row.NODE) AS row;
                    ",
                    '
                        WITH *, "database/distro-4707" AS by
                        MERGE (acrId:ACRID { id: row.acr_id })
                            ON CREATE SET
                                acrId.createdAt = datetime(),
                                acrId.createdBy = by,
                                acrId.lastModifiedAt = datetime(),
                                acrId.lastModifiedBy = by
                        MERGE (acrId)<-[acrIdToOsr:CONTAINS_FINGERPRINT]-(osr:OrchardSoundRecording)
                            ON CREATE SET
                                osr.id = apoc.create.uuid(),
                                osr.createdAt = datetime(),
                                osr.createdBy = by,
                                osr.lastModifiedAt = datetime(),
                                osr.lastModifiedBy = by,
                                acrIdToOsr.createdAt = datetime(),
                                acrIdToOsr.createdBy = by,
                                acrIdToOsr.lastModifiedAt = datetime(),
                                acrIdToOsr.lastModifiedBy = by
                        WITH *
                        UNWIND row.assets AS source_asset
                        MERGE (asset:OrchardAsset {
                            filename: source_asset.filename,
                            extension: "mp3",
                            source: "direct-delivery-db"
                        })
                            ON CREATE SET
                                asset.id = apoc.create.uuid(),
                                asset.createdAt = datetime(),
                                asset.createdBy = by,
                                asset.lastModifiedAt = datetime(),
                                asset.lastModifiedBy = by
                        MERGE (asset)-[assetToAcrId:FINGERPRINTED_AS]->(acrId)
                            ON CREATE SET
                                assetToAcrId.createdAt = datetime(),
                                assetToAcrId.createdBy = by
                            SET
                                assetToAcrId.lastModifiedAt = datetime(),
                                assetToAcrId.lastModifiedBy = by
                        WITH *
                        OPTIONAL MATCH (asset)-[assetToOldAcrId:FINGERPRINTED_AS]->(oldAcrId:ACRID)
                            WHERE oldAcrId <> acrId
                        FOREACH (hasOldAcrId IN CASE WHEN oldAcrId IS NOT NULL THEN [1] ELSE [] END |
                            CREATE (asset)-[deletedRelationship:DELETED_FINGERPRINTED_AS]->(oldAcrId)
                            SET
                                deletedRelationship += assetToOldAcrId,
                                deletedRelationship.deletedAt = datetime(),
                                deletedRelationship.deletedBy = by
                            DELETE assetToOldAcrId
                        )
                        WITH DISTINCT source_asset, by, asset
                        OPTIONAL MATCH (track:Track { id: toInteger(source_asset.tuid) })
                        CALL apoc.util.validate(track IS NULL, "Could not find the track %s", [source_asset.tuid])
                        MERGE (track)-[trackHasAsset:HAS_ASSET]->(asset)
                            ON CREATE SET
                                trackHasAsset.createdAt = datetime(),
                                trackHasAsset.createdBy = by,
                                trackHasAsset.lastModifiedAt = datetime(),
                                trackHasAsset.lastModifiedBy = by
                    ',
                    {
                        batchSize: 1000
                    }
                )
                YIELD failedOperations, errorMessages, failedBatches, batch
                CALL apoc.util.validate(failedOperations > 0, "At least one sub-operation failed: %s", [reduce(all_errors = "", error IN keys(errorMessages) | all_errors + ", " + error)])
                CALL apoc.util.validate(failedBatches > 0, "At least one batch failed: %s", [reduce(all_errors = "", error IN keys(batch.errors) | all_errors + ", " + error)])
                RETURN 0
            ]]>
        </query>
        <query>
            CALL apoc.log.info("Finished acr_cloud data ingest part 129 of 169 at %s", [datetime()]);
        </query>

        <query>
            <![CDATA[
                CALL apoc.periodic.iterate(
                     "
                        WITH 'snowflake_orchard' AS url_alias,
                        '
                            SELECT * FROM facts.qa.jsonified_track_mapping ORDER BY ACR_ID ASC LIMIT 100000 OFFSET 12900000
                        '
                        AS sql
                        CALL apoc.load.jdbc(url_alias, sql)
                        YIELD row
                        return apoc.convert.fromJsonMap(row.NODE) AS row;
                    ",
                    '
                        WITH *, "database/distro-4707" AS by
                        MERGE (acrId:ACRID { id: row.acr_id })
                            ON CREATE SET
                                acrId.createdAt = datetime(),
                                acrId.createdBy = by,
                                acrId.lastModifiedAt = datetime(),
                                acrId.lastModifiedBy = by
                        MERGE (acrId)<-[acrIdToOsr:CONTAINS_FINGERPRINT]-(osr:OrchardSoundRecording)
                            ON CREATE SET
                                osr.id = apoc.create.uuid(),
                                osr.createdAt = datetime(),
                                osr.createdBy = by,
                                osr.lastModifiedAt = datetime(),
                                osr.lastModifiedBy = by,
                                acrIdToOsr.createdAt = datetime(),
                                acrIdToOsr.createdBy = by,
                                acrIdToOsr.lastModifiedAt = datetime(),
                                acrIdToOsr.lastModifiedBy = by
                        WITH *
                        UNWIND row.assets AS source_asset
                        MERGE (asset:OrchardAsset {
                            filename: source_asset.filename,
                            extension: "mp3",
                            source: "direct-delivery-db"
                        })
                            ON CREATE SET
                                asset.id = apoc.create.uuid(),
                                asset.createdAt = datetime(),
                                asset.createdBy = by,
                                asset.lastModifiedAt = datetime(),
                                asset.lastModifiedBy = by
                        MERGE (asset)-[assetToAcrId:FINGERPRINTED_AS]->(acrId)
                            ON CREATE SET
                                assetToAcrId.createdAt = datetime(),
                                assetToAcrId.createdBy = by
                            SET
                                assetToAcrId.lastModifiedAt = datetime(),
                                assetToAcrId.lastModifiedBy = by
                        WITH *
                        OPTIONAL MATCH (asset)-[assetToOldAcrId:FINGERPRINTED_AS]->(oldAcrId:ACRID)
                            WHERE oldAcrId <> acrId
                        FOREACH (hasOldAcrId IN CASE WHEN oldAcrId IS NOT NULL THEN [1] ELSE [] END |
                            CREATE (asset)-[deletedRelationship:DELETED_FINGERPRINTED_AS]->(oldAcrId)
                            SET
                                deletedRelationship += assetToOldAcrId,
                                deletedRelationship.deletedAt = datetime(),
                                deletedRelationship.deletedBy = by
                            DELETE assetToOldAcrId
                        )
                        WITH DISTINCT source_asset, by, asset
                        OPTIONAL MATCH (track:Track { id: toInteger(source_asset.tuid) })
                        CALL apoc.util.validate(track IS NULL, "Could not find the track %s", [source_asset.tuid])
                        MERGE (track)-[trackHasAsset:HAS_ASSET]->(asset)
                            ON CREATE SET
                                trackHasAsset.createdAt = datetime(),
                                trackHasAsset.createdBy = by,
                                trackHasAsset.lastModifiedAt = datetime(),
                                trackHasAsset.lastModifiedBy = by
                    ',
                    {
                        batchSize: 1000
                    }
                )
                YIELD failedOperations, errorMessages, failedBatches, batch
                CALL apoc.util.validate(failedOperations > 0, "At least one sub-operation failed: %s", [reduce(all_errors = "", error IN keys(errorMessages) | all_errors + ", " + error)])
                CALL apoc.util.validate(failedBatches > 0, "At least one batch failed: %s", [reduce(all_errors = "", error IN keys(batch.errors) | all_errors + ", " + error)])
                RETURN 0
            ]]>
        </query>
        <query>
            CALL apoc.log.info("Finished acr_cloud data ingest part 130 of 169 at %s", [datetime()]);
        </query>

        <query>
            <![CDATA[
                CALL apoc.periodic.iterate(
                     "
                        WITH 'snowflake_orchard' AS url_alias,
                        '
                            SELECT * FROM facts.qa.jsonified_track_mapping ORDER BY ACR_ID ASC LIMIT 100000 OFFSET 13000000
                        '
                        AS sql
                        CALL apoc.load.jdbc(url_alias, sql)
                        YIELD row
                        return apoc.convert.fromJsonMap(row.NODE) AS row;
                    ",
                    '
                        WITH *, "database/distro-4707" AS by
                        MERGE (acrId:ACRID { id: row.acr_id })
                            ON CREATE SET
                                acrId.createdAt = datetime(),
                                acrId.createdBy = by,
                                acrId.lastModifiedAt = datetime(),
                                acrId.lastModifiedBy = by
                        MERGE (acrId)<-[acrIdToOsr:CONTAINS_FINGERPRINT]-(osr:OrchardSoundRecording)
                            ON CREATE SET
                                osr.id = apoc.create.uuid(),
                                osr.createdAt = datetime(),
                                osr.createdBy = by,
                                osr.lastModifiedAt = datetime(),
                                osr.lastModifiedBy = by,
                                acrIdToOsr.createdAt = datetime(),
                                acrIdToOsr.createdBy = by,
                                acrIdToOsr.lastModifiedAt = datetime(),
                                acrIdToOsr.lastModifiedBy = by
                        WITH *
                        UNWIND row.assets AS source_asset
                        MERGE (asset:OrchardAsset {
                            filename: source_asset.filename,
                            extension: "mp3",
                            source: "direct-delivery-db"
                        })
                            ON CREATE SET
                                asset.id = apoc.create.uuid(),
                                asset.createdAt = datetime(),
                                asset.createdBy = by,
                                asset.lastModifiedAt = datetime(),
                                asset.lastModifiedBy = by
                        MERGE (asset)-[assetToAcrId:FINGERPRINTED_AS]->(acrId)
                            ON CREATE SET
                                assetToAcrId.createdAt = datetime(),
                                assetToAcrId.createdBy = by
                            SET
                                assetToAcrId.lastModifiedAt = datetime(),
                                assetToAcrId.lastModifiedBy = by
                        WITH *
                        OPTIONAL MATCH (asset)-[assetToOldAcrId:FINGERPRINTED_AS]->(oldAcrId:ACRID)
                            WHERE oldAcrId <> acrId
                        FOREACH (hasOldAcrId IN CASE WHEN oldAcrId IS NOT NULL THEN [1] ELSE [] END |
                            CREATE (asset)-[deletedRelationship:DELETED_FINGERPRINTED_AS]->(oldAcrId)
                            SET
                                deletedRelationship += assetToOldAcrId,
                                deletedRelationship.deletedAt = datetime(),
                                deletedRelationship.deletedBy = by
                            DELETE assetToOldAcrId
                        )
                        WITH DISTINCT source_asset, by, asset
                        OPTIONAL MATCH (track:Track { id: toInteger(source_asset.tuid) })
                        CALL apoc.util.validate(track IS NULL, "Could not find the track %s", [source_asset.tuid])
                        MERGE (track)-[trackHasAsset:HAS_ASSET]->(asset)
                            ON CREATE SET
                                trackHasAsset.createdAt = datetime(),
                                trackHasAsset.createdBy = by,
                                trackHasAsset.lastModifiedAt = datetime(),
                                trackHasAsset.lastModifiedBy = by
                    ',
                    {
                        batchSize: 1000
                    }
                )
                YIELD failedOperations, errorMessages, failedBatches, batch
                CALL apoc.util.validate(failedOperations > 0, "At least one sub-operation failed: %s", [reduce(all_errors = "", error IN keys(errorMessages) | all_errors + ", " + error)])
                CALL apoc.util.validate(failedBatches > 0, "At least one batch failed: %s", [reduce(all_errors = "", error IN keys(batch.errors) | all_errors + ", " + error)])
                RETURN 0
            ]]>
        </query>
        <query>
            CALL apoc.log.info("Finished acr_cloud data ingest part 131 of 169 at %s", [datetime()]);
        </query>

        <query>
            <![CDATA[
                CALL apoc.periodic.iterate(
                     "
                        WITH 'snowflake_orchard' AS url_alias,
                        '
                            SELECT * FROM facts.qa.jsonified_track_mapping ORDER BY ACR_ID ASC LIMIT 100000 OFFSET 13100000
                        '
                        AS sql
                        CALL apoc.load.jdbc(url_alias, sql)
                        YIELD row
                        return apoc.convert.fromJsonMap(row.NODE) AS row;
                    ",
                    '
                        WITH *, "database/distro-4707" AS by
                        MERGE (acrId:ACRID { id: row.acr_id })
                            ON CREATE SET
                                acrId.createdAt = datetime(),
                                acrId.createdBy = by,
                                acrId.lastModifiedAt = datetime(),
                                acrId.lastModifiedBy = by
                        MERGE (acrId)<-[acrIdToOsr:CONTAINS_FINGERPRINT]-(osr:OrchardSoundRecording)
                            ON CREATE SET
                                osr.id = apoc.create.uuid(),
                                osr.createdAt = datetime(),
                                osr.createdBy = by,
                                osr.lastModifiedAt = datetime(),
                                osr.lastModifiedBy = by,
                                acrIdToOsr.createdAt = datetime(),
                                acrIdToOsr.createdBy = by,
                                acrIdToOsr.lastModifiedAt = datetime(),
                                acrIdToOsr.lastModifiedBy = by
                        WITH *
                        UNWIND row.assets AS source_asset
                        MERGE (asset:OrchardAsset {
                            filename: source_asset.filename,
                            extension: "mp3",
                            source: "direct-delivery-db"
                        })
                            ON CREATE SET
                                asset.id = apoc.create.uuid(),
                                asset.createdAt = datetime(),
                                asset.createdBy = by,
                                asset.lastModifiedAt = datetime(),
                                asset.lastModifiedBy = by
                        MERGE (asset)-[assetToAcrId:FINGERPRINTED_AS]->(acrId)
                            ON CREATE SET
                                assetToAcrId.createdAt = datetime(),
                                assetToAcrId.createdBy = by
                            SET
                                assetToAcrId.lastModifiedAt = datetime(),
                                assetToAcrId.lastModifiedBy = by
                        WITH *
                        OPTIONAL MATCH (asset)-[assetToOldAcrId:FINGERPRINTED_AS]->(oldAcrId:ACRID)
                            WHERE oldAcrId <> acrId
                        FOREACH (hasOldAcrId IN CASE WHEN oldAcrId IS NOT NULL THEN [1] ELSE [] END |
                            CREATE (asset)-[deletedRelationship:DELETED_FINGERPRINTED_AS]->(oldAcrId)
                            SET
                                deletedRelationship += assetToOldAcrId,
                                deletedRelationship.deletedAt = datetime(),
                                deletedRelationship.deletedBy = by
                            DELETE assetToOldAcrId
                        )
                        WITH DISTINCT source_asset, by, asset
                        OPTIONAL MATCH (track:Track { id: toInteger(source_asset.tuid) })
                        CALL apoc.util.validate(track IS NULL, "Could not find the track %s", [source_asset.tuid])
                        MERGE (track)-[trackHasAsset:HAS_ASSET]->(asset)
                            ON CREATE SET
                                trackHasAsset.createdAt = datetime(),
                                trackHasAsset.createdBy = by,
                                trackHasAsset.lastModifiedAt = datetime(),
                                trackHasAsset.lastModifiedBy = by
                    ',
                    {
                        batchSize: 1000
                    }
                )
                YIELD failedOperations, errorMessages, failedBatches, batch
                CALL apoc.util.validate(failedOperations > 0, "At least one sub-operation failed: %s", [reduce(all_errors = "", error IN keys(errorMessages) | all_errors + ", " + error)])
                CALL apoc.util.validate(failedBatches > 0, "At least one batch failed: %s", [reduce(all_errors = "", error IN keys(batch.errors) | all_errors + ", " + error)])
                RETURN 0
            ]]>
        </query>
        <query>
            CALL apoc.log.info("Finished acr_cloud data ingest part 132 of 169 at %s", [datetime()]);
        </query>

        <query>
            <![CDATA[
                CALL apoc.periodic.iterate(
                     "
                        WITH 'snowflake_orchard' AS url_alias,
                        '
                            SELECT * FROM facts.qa.jsonified_track_mapping ORDER BY ACR_ID ASC LIMIT 100000 OFFSET 13200000
                        '
                        AS sql
                        CALL apoc.load.jdbc(url_alias, sql)
                        YIELD row
                        return apoc.convert.fromJsonMap(row.NODE) AS row;
                    ",
                    '
                        WITH *, "database/distro-4707" AS by
                        MERGE (acrId:ACRID { id: row.acr_id })
                            ON CREATE SET
                                acrId.createdAt = datetime(),
                                acrId.createdBy = by,
                                acrId.lastModifiedAt = datetime(),
                                acrId.lastModifiedBy = by
                        MERGE (acrId)<-[acrIdToOsr:CONTAINS_FINGERPRINT]-(osr:OrchardSoundRecording)
                            ON CREATE SET
                                osr.id = apoc.create.uuid(),
                                osr.createdAt = datetime(),
                                osr.createdBy = by,
                                osr.lastModifiedAt = datetime(),
                                osr.lastModifiedBy = by,
                                acrIdToOsr.createdAt = datetime(),
                                acrIdToOsr.createdBy = by,
                                acrIdToOsr.lastModifiedAt = datetime(),
                                acrIdToOsr.lastModifiedBy = by
                        WITH *
                        UNWIND row.assets AS source_asset
                        MERGE (asset:OrchardAsset {
                            filename: source_asset.filename,
                            extension: "mp3",
                            source: "direct-delivery-db"
                        })
                            ON CREATE SET
                                asset.id = apoc.create.uuid(),
                                asset.createdAt = datetime(),
                                asset.createdBy = by,
                                asset.lastModifiedAt = datetime(),
                                asset.lastModifiedBy = by
                        MERGE (asset)-[assetToAcrId:FINGERPRINTED_AS]->(acrId)
                            ON CREATE SET
                                assetToAcrId.createdAt = datetime(),
                                assetToAcrId.createdBy = by
                            SET
                                assetToAcrId.lastModifiedAt = datetime(),
                                assetToAcrId.lastModifiedBy = by
                        WITH *
                        OPTIONAL MATCH (asset)-[assetToOldAcrId:FINGERPRINTED_AS]->(oldAcrId:ACRID)
                            WHERE oldAcrId <> acrId
                        FOREACH (hasOldAcrId IN CASE WHEN oldAcrId IS NOT NULL THEN [1] ELSE [] END |
                            CREATE (asset)-[deletedRelationship:DELETED_FINGERPRINTED_AS]->(oldAcrId)
                            SET
                                deletedRelationship += assetToOldAcrId,
                                deletedRelationship.deletedAt = datetime(),
                                deletedRelationship.deletedBy = by
                            DELETE assetToOldAcrId
                        )
                        WITH DISTINCT source_asset, by, asset
                        OPTIONAL MATCH (track:Track { id: toInteger(source_asset.tuid) })
                        CALL apoc.util.validate(track IS NULL, "Could not find the track %s", [source_asset.tuid])
                        MERGE (track)-[trackHasAsset:HAS_ASSET]->(asset)
                            ON CREATE SET
                                trackHasAsset.createdAt = datetime(),
                                trackHasAsset.createdBy = by,
                                trackHasAsset.lastModifiedAt = datetime(),
                                trackHasAsset.lastModifiedBy = by
                    ',
                    {
                        batchSize: 1000
                    }
                )
                YIELD failedOperations, errorMessages, failedBatches, batch
                CALL apoc.util.validate(failedOperations > 0, "At least one sub-operation failed: %s", [reduce(all_errors = "", error IN keys(errorMessages) | all_errors + ", " + error)])
                CALL apoc.util.validate(failedBatches > 0, "At least one batch failed: %s", [reduce(all_errors = "", error IN keys(batch.errors) | all_errors + ", " + error)])
                RETURN 0
            ]]>
        </query>
        <query>
            CALL apoc.log.info("Finished acr_cloud data ingest part 133 of 169 at %s", [datetime()]);
        </query>

        <query>
            <![CDATA[
                CALL apoc.periodic.iterate(
                     "
                        WITH 'snowflake_orchard' AS url_alias,
                        '
                            SELECT * FROM facts.qa.jsonified_track_mapping ORDER BY ACR_ID ASC LIMIT 100000 OFFSET 13300000
                        '
                        AS sql
                        CALL apoc.load.jdbc(url_alias, sql)
                        YIELD row
                        return apoc.convert.fromJsonMap(row.NODE) AS row;
                    ",
                    '
                        WITH *, "database/distro-4707" AS by
                        MERGE (acrId:ACRID { id: row.acr_id })
                            ON CREATE SET
                                acrId.createdAt = datetime(),
                                acrId.createdBy = by,
                                acrId.lastModifiedAt = datetime(),
                                acrId.lastModifiedBy = by
                        MERGE (acrId)<-[acrIdToOsr:CONTAINS_FINGERPRINT]-(osr:OrchardSoundRecording)
                            ON CREATE SET
                                osr.id = apoc.create.uuid(),
                                osr.createdAt = datetime(),
                                osr.createdBy = by,
                                osr.lastModifiedAt = datetime(),
                                osr.lastModifiedBy = by,
                                acrIdToOsr.createdAt = datetime(),
                                acrIdToOsr.createdBy = by,
                                acrIdToOsr.lastModifiedAt = datetime(),
                                acrIdToOsr.lastModifiedBy = by
                        WITH *
                        UNWIND row.assets AS source_asset
                        MERGE (asset:OrchardAsset {
                            filename: source_asset.filename,
                            extension: "mp3",
                            source: "direct-delivery-db"
                        })
                            ON CREATE SET
                                asset.id = apoc.create.uuid(),
                                asset.createdAt = datetime(),
                                asset.createdBy = by,
                                asset.lastModifiedAt = datetime(),
                                asset.lastModifiedBy = by
                        MERGE (asset)-[assetToAcrId:FINGERPRINTED_AS]->(acrId)
                            ON CREATE SET
                                assetToAcrId.createdAt = datetime(),
                                assetToAcrId.createdBy = by
                            SET
                                assetToAcrId.lastModifiedAt = datetime(),
                                assetToAcrId.lastModifiedBy = by
                        WITH *
                        OPTIONAL MATCH (asset)-[assetToOldAcrId:FINGERPRINTED_AS]->(oldAcrId:ACRID)
                            WHERE oldAcrId <> acrId
                        FOREACH (hasOldAcrId IN CASE WHEN oldAcrId IS NOT NULL THEN [1] ELSE [] END |
                            CREATE (asset)-[deletedRelationship:DELETED_FINGERPRINTED_AS]->(oldAcrId)
                            SET
                                deletedRelationship += assetToOldAcrId,
                                deletedRelationship.deletedAt = datetime(),
                                deletedRelationship.deletedBy = by
                            DELETE assetToOldAcrId
                        )
                        WITH DISTINCT source_asset, by, asset
                        OPTIONAL MATCH (track:Track { id: toInteger(source_asset.tuid) })
                        CALL apoc.util.validate(track IS NULL, "Could not find the track %s", [source_asset.tuid])
                        MERGE (track)-[trackHasAsset:HAS_ASSET]->(asset)
                            ON CREATE SET
                                trackHasAsset.createdAt = datetime(),
                                trackHasAsset.createdBy = by,
                                trackHasAsset.lastModifiedAt = datetime(),
                                trackHasAsset.lastModifiedBy = by
                    ',
                    {
                        batchSize: 1000
                    }
                )
                YIELD failedOperations, errorMessages, failedBatches, batch
                CALL apoc.util.validate(failedOperations > 0, "At least one sub-operation failed: %s", [reduce(all_errors = "", error IN keys(errorMessages) | all_errors + ", " + error)])
                CALL apoc.util.validate(failedBatches > 0, "At least one batch failed: %s", [reduce(all_errors = "", error IN keys(batch.errors) | all_errors + ", " + error)])
                RETURN 0
            ]]>
        </query>
        <query>
            CALL apoc.log.info("Finished acr_cloud data ingest part 134 of 169 at %s", [datetime()]);
        </query>

        <query>
            <![CDATA[
                CALL apoc.periodic.iterate(
                     "
                        WITH 'snowflake_orchard' AS url_alias,
                        '
                            SELECT * FROM facts.qa.jsonified_track_mapping ORDER BY ACR_ID ASC LIMIT 100000 OFFSET 13400000
                        '
                        AS sql
                        CALL apoc.load.jdbc(url_alias, sql)
                        YIELD row
                        return apoc.convert.fromJsonMap(row.NODE) AS row;
                    ",
                    '
                        WITH *, "database/distro-4707" AS by
                        MERGE (acrId:ACRID { id: row.acr_id })
                            ON CREATE SET
                                acrId.createdAt = datetime(),
                                acrId.createdBy = by,
                                acrId.lastModifiedAt = datetime(),
                                acrId.lastModifiedBy = by
                        MERGE (acrId)<-[acrIdToOsr:CONTAINS_FINGERPRINT]-(osr:OrchardSoundRecording)
                            ON CREATE SET
                                osr.id = apoc.create.uuid(),
                                osr.createdAt = datetime(),
                                osr.createdBy = by,
                                osr.lastModifiedAt = datetime(),
                                osr.lastModifiedBy = by,
                                acrIdToOsr.createdAt = datetime(),
                                acrIdToOsr.createdBy = by,
                                acrIdToOsr.lastModifiedAt = datetime(),
                                acrIdToOsr.lastModifiedBy = by
                        WITH *
                        UNWIND row.assets AS source_asset
                        MERGE (asset:OrchardAsset {
                            filename: source_asset.filename,
                            extension: "mp3",
                            source: "direct-delivery-db"
                        })
                            ON CREATE SET
                                asset.id = apoc.create.uuid(),
                                asset.createdAt = datetime(),
                                asset.createdBy = by,
                                asset.lastModifiedAt = datetime(),
                                asset.lastModifiedBy = by
                        MERGE (asset)-[assetToAcrId:FINGERPRINTED_AS]->(acrId)
                            ON CREATE SET
                                assetToAcrId.createdAt = datetime(),
                                assetToAcrId.createdBy = by
                            SET
                                assetToAcrId.lastModifiedAt = datetime(),
                                assetToAcrId.lastModifiedBy = by
                        WITH *
                        OPTIONAL MATCH (asset)-[assetToOldAcrId:FINGERPRINTED_AS]->(oldAcrId:ACRID)
                            WHERE oldAcrId <> acrId
                        FOREACH (hasOldAcrId IN CASE WHEN oldAcrId IS NOT NULL THEN [1] ELSE [] END |
                            CREATE (asset)-[deletedRelationship:DELETED_FINGERPRINTED_AS]->(oldAcrId)
                            SET
                                deletedRelationship += assetToOldAcrId,
                                deletedRelationship.deletedAt = datetime(),
                                deletedRelationship.deletedBy = by
                            DELETE assetToOldAcrId
                        )
                        WITH DISTINCT source_asset, by, asset
                        OPTIONAL MATCH (track:Track { id: toInteger(source_asset.tuid) })
                        CALL apoc.util.validate(track IS NULL, "Could not find the track %s", [source_asset.tuid])
                        MERGE (track)-[trackHasAsset:HAS_ASSET]->(asset)
                            ON CREATE SET
                                trackHasAsset.createdAt = datetime(),
                                trackHasAsset.createdBy = by,
                                trackHasAsset.lastModifiedAt = datetime(),
                                trackHasAsset.lastModifiedBy = by
                    ',
                    {
                        batchSize: 1000
                    }
                )
                YIELD failedOperations, errorMessages, failedBatches, batch
                CALL apoc.util.validate(failedOperations > 0, "At least one sub-operation failed: %s", [reduce(all_errors = "", error IN keys(errorMessages) | all_errors + ", " + error)])
                CALL apoc.util.validate(failedBatches > 0, "At least one batch failed: %s", [reduce(all_errors = "", error IN keys(batch.errors) | all_errors + ", " + error)])
                RETURN 0
            ]]>
        </query>
        <query>
            CALL apoc.log.info("Finished acr_cloud data ingest part 135 of 169 at %s", [datetime()]);
        </query>

        <query>
            <![CDATA[
                CALL apoc.periodic.iterate(
                     "
                        WITH 'snowflake_orchard' AS url_alias,
                        '
                            SELECT * FROM facts.qa.jsonified_track_mapping ORDER BY ACR_ID ASC LIMIT 100000 OFFSET 13500000
                        '
                        AS sql
                        CALL apoc.load.jdbc(url_alias, sql)
                        YIELD row
                        return apoc.convert.fromJsonMap(row.NODE) AS row;
                    ",
                    '
                        WITH *, "database/distro-4707" AS by
                        MERGE (acrId:ACRID { id: row.acr_id })
                            ON CREATE SET
                                acrId.createdAt = datetime(),
                                acrId.createdBy = by,
                                acrId.lastModifiedAt = datetime(),
                                acrId.lastModifiedBy = by
                        MERGE (acrId)<-[acrIdToOsr:CONTAINS_FINGERPRINT]-(osr:OrchardSoundRecording)
                            ON CREATE SET
                                osr.id = apoc.create.uuid(),
                                osr.createdAt = datetime(),
                                osr.createdBy = by,
                                osr.lastModifiedAt = datetime(),
                                osr.lastModifiedBy = by,
                                acrIdToOsr.createdAt = datetime(),
                                acrIdToOsr.createdBy = by,
                                acrIdToOsr.lastModifiedAt = datetime(),
                                acrIdToOsr.lastModifiedBy = by
                        WITH *
                        UNWIND row.assets AS source_asset
                        MERGE (asset:OrchardAsset {
                            filename: source_asset.filename,
                            extension: "mp3",
                            source: "direct-delivery-db"
                        })
                            ON CREATE SET
                                asset.id = apoc.create.uuid(),
                                asset.createdAt = datetime(),
                                asset.createdBy = by,
                                asset.lastModifiedAt = datetime(),
                                asset.lastModifiedBy = by
                        MERGE (asset)-[assetToAcrId:FINGERPRINTED_AS]->(acrId)
                            ON CREATE SET
                                assetToAcrId.createdAt = datetime(),
                                assetToAcrId.createdBy = by
                            SET
                                assetToAcrId.lastModifiedAt = datetime(),
                                assetToAcrId.lastModifiedBy = by
                        WITH *
                        OPTIONAL MATCH (asset)-[assetToOldAcrId:FINGERPRINTED_AS]->(oldAcrId:ACRID)
                            WHERE oldAcrId <> acrId
                        FOREACH (hasOldAcrId IN CASE WHEN oldAcrId IS NOT NULL THEN [1] ELSE [] END |
                            CREATE (asset)-[deletedRelationship:DELETED_FINGERPRINTED_AS]->(oldAcrId)
                            SET
                                deletedRelationship += assetToOldAcrId,
                                deletedRelationship.deletedAt = datetime(),
                                deletedRelationship.deletedBy = by
                            DELETE assetToOldAcrId
                        )
                        WITH DISTINCT source_asset, by, asset
                        OPTIONAL MATCH (track:Track { id: toInteger(source_asset.tuid) })
                        CALL apoc.util.validate(track IS NULL, "Could not find the track %s", [source_asset.tuid])
                        MERGE (track)-[trackHasAsset:HAS_ASSET]->(asset)
                            ON CREATE SET
                                trackHasAsset.createdAt = datetime(),
                                trackHasAsset.createdBy = by,
                                trackHasAsset.lastModifiedAt = datetime(),
                                trackHasAsset.lastModifiedBy = by
                    ',
                    {
                        batchSize: 1000
                    }
                )
                YIELD failedOperations, errorMessages, failedBatches, batch
                CALL apoc.util.validate(failedOperations > 0, "At least one sub-operation failed: %s", [reduce(all_errors = "", error IN keys(errorMessages) | all_errors + ", " + error)])
                CALL apoc.util.validate(failedBatches > 0, "At least one batch failed: %s", [reduce(all_errors = "", error IN keys(batch.errors) | all_errors + ", " + error)])
                RETURN 0
            ]]>
        </query>
        <query>
            CALL apoc.log.info("Finished acr_cloud data ingest part 136 of 169 at %s", [datetime()]);
        </query>

        <query>
            <![CDATA[
                CALL apoc.periodic.iterate(
                     "
                        WITH 'snowflake_orchard' AS url_alias,
                        '
                            SELECT * FROM facts.qa.jsonified_track_mapping ORDER BY ACR_ID ASC LIMIT 100000 OFFSET 13600000
                        '
                        AS sql
                        CALL apoc.load.jdbc(url_alias, sql)
                        YIELD row
                        return apoc.convert.fromJsonMap(row.NODE) AS row;
                    ",
                    '
                        WITH *, "database/distro-4707" AS by
                        MERGE (acrId:ACRID { id: row.acr_id })
                            ON CREATE SET
                                acrId.createdAt = datetime(),
                                acrId.createdBy = by,
                                acrId.lastModifiedAt = datetime(),
                                acrId.lastModifiedBy = by
                        MERGE (acrId)<-[acrIdToOsr:CONTAINS_FINGERPRINT]-(osr:OrchardSoundRecording)
                            ON CREATE SET
                                osr.id = apoc.create.uuid(),
                                osr.createdAt = datetime(),
                                osr.createdBy = by,
                                osr.lastModifiedAt = datetime(),
                                osr.lastModifiedBy = by,
                                acrIdToOsr.createdAt = datetime(),
                                acrIdToOsr.createdBy = by,
                                acrIdToOsr.lastModifiedAt = datetime(),
                                acrIdToOsr.lastModifiedBy = by
                        WITH *
                        UNWIND row.assets AS source_asset
                        MERGE (asset:OrchardAsset {
                            filename: source_asset.filename,
                            extension: "mp3",
                            source: "direct-delivery-db"
                        })
                            ON CREATE SET
                                asset.id = apoc.create.uuid(),
                                asset.createdAt = datetime(),
                                asset.createdBy = by,
                                asset.lastModifiedAt = datetime(),
                                asset.lastModifiedBy = by
                        MERGE (asset)-[assetToAcrId:FINGERPRINTED_AS]->(acrId)
                            ON CREATE SET
                                assetToAcrId.createdAt = datetime(),
                                assetToAcrId.createdBy = by
                            SET
                                assetToAcrId.lastModifiedAt = datetime(),
                                assetToAcrId.lastModifiedBy = by
                        WITH *
                        OPTIONAL MATCH (asset)-[assetToOldAcrId:FINGERPRINTED_AS]->(oldAcrId:ACRID)
                            WHERE oldAcrId <> acrId
                        FOREACH (hasOldAcrId IN CASE WHEN oldAcrId IS NOT NULL THEN [1] ELSE [] END |
                            CREATE (asset)-[deletedRelationship:DELETED_FINGERPRINTED_AS]->(oldAcrId)
                            SET
                                deletedRelationship += assetToOldAcrId,
                                deletedRelationship.deletedAt = datetime(),
                                deletedRelationship.deletedBy = by
                            DELETE assetToOldAcrId
                        )
                        WITH DISTINCT source_asset, by, asset
                        OPTIONAL MATCH (track:Track { id: toInteger(source_asset.tuid) })
                        CALL apoc.util.validate(track IS NULL, "Could not find the track %s", [source_asset.tuid])
                        MERGE (track)-[trackHasAsset:HAS_ASSET]->(asset)
                            ON CREATE SET
                                trackHasAsset.createdAt = datetime(),
                                trackHasAsset.createdBy = by,
                                trackHasAsset.lastModifiedAt = datetime(),
                                trackHasAsset.lastModifiedBy = by
                    ',
                    {
                        batchSize: 1000
                    }
                )
                YIELD failedOperations, errorMessages, failedBatches, batch
                CALL apoc.util.validate(failedOperations > 0, "At least one sub-operation failed: %s", [reduce(all_errors = "", error IN keys(errorMessages) | all_errors + ", " + error)])
                CALL apoc.util.validate(failedBatches > 0, "At least one batch failed: %s", [reduce(all_errors = "", error IN keys(batch.errors) | all_errors + ", " + error)])
                RETURN 0
            ]]>
        </query>
        <query>
            CALL apoc.log.info("Finished acr_cloud data ingest part 137 of 169 at %s", [datetime()]);
        </query>

        <query>
            <![CDATA[
                CALL apoc.periodic.iterate(
                     "
                        WITH 'snowflake_orchard' AS url_alias,
                        '
                            SELECT * FROM facts.qa.jsonified_track_mapping ORDER BY ACR_ID ASC LIMIT 100000 OFFSET 13700000
                        '
                        AS sql
                        CALL apoc.load.jdbc(url_alias, sql)
                        YIELD row
                        return apoc.convert.fromJsonMap(row.NODE) AS row;
                    ",
                    '
                        WITH *, "database/distro-4707" AS by
                        MERGE (acrId:ACRID { id: row.acr_id })
                            ON CREATE SET
                                acrId.createdAt = datetime(),
                                acrId.createdBy = by,
                                acrId.lastModifiedAt = datetime(),
                                acrId.lastModifiedBy = by
                        MERGE (acrId)<-[acrIdToOsr:CONTAINS_FINGERPRINT]-(osr:OrchardSoundRecording)
                            ON CREATE SET
                                osr.id = apoc.create.uuid(),
                                osr.createdAt = datetime(),
                                osr.createdBy = by,
                                osr.lastModifiedAt = datetime(),
                                osr.lastModifiedBy = by,
                                acrIdToOsr.createdAt = datetime(),
                                acrIdToOsr.createdBy = by,
                                acrIdToOsr.lastModifiedAt = datetime(),
                                acrIdToOsr.lastModifiedBy = by
                        WITH *
                        UNWIND row.assets AS source_asset
                        MERGE (asset:OrchardAsset {
                            filename: source_asset.filename,
                            extension: "mp3",
                            source: "direct-delivery-db"
                        })
                            ON CREATE SET
                                asset.id = apoc.create.uuid(),
                                asset.createdAt = datetime(),
                                asset.createdBy = by,
                                asset.lastModifiedAt = datetime(),
                                asset.lastModifiedBy = by
                        MERGE (asset)-[assetToAcrId:FINGERPRINTED_AS]->(acrId)
                            ON CREATE SET
                                assetToAcrId.createdAt = datetime(),
                                assetToAcrId.createdBy = by
                            SET
                                assetToAcrId.lastModifiedAt = datetime(),
                                assetToAcrId.lastModifiedBy = by
                        WITH *
                        OPTIONAL MATCH (asset)-[assetToOldAcrId:FINGERPRINTED_AS]->(oldAcrId:ACRID)
                            WHERE oldAcrId <> acrId
                        FOREACH (hasOldAcrId IN CASE WHEN oldAcrId IS NOT NULL THEN [1] ELSE [] END |
                            CREATE (asset)-[deletedRelationship:DELETED_FINGERPRINTED_AS]->(oldAcrId)
                            SET
                                deletedRelationship += assetToOldAcrId,
                                deletedRelationship.deletedAt = datetime(),
                                deletedRelationship.deletedBy = by
                            DELETE assetToOldAcrId
                        )
                        WITH DISTINCT source_asset, by, asset
                        OPTIONAL MATCH (track:Track { id: toInteger(source_asset.tuid) })
                        CALL apoc.util.validate(track IS NULL, "Could not find the track %s", [source_asset.tuid])
                        MERGE (track)-[trackHasAsset:HAS_ASSET]->(asset)
                            ON CREATE SET
                                trackHasAsset.createdAt = datetime(),
                                trackHasAsset.createdBy = by,
                                trackHasAsset.lastModifiedAt = datetime(),
                                trackHasAsset.lastModifiedBy = by
                    ',
                    {
                        batchSize: 1000
                    }
                )
                YIELD failedOperations, errorMessages, failedBatches, batch
                CALL apoc.util.validate(failedOperations > 0, "At least one sub-operation failed: %s", [reduce(all_errors = "", error IN keys(errorMessages) | all_errors + ", " + error)])
                CALL apoc.util.validate(failedBatches > 0, "At least one batch failed: %s", [reduce(all_errors = "", error IN keys(batch.errors) | all_errors + ", " + error)])
                RETURN 0
            ]]>
        </query>
        <query>
            CALL apoc.log.info("Finished acr_cloud data ingest part 138 of 169 at %s", [datetime()]);
        </query>

        <query>
            <![CDATA[
                CALL apoc.periodic.iterate(
                     "
                        WITH 'snowflake_orchard' AS url_alias,
                        '
                            SELECT * FROM facts.qa.jsonified_track_mapping ORDER BY ACR_ID ASC LIMIT 100000 OFFSET 13800000
                        '
                        AS sql
                        CALL apoc.load.jdbc(url_alias, sql)
                        YIELD row
                        return apoc.convert.fromJsonMap(row.NODE) AS row;
                    ",
                    '
                        WITH *, "database/distro-4707" AS by
                        MERGE (acrId:ACRID { id: row.acr_id })
                            ON CREATE SET
                                acrId.createdAt = datetime(),
                                acrId.createdBy = by,
                                acrId.lastModifiedAt = datetime(),
                                acrId.lastModifiedBy = by
                        MERGE (acrId)<-[acrIdToOsr:CONTAINS_FINGERPRINT]-(osr:OrchardSoundRecording)
                            ON CREATE SET
                                osr.id = apoc.create.uuid(),
                                osr.createdAt = datetime(),
                                osr.createdBy = by,
                                osr.lastModifiedAt = datetime(),
                                osr.lastModifiedBy = by,
                                acrIdToOsr.createdAt = datetime(),
                                acrIdToOsr.createdBy = by,
                                acrIdToOsr.lastModifiedAt = datetime(),
                                acrIdToOsr.lastModifiedBy = by
                        WITH *
                        UNWIND row.assets AS source_asset
                        MERGE (asset:OrchardAsset {
                            filename: source_asset.filename,
                            extension: "mp3",
                            source: "direct-delivery-db"
                        })
                            ON CREATE SET
                                asset.id = apoc.create.uuid(),
                                asset.createdAt = datetime(),
                                asset.createdBy = by,
                                asset.lastModifiedAt = datetime(),
                                asset.lastModifiedBy = by
                        MERGE (asset)-[assetToAcrId:FINGERPRINTED_AS]->(acrId)
                            ON CREATE SET
                                assetToAcrId.createdAt = datetime(),
                                assetToAcrId.createdBy = by
                            SET
                                assetToAcrId.lastModifiedAt = datetime(),
                                assetToAcrId.lastModifiedBy = by
                        WITH *
                        OPTIONAL MATCH (asset)-[assetToOldAcrId:FINGERPRINTED_AS]->(oldAcrId:ACRID)
                            WHERE oldAcrId <> acrId
                        FOREACH (hasOldAcrId IN CASE WHEN oldAcrId IS NOT NULL THEN [1] ELSE [] END |
                            CREATE (asset)-[deletedRelationship:DELETED_FINGERPRINTED_AS]->(oldAcrId)
                            SET
                                deletedRelationship += assetToOldAcrId,
                                deletedRelationship.deletedAt = datetime(),
                                deletedRelationship.deletedBy = by
                            DELETE assetToOldAcrId
                        )
                        WITH DISTINCT source_asset, by, asset
                        OPTIONAL MATCH (track:Track { id: toInteger(source_asset.tuid) })
                        CALL apoc.util.validate(track IS NULL, "Could not find the track %s", [source_asset.tuid])
                        MERGE (track)-[trackHasAsset:HAS_ASSET]->(asset)
                            ON CREATE SET
                                trackHasAsset.createdAt = datetime(),
                                trackHasAsset.createdBy = by,
                                trackHasAsset.lastModifiedAt = datetime(),
                                trackHasAsset.lastModifiedBy = by
                    ',
                    {
                        batchSize: 1000
                    }
                )
                YIELD failedOperations, errorMessages, failedBatches, batch
                CALL apoc.util.validate(failedOperations > 0, "At least one sub-operation failed: %s", [reduce(all_errors = "", error IN keys(errorMessages) | all_errors + ", " + error)])
                CALL apoc.util.validate(failedBatches > 0, "At least one batch failed: %s", [reduce(all_errors = "", error IN keys(batch.errors) | all_errors + ", " + error)])
                RETURN 0
            ]]>
        </query>
        <query>
            CALL apoc.log.info("Finished acr_cloud data ingest part 139 of 169 at %s", [datetime()]);
        </query>

        <query>
            <![CDATA[
                CALL apoc.periodic.iterate(
                     "
                        WITH 'snowflake_orchard' AS url_alias,
                        '
                            SELECT * FROM facts.qa.jsonified_track_mapping ORDER BY ACR_ID ASC LIMIT 100000 OFFSET 13900000
                        '
                        AS sql
                        CALL apoc.load.jdbc(url_alias, sql)
                        YIELD row
                        return apoc.convert.fromJsonMap(row.NODE) AS row;
                    ",
                    '
                        WITH *, "database/distro-4707" AS by
                        MERGE (acrId:ACRID { id: row.acr_id })
                            ON CREATE SET
                                acrId.createdAt = datetime(),
                                acrId.createdBy = by,
                                acrId.lastModifiedAt = datetime(),
                                acrId.lastModifiedBy = by
                        MERGE (acrId)<-[acrIdToOsr:CONTAINS_FINGERPRINT]-(osr:OrchardSoundRecording)
                            ON CREATE SET
                                osr.id = apoc.create.uuid(),
                                osr.createdAt = datetime(),
                                osr.createdBy = by,
                                osr.lastModifiedAt = datetime(),
                                osr.lastModifiedBy = by,
                                acrIdToOsr.createdAt = datetime(),
                                acrIdToOsr.createdBy = by,
                                acrIdToOsr.lastModifiedAt = datetime(),
                                acrIdToOsr.lastModifiedBy = by
                        WITH *
                        UNWIND row.assets AS source_asset
                        MERGE (asset:OrchardAsset {
                            filename: source_asset.filename,
                            extension: "mp3",
                            source: "direct-delivery-db"
                        })
                            ON CREATE SET
                                asset.id = apoc.create.uuid(),
                                asset.createdAt = datetime(),
                                asset.createdBy = by,
                                asset.lastModifiedAt = datetime(),
                                asset.lastModifiedBy = by
                        MERGE (asset)-[assetToAcrId:FINGERPRINTED_AS]->(acrId)
                            ON CREATE SET
                                assetToAcrId.createdAt = datetime(),
                                assetToAcrId.createdBy = by
                            SET
                                assetToAcrId.lastModifiedAt = datetime(),
                                assetToAcrId.lastModifiedBy = by
                        WITH *
                        OPTIONAL MATCH (asset)-[assetToOldAcrId:FINGERPRINTED_AS]->(oldAcrId:ACRID)
                            WHERE oldAcrId <> acrId
                        FOREACH (hasOldAcrId IN CASE WHEN oldAcrId IS NOT NULL THEN [1] ELSE [] END |
                            CREATE (asset)-[deletedRelationship:DELETED_FINGERPRINTED_AS]->(oldAcrId)
                            SET
                                deletedRelationship += assetToOldAcrId,
                                deletedRelationship.deletedAt = datetime(),
                                deletedRelationship.deletedBy = by
                            DELETE assetToOldAcrId
                        )
                        WITH DISTINCT source_asset, by, asset
                        OPTIONAL MATCH (track:Track { id: toInteger(source_asset.tuid) })
                        CALL apoc.util.validate(track IS NULL, "Could not find the track %s", [source_asset.tuid])
                        MERGE (track)-[trackHasAsset:HAS_ASSET]->(asset)
                            ON CREATE SET
                                trackHasAsset.createdAt = datetime(),
                                trackHasAsset.createdBy = by,
                                trackHasAsset.lastModifiedAt = datetime(),
                                trackHasAsset.lastModifiedBy = by
                    ',
                    {
                        batchSize: 1000
                    }
                )
                YIELD failedOperations, errorMessages, failedBatches, batch
                CALL apoc.util.validate(failedOperations > 0, "At least one sub-operation failed: %s", [reduce(all_errors = "", error IN keys(errorMessages) | all_errors + ", " + error)])
                CALL apoc.util.validate(failedBatches > 0, "At least one batch failed: %s", [reduce(all_errors = "", error IN keys(batch.errors) | all_errors + ", " + error)])
                RETURN 0
            ]]>
        </query>
        <query>
            CALL apoc.log.info("Finished acr_cloud data ingest part 140 of 169 at %s", [datetime()]);
        </query>

        <query>
            <![CDATA[
                CALL apoc.periodic.iterate(
                     "
                        WITH 'snowflake_orchard' AS url_alias,
                        '
                            SELECT * FROM facts.qa.jsonified_track_mapping ORDER BY ACR_ID ASC LIMIT 100000 OFFSET 14000000
                        '
                        AS sql
                        CALL apoc.load.jdbc(url_alias, sql)
                        YIELD row
                        return apoc.convert.fromJsonMap(row.NODE) AS row;
                    ",
                    '
                        WITH *, "database/distro-4707" AS by
                        MERGE (acrId:ACRID { id: row.acr_id })
                            ON CREATE SET
                                acrId.createdAt = datetime(),
                                acrId.createdBy = by,
                                acrId.lastModifiedAt = datetime(),
                                acrId.lastModifiedBy = by
                        MERGE (acrId)<-[acrIdToOsr:CONTAINS_FINGERPRINT]-(osr:OrchardSoundRecording)
                            ON CREATE SET
                                osr.id = apoc.create.uuid(),
                                osr.createdAt = datetime(),
                                osr.createdBy = by,
                                osr.lastModifiedAt = datetime(),
                                osr.lastModifiedBy = by,
                                acrIdToOsr.createdAt = datetime(),
                                acrIdToOsr.createdBy = by,
                                acrIdToOsr.lastModifiedAt = datetime(),
                                acrIdToOsr.lastModifiedBy = by
                        WITH *
                        UNWIND row.assets AS source_asset
                        MERGE (asset:OrchardAsset {
                            filename: source_asset.filename,
                            extension: "mp3",
                            source: "direct-delivery-db"
                        })
                            ON CREATE SET
                                asset.id = apoc.create.uuid(),
                                asset.createdAt = datetime(),
                                asset.createdBy = by,
                                asset.lastModifiedAt = datetime(),
                                asset.lastModifiedBy = by
                        MERGE (asset)-[assetToAcrId:FINGERPRINTED_AS]->(acrId)
                            ON CREATE SET
                                assetToAcrId.createdAt = datetime(),
                                assetToAcrId.createdBy = by
                            SET
                                assetToAcrId.lastModifiedAt = datetime(),
                                assetToAcrId.lastModifiedBy = by
                        WITH *
                        OPTIONAL MATCH (asset)-[assetToOldAcrId:FINGERPRINTED_AS]->(oldAcrId:ACRID)
                            WHERE oldAcrId <> acrId
                        FOREACH (hasOldAcrId IN CASE WHEN oldAcrId IS NOT NULL THEN [1] ELSE [] END |
                            CREATE (asset)-[deletedRelationship:DELETED_FINGERPRINTED_AS]->(oldAcrId)
                            SET
                                deletedRelationship += assetToOldAcrId,
                                deletedRelationship.deletedAt = datetime(),
                                deletedRelationship.deletedBy = by
                            DELETE assetToOldAcrId
                        )
                        WITH DISTINCT source_asset, by, asset
                        OPTIONAL MATCH (track:Track { id: toInteger(source_asset.tuid) })
                        CALL apoc.util.validate(track IS NULL, "Could not find the track %s", [source_asset.tuid])
                        MERGE (track)-[trackHasAsset:HAS_ASSET]->(asset)
                            ON CREATE SET
                                trackHasAsset.createdAt = datetime(),
                                trackHasAsset.createdBy = by,
                                trackHasAsset.lastModifiedAt = datetime(),
                                trackHasAsset.lastModifiedBy = by
                    ',
                    {
                        batchSize: 1000
                    }
                )
                YIELD failedOperations, errorMessages, failedBatches, batch
                CALL apoc.util.validate(failedOperations > 0, "At least one sub-operation failed: %s", [reduce(all_errors = "", error IN keys(errorMessages) | all_errors + ", " + error)])
                CALL apoc.util.validate(failedBatches > 0, "At least one batch failed: %s", [reduce(all_errors = "", error IN keys(batch.errors) | all_errors + ", " + error)])
                RETURN 0
            ]]>
        </query>
        <query>
            CALL apoc.log.info("Finished acr_cloud data ingest part 141 of 169 at %s", [datetime()]);
        </query>

        <query>
            <![CDATA[
                CALL apoc.periodic.iterate(
                     "
                        WITH 'snowflake_orchard' AS url_alias,
                        '
                            SELECT * FROM facts.qa.jsonified_track_mapping ORDER BY ACR_ID ASC LIMIT 100000 OFFSET 14100000
                        '
                        AS sql
                        CALL apoc.load.jdbc(url_alias, sql)
                        YIELD row
                        return apoc.convert.fromJsonMap(row.NODE) AS row;
                    ",
                    '
                        WITH *, "database/distro-4707" AS by
                        MERGE (acrId:ACRID { id: row.acr_id })
                            ON CREATE SET
                                acrId.createdAt = datetime(),
                                acrId.createdBy = by,
                                acrId.lastModifiedAt = datetime(),
                                acrId.lastModifiedBy = by
                        MERGE (acrId)<-[acrIdToOsr:CONTAINS_FINGERPRINT]-(osr:OrchardSoundRecording)
                            ON CREATE SET
                                osr.id = apoc.create.uuid(),
                                osr.createdAt = datetime(),
                                osr.createdBy = by,
                                osr.lastModifiedAt = datetime(),
                                osr.lastModifiedBy = by,
                                acrIdToOsr.createdAt = datetime(),
                                acrIdToOsr.createdBy = by,
                                acrIdToOsr.lastModifiedAt = datetime(),
                                acrIdToOsr.lastModifiedBy = by
                        WITH *
                        UNWIND row.assets AS source_asset
                        MERGE (asset:OrchardAsset {
                            filename: source_asset.filename,
                            extension: "mp3",
                            source: "direct-delivery-db"
                        })
                            ON CREATE SET
                                asset.id = apoc.create.uuid(),
                                asset.createdAt = datetime(),
                                asset.createdBy = by,
                                asset.lastModifiedAt = datetime(),
                                asset.lastModifiedBy = by
                        MERGE (asset)-[assetToAcrId:FINGERPRINTED_AS]->(acrId)
                            ON CREATE SET
                                assetToAcrId.createdAt = datetime(),
                                assetToAcrId.createdBy = by
                            SET
                                assetToAcrId.lastModifiedAt = datetime(),
                                assetToAcrId.lastModifiedBy = by
                        WITH *
                        OPTIONAL MATCH (asset)-[assetToOldAcrId:FINGERPRINTED_AS]->(oldAcrId:ACRID)
                            WHERE oldAcrId <> acrId
                        FOREACH (hasOldAcrId IN CASE WHEN oldAcrId IS NOT NULL THEN [1] ELSE [] END |
                            CREATE (asset)-[deletedRelationship:DELETED_FINGERPRINTED_AS]->(oldAcrId)
                            SET
                                deletedRelationship += assetToOldAcrId,
                                deletedRelationship.deletedAt = datetime(),
                                deletedRelationship.deletedBy = by
                            DELETE assetToOldAcrId
                        )
                        WITH DISTINCT source_asset, by, asset
                        OPTIONAL MATCH (track:Track { id: toInteger(source_asset.tuid) })
                        CALL apoc.util.validate(track IS NULL, "Could not find the track %s", [source_asset.tuid])
                        MERGE (track)-[trackHasAsset:HAS_ASSET]->(asset)
                            ON CREATE SET
                                trackHasAsset.createdAt = datetime(),
                                trackHasAsset.createdBy = by,
                                trackHasAsset.lastModifiedAt = datetime(),
                                trackHasAsset.lastModifiedBy = by
                    ',
                    {
                        batchSize: 1000
                    }
                )
                YIELD failedOperations, errorMessages, failedBatches, batch
                CALL apoc.util.validate(failedOperations > 0, "At least one sub-operation failed: %s", [reduce(all_errors = "", error IN keys(errorMessages) | all_errors + ", " + error)])
                CALL apoc.util.validate(failedBatches > 0, "At least one batch failed: %s", [reduce(all_errors = "", error IN keys(batch.errors) | all_errors + ", " + error)])
                RETURN 0
            ]]>
        </query>
        <query>
            CALL apoc.log.info("Finished acr_cloud data ingest part 142 of 169 at %s", [datetime()]);
        </query>

        <query>
            <![CDATA[
                CALL apoc.periodic.iterate(
                     "
                        WITH 'snowflake_orchard' AS url_alias,
                        '
                            SELECT * FROM facts.qa.jsonified_track_mapping ORDER BY ACR_ID ASC LIMIT 100000 OFFSET 14200000
                        '
                        AS sql
                        CALL apoc.load.jdbc(url_alias, sql)
                        YIELD row
                        return apoc.convert.fromJsonMap(row.NODE) AS row;
                    ",
                    '
                        WITH *, "database/distro-4707" AS by
                        MERGE (acrId:ACRID { id: row.acr_id })
                            ON CREATE SET
                                acrId.createdAt = datetime(),
                                acrId.createdBy = by,
                                acrId.lastModifiedAt = datetime(),
                                acrId.lastModifiedBy = by
                        MERGE (acrId)<-[acrIdToOsr:CONTAINS_FINGERPRINT]-(osr:OrchardSoundRecording)
                            ON CREATE SET
                                osr.id = apoc.create.uuid(),
                                osr.createdAt = datetime(),
                                osr.createdBy = by,
                                osr.lastModifiedAt = datetime(),
                                osr.lastModifiedBy = by,
                                acrIdToOsr.createdAt = datetime(),
                                acrIdToOsr.createdBy = by,
                                acrIdToOsr.lastModifiedAt = datetime(),
                                acrIdToOsr.lastModifiedBy = by
                        WITH *
                        UNWIND row.assets AS source_asset
                        MERGE (asset:OrchardAsset {
                            filename: source_asset.filename,
                            extension: "mp3",
                            source: "direct-delivery-db"
                        })
                            ON CREATE SET
                                asset.id = apoc.create.uuid(),
                                asset.createdAt = datetime(),
                                asset.createdBy = by,
                                asset.lastModifiedAt = datetime(),
                                asset.lastModifiedBy = by
                        MERGE (asset)-[assetToAcrId:FINGERPRINTED_AS]->(acrId)
                            ON CREATE SET
                                assetToAcrId.createdAt = datetime(),
                                assetToAcrId.createdBy = by
                            SET
                                assetToAcrId.lastModifiedAt = datetime(),
                                assetToAcrId.lastModifiedBy = by
                        WITH *
                        OPTIONAL MATCH (asset)-[assetToOldAcrId:FINGERPRINTED_AS]->(oldAcrId:ACRID)
                            WHERE oldAcrId <> acrId
                        FOREACH (hasOldAcrId IN CASE WHEN oldAcrId IS NOT NULL THEN [1] ELSE [] END |
                            CREATE (asset)-[deletedRelationship:DELETED_FINGERPRINTED_AS]->(oldAcrId)
                            SET
                                deletedRelationship += assetToOldAcrId,
                                deletedRelationship.deletedAt = datetime(),
                                deletedRelationship.deletedBy = by
                            DELETE assetToOldAcrId
                        )
                        WITH DISTINCT source_asset, by, asset
                        OPTIONAL MATCH (track:Track { id: toInteger(source_asset.tuid) })
                        CALL apoc.util.validate(track IS NULL, "Could not find the track %s", [source_asset.tuid])
                        MERGE (track)-[trackHasAsset:HAS_ASSET]->(asset)
                            ON CREATE SET
                                trackHasAsset.createdAt = datetime(),
                                trackHasAsset.createdBy = by,
                                trackHasAsset.lastModifiedAt = datetime(),
                                trackHasAsset.lastModifiedBy = by
                    ',
                    {
                        batchSize: 1000
                    }
                )
                YIELD failedOperations, errorMessages, failedBatches, batch
                CALL apoc.util.validate(failedOperations > 0, "At least one sub-operation failed: %s", [reduce(all_errors = "", error IN keys(errorMessages) | all_errors + ", " + error)])
                CALL apoc.util.validate(failedBatches > 0, "At least one batch failed: %s", [reduce(all_errors = "", error IN keys(batch.errors) | all_errors + ", " + error)])
                RETURN 0
            ]]>
        </query>
        <query>
            CALL apoc.log.info("Finished acr_cloud data ingest part 143 of 169 at %s", [datetime()]);
        </query>

        <query>
            <![CDATA[
                CALL apoc.periodic.iterate(
                     "
                        WITH 'snowflake_orchard' AS url_alias,
                        '
                            SELECT * FROM facts.qa.jsonified_track_mapping ORDER BY ACR_ID ASC LIMIT 100000 OFFSET 14300000
                        '
                        AS sql
                        CALL apoc.load.jdbc(url_alias, sql)
                        YIELD row
                        return apoc.convert.fromJsonMap(row.NODE) AS row;
                    ",
                    '
                        WITH *, "database/distro-4707" AS by
                        MERGE (acrId:ACRID { id: row.acr_id })
                            ON CREATE SET
                                acrId.createdAt = datetime(),
                                acrId.createdBy = by,
                                acrId.lastModifiedAt = datetime(),
                                acrId.lastModifiedBy = by
                        MERGE (acrId)<-[acrIdToOsr:CONTAINS_FINGERPRINT]-(osr:OrchardSoundRecording)
                            ON CREATE SET
                                osr.id = apoc.create.uuid(),
                                osr.createdAt = datetime(),
                                osr.createdBy = by,
                                osr.lastModifiedAt = datetime(),
                                osr.lastModifiedBy = by,
                                acrIdToOsr.createdAt = datetime(),
                                acrIdToOsr.createdBy = by,
                                acrIdToOsr.lastModifiedAt = datetime(),
                                acrIdToOsr.lastModifiedBy = by
                        WITH *
                        UNWIND row.assets AS source_asset
                        MERGE (asset:OrchardAsset {
                            filename: source_asset.filename,
                            extension: "mp3",
                            source: "direct-delivery-db"
                        })
                            ON CREATE SET
                                asset.id = apoc.create.uuid(),
                                asset.createdAt = datetime(),
                                asset.createdBy = by,
                                asset.lastModifiedAt = datetime(),
                                asset.lastModifiedBy = by
                        MERGE (asset)-[assetToAcrId:FINGERPRINTED_AS]->(acrId)
                            ON CREATE SET
                                assetToAcrId.createdAt = datetime(),
                                assetToAcrId.createdBy = by
                            SET
                                assetToAcrId.lastModifiedAt = datetime(),
                                assetToAcrId.lastModifiedBy = by
                        WITH *
                        OPTIONAL MATCH (asset)-[assetToOldAcrId:FINGERPRINTED_AS]->(oldAcrId:ACRID)
                            WHERE oldAcrId <> acrId
                        FOREACH (hasOldAcrId IN CASE WHEN oldAcrId IS NOT NULL THEN [1] ELSE [] END |
                            CREATE (asset)-[deletedRelationship:DELETED_FINGERPRINTED_AS]->(oldAcrId)
                            SET
                                deletedRelationship += assetToOldAcrId,
                                deletedRelationship.deletedAt = datetime(),
                                deletedRelationship.deletedBy = by
                            DELETE assetToOldAcrId
                        )
                        WITH DISTINCT source_asset, by, asset
                        OPTIONAL MATCH (track:Track { id: toInteger(source_asset.tuid) })
                        CALL apoc.util.validate(track IS NULL, "Could not find the track %s", [source_asset.tuid])
                        MERGE (track)-[trackHasAsset:HAS_ASSET]->(asset)
                            ON CREATE SET
                                trackHasAsset.createdAt = datetime(),
                                trackHasAsset.createdBy = by,
                                trackHasAsset.lastModifiedAt = datetime(),
                                trackHasAsset.lastModifiedBy = by
                    ',
                    {
                        batchSize: 1000
                    }
                )
                YIELD failedOperations, errorMessages, failedBatches, batch
                CALL apoc.util.validate(failedOperations > 0, "At least one sub-operation failed: %s", [reduce(all_errors = "", error IN keys(errorMessages) | all_errors + ", " + error)])
                CALL apoc.util.validate(failedBatches > 0, "At least one batch failed: %s", [reduce(all_errors = "", error IN keys(batch.errors) | all_errors + ", " + error)])
                RETURN 0
            ]]>
        </query>
        <query>
            CALL apoc.log.info("Finished acr_cloud data ingest part 144 of 169 at %s", [datetime()]);
        </query>

        <query>
            <![CDATA[
                CALL apoc.periodic.iterate(
                     "
                        WITH 'snowflake_orchard' AS url_alias,
                        '
                            SELECT * FROM facts.qa.jsonified_track_mapping ORDER BY ACR_ID ASC LIMIT 100000 OFFSET 14400000
                        '
                        AS sql
                        CALL apoc.load.jdbc(url_alias, sql)
                        YIELD row
                        return apoc.convert.fromJsonMap(row.NODE) AS row;
                    ",
                    '
                        WITH *, "database/distro-4707" AS by
                        MERGE (acrId:ACRID { id: row.acr_id })
                            ON CREATE SET
                                acrId.createdAt = datetime(),
                                acrId.createdBy = by,
                                acrId.lastModifiedAt = datetime(),
                                acrId.lastModifiedBy = by
                        MERGE (acrId)<-[acrIdToOsr:CONTAINS_FINGERPRINT]-(osr:OrchardSoundRecording)
                            ON CREATE SET
                                osr.id = apoc.create.uuid(),
                                osr.createdAt = datetime(),
                                osr.createdBy = by,
                                osr.lastModifiedAt = datetime(),
                                osr.lastModifiedBy = by,
                                acrIdToOsr.createdAt = datetime(),
                                acrIdToOsr.createdBy = by,
                                acrIdToOsr.lastModifiedAt = datetime(),
                                acrIdToOsr.lastModifiedBy = by
                        WITH *
                        UNWIND row.assets AS source_asset
                        MERGE (asset:OrchardAsset {
                            filename: source_asset.filename,
                            extension: "mp3",
                            source: "direct-delivery-db"
                        })
                            ON CREATE SET
                                asset.id = apoc.create.uuid(),
                                asset.createdAt = datetime(),
                                asset.createdBy = by,
                                asset.lastModifiedAt = datetime(),
                                asset.lastModifiedBy = by
                        MERGE (asset)-[assetToAcrId:FINGERPRINTED_AS]->(acrId)
                            ON CREATE SET
                                assetToAcrId.createdAt = datetime(),
                                assetToAcrId.createdBy = by
                            SET
                                assetToAcrId.lastModifiedAt = datetime(),
                                assetToAcrId.lastModifiedBy = by
                        WITH *
                        OPTIONAL MATCH (asset)-[assetToOldAcrId:FINGERPRINTED_AS]->(oldAcrId:ACRID)
                            WHERE oldAcrId <> acrId
                        FOREACH (hasOldAcrId IN CASE WHEN oldAcrId IS NOT NULL THEN [1] ELSE [] END |
                            CREATE (asset)-[deletedRelationship:DELETED_FINGERPRINTED_AS]->(oldAcrId)
                            SET
                                deletedRelationship += assetToOldAcrId,
                                deletedRelationship.deletedAt = datetime(),
                                deletedRelationship.deletedBy = by
                            DELETE assetToOldAcrId
                        )
                        WITH DISTINCT source_asset, by, asset
                        OPTIONAL MATCH (track:Track { id: toInteger(source_asset.tuid) })
                        CALL apoc.util.validate(track IS NULL, "Could not find the track %s", [source_asset.tuid])
                        MERGE (track)-[trackHasAsset:HAS_ASSET]->(asset)
                            ON CREATE SET
                                trackHasAsset.createdAt = datetime(),
                                trackHasAsset.createdBy = by,
                                trackHasAsset.lastModifiedAt = datetime(),
                                trackHasAsset.lastModifiedBy = by
                    ',
                    {
                        batchSize: 1000
                    }
                )
                YIELD failedOperations, errorMessages, failedBatches, batch
                CALL apoc.util.validate(failedOperations > 0, "At least one sub-operation failed: %s", [reduce(all_errors = "", error IN keys(errorMessages) | all_errors + ", " + error)])
                CALL apoc.util.validate(failedBatches > 0, "At least one batch failed: %s", [reduce(all_errors = "", error IN keys(batch.errors) | all_errors + ", " + error)])
                RETURN 0
            ]]>
        </query>
        <query>
            CALL apoc.log.info("Finished acr_cloud data ingest part 145 of 169 at %s", [datetime()]);
        </query>

        <query>
            <![CDATA[
                CALL apoc.periodic.iterate(
                     "
                        WITH 'snowflake_orchard' AS url_alias,
                        '
                            SELECT * FROM facts.qa.jsonified_track_mapping ORDER BY ACR_ID ASC LIMIT 100000 OFFSET 14500000
                        '
                        AS sql
                        CALL apoc.load.jdbc(url_alias, sql)
                        YIELD row
                        return apoc.convert.fromJsonMap(row.NODE) AS row;
                    ",
                    '
                        WITH *, "database/distro-4707" AS by
                        MERGE (acrId:ACRID { id: row.acr_id })
                            ON CREATE SET
                                acrId.createdAt = datetime(),
                                acrId.createdBy = by,
                                acrId.lastModifiedAt = datetime(),
                                acrId.lastModifiedBy = by
                        MERGE (acrId)<-[acrIdToOsr:CONTAINS_FINGERPRINT]-(osr:OrchardSoundRecording)
                            ON CREATE SET
                                osr.id = apoc.create.uuid(),
                                osr.createdAt = datetime(),
                                osr.createdBy = by,
                                osr.lastModifiedAt = datetime(),
                                osr.lastModifiedBy = by,
                                acrIdToOsr.createdAt = datetime(),
                                acrIdToOsr.createdBy = by,
                                acrIdToOsr.lastModifiedAt = datetime(),
                                acrIdToOsr.lastModifiedBy = by
                        WITH *
                        UNWIND row.assets AS source_asset
                        MERGE (asset:OrchardAsset {
                            filename: source_asset.filename,
                            extension: "mp3",
                            source: "direct-delivery-db"
                        })
                            ON CREATE SET
                                asset.id = apoc.create.uuid(),
                                asset.createdAt = datetime(),
                                asset.createdBy = by,
                                asset.lastModifiedAt = datetime(),
                                asset.lastModifiedBy = by
                        MERGE (asset)-[assetToAcrId:FINGERPRINTED_AS]->(acrId)
                            ON CREATE SET
                                assetToAcrId.createdAt = datetime(),
                                assetToAcrId.createdBy = by
                            SET
                                assetToAcrId.lastModifiedAt = datetime(),
                                assetToAcrId.lastModifiedBy = by
                        WITH *
                        OPTIONAL MATCH (asset)-[assetToOldAcrId:FINGERPRINTED_AS]->(oldAcrId:ACRID)
                            WHERE oldAcrId <> acrId
                        FOREACH (hasOldAcrId IN CASE WHEN oldAcrId IS NOT NULL THEN [1] ELSE [] END |
                            CREATE (asset)-[deletedRelationship:DELETED_FINGERPRINTED_AS]->(oldAcrId)
                            SET
                                deletedRelationship += assetToOldAcrId,
                                deletedRelationship.deletedAt = datetime(),
                                deletedRelationship.deletedBy = by
                            DELETE assetToOldAcrId
                        )
                        WITH DISTINCT source_asset, by, asset
                        OPTIONAL MATCH (track:Track { id: toInteger(source_asset.tuid) })
                        CALL apoc.util.validate(track IS NULL, "Could not find the track %s", [source_asset.tuid])
                        MERGE (track)-[trackHasAsset:HAS_ASSET]->(asset)
                            ON CREATE SET
                                trackHasAsset.createdAt = datetime(),
                                trackHasAsset.createdBy = by,
                                trackHasAsset.lastModifiedAt = datetime(),
                                trackHasAsset.lastModifiedBy = by
                    ',
                    {
                        batchSize: 1000
                    }
                )
                YIELD failedOperations, errorMessages, failedBatches, batch
                CALL apoc.util.validate(failedOperations > 0, "At least one sub-operation failed: %s", [reduce(all_errors = "", error IN keys(errorMessages) | all_errors + ", " + error)])
                CALL apoc.util.validate(failedBatches > 0, "At least one batch failed: %s", [reduce(all_errors = "", error IN keys(batch.errors) | all_errors + ", " + error)])
                RETURN 0
            ]]>
        </query>
        <query>
            CALL apoc.log.info("Finished acr_cloud data ingest part 146 of 169 at %s", [datetime()]);
        </query>

        <query>
            <![CDATA[
                CALL apoc.periodic.iterate(
                     "
                        WITH 'snowflake_orchard' AS url_alias,
                        '
                            SELECT * FROM facts.qa.jsonified_track_mapping ORDER BY ACR_ID ASC LIMIT 100000 OFFSET 14600000
                        '
                        AS sql
                        CALL apoc.load.jdbc(url_alias, sql)
                        YIELD row
                        return apoc.convert.fromJsonMap(row.NODE) AS row;
                    ",
                    '
                        WITH *, "database/distro-4707" AS by
                        MERGE (acrId:ACRID { id: row.acr_id })
                            ON CREATE SET
                                acrId.createdAt = datetime(),
                                acrId.createdBy = by,
                                acrId.lastModifiedAt = datetime(),
                                acrId.lastModifiedBy = by
                        MERGE (acrId)<-[acrIdToOsr:CONTAINS_FINGERPRINT]-(osr:OrchardSoundRecording)
                            ON CREATE SET
                                osr.id = apoc.create.uuid(),
                                osr.createdAt = datetime(),
                                osr.createdBy = by,
                                osr.lastModifiedAt = datetime(),
                                osr.lastModifiedBy = by,
                                acrIdToOsr.createdAt = datetime(),
                                acrIdToOsr.createdBy = by,
                                acrIdToOsr.lastModifiedAt = datetime(),
                                acrIdToOsr.lastModifiedBy = by
                        WITH *
                        UNWIND row.assets AS source_asset
                        MERGE (asset:OrchardAsset {
                            filename: source_asset.filename,
                            extension: "mp3",
                            source: "direct-delivery-db"
                        })
                            ON CREATE SET
                                asset.id = apoc.create.uuid(),
                                asset.createdAt = datetime(),
                                asset.createdBy = by,
                                asset.lastModifiedAt = datetime(),
                                asset.lastModifiedBy = by
                        MERGE (asset)-[assetToAcrId:FINGERPRINTED_AS]->(acrId)
                            ON CREATE SET
                                assetToAcrId.createdAt = datetime(),
                                assetToAcrId.createdBy = by
                            SET
                                assetToAcrId.lastModifiedAt = datetime(),
                                assetToAcrId.lastModifiedBy = by
                        WITH *
                        OPTIONAL MATCH (asset)-[assetToOldAcrId:FINGERPRINTED_AS]->(oldAcrId:ACRID)
                            WHERE oldAcrId <> acrId
                        FOREACH (hasOldAcrId IN CASE WHEN oldAcrId IS NOT NULL THEN [1] ELSE [] END |
                            CREATE (asset)-[deletedRelationship:DELETED_FINGERPRINTED_AS]->(oldAcrId)
                            SET
                                deletedRelationship += assetToOldAcrId,
                                deletedRelationship.deletedAt = datetime(),
                                deletedRelationship.deletedBy = by
                            DELETE assetToOldAcrId
                        )
                        WITH DISTINCT source_asset, by, asset
                        OPTIONAL MATCH (track:Track { id: toInteger(source_asset.tuid) })
                        CALL apoc.util.validate(track IS NULL, "Could not find the track %s", [source_asset.tuid])
                        MERGE (track)-[trackHasAsset:HAS_ASSET]->(asset)
                            ON CREATE SET
                                trackHasAsset.createdAt = datetime(),
                                trackHasAsset.createdBy = by,
                                trackHasAsset.lastModifiedAt = datetime(),
                                trackHasAsset.lastModifiedBy = by
                    ',
                    {
                        batchSize: 1000
                    }
                )
                YIELD failedOperations, errorMessages, failedBatches, batch
                CALL apoc.util.validate(failedOperations > 0, "At least one sub-operation failed: %s", [reduce(all_errors = "", error IN keys(errorMessages) | all_errors + ", " + error)])
                CALL apoc.util.validate(failedBatches > 0, "At least one batch failed: %s", [reduce(all_errors = "", error IN keys(batch.errors) | all_errors + ", " + error)])
                RETURN 0
            ]]>
        </query>
        <query>
            CALL apoc.log.info("Finished acr_cloud data ingest part 147 of 169 at %s", [datetime()]);
        </query>

        <query>
            <![CDATA[
                CALL apoc.periodic.iterate(
                     "
                        WITH 'snowflake_orchard' AS url_alias,
                        '
                            SELECT * FROM facts.qa.jsonified_track_mapping ORDER BY ACR_ID ASC LIMIT 100000 OFFSET 14700000
                        '
                        AS sql
                        CALL apoc.load.jdbc(url_alias, sql)
                        YIELD row
                        return apoc.convert.fromJsonMap(row.NODE) AS row;
                    ",
                    '
                        WITH *, "database/distro-4707" AS by
                        MERGE (acrId:ACRID { id: row.acr_id })
                            ON CREATE SET
                                acrId.createdAt = datetime(),
                                acrId.createdBy = by,
                                acrId.lastModifiedAt = datetime(),
                                acrId.lastModifiedBy = by
                        MERGE (acrId)<-[acrIdToOsr:CONTAINS_FINGERPRINT]-(osr:OrchardSoundRecording)
                            ON CREATE SET
                                osr.id = apoc.create.uuid(),
                                osr.createdAt = datetime(),
                                osr.createdBy = by,
                                osr.lastModifiedAt = datetime(),
                                osr.lastModifiedBy = by,
                                acrIdToOsr.createdAt = datetime(),
                                acrIdToOsr.createdBy = by,
                                acrIdToOsr.lastModifiedAt = datetime(),
                                acrIdToOsr.lastModifiedBy = by
                        WITH *
                        UNWIND row.assets AS source_asset
                        MERGE (asset:OrchardAsset {
                            filename: source_asset.filename,
                            extension: "mp3",
                            source: "direct-delivery-db"
                        })
                            ON CREATE SET
                                asset.id = apoc.create.uuid(),
                                asset.createdAt = datetime(),
                                asset.createdBy = by,
                                asset.lastModifiedAt = datetime(),
                                asset.lastModifiedBy = by
                        MERGE (asset)-[assetToAcrId:FINGERPRINTED_AS]->(acrId)
                            ON CREATE SET
                                assetToAcrId.createdAt = datetime(),
                                assetToAcrId.createdBy = by
                            SET
                                assetToAcrId.lastModifiedAt = datetime(),
                                assetToAcrId.lastModifiedBy = by
                        WITH *
                        OPTIONAL MATCH (asset)-[assetToOldAcrId:FINGERPRINTED_AS]->(oldAcrId:ACRID)
                            WHERE oldAcrId <> acrId
                        FOREACH (hasOldAcrId IN CASE WHEN oldAcrId IS NOT NULL THEN [1] ELSE [] END |
                            CREATE (asset)-[deletedRelationship:DELETED_FINGERPRINTED_AS]->(oldAcrId)
                            SET
                                deletedRelationship += assetToOldAcrId,
                                deletedRelationship.deletedAt = datetime(),
                                deletedRelationship.deletedBy = by
                            DELETE assetToOldAcrId
                        )
                        WITH DISTINCT source_asset, by, asset
                        OPTIONAL MATCH (track:Track { id: toInteger(source_asset.tuid) })
                        CALL apoc.util.validate(track IS NULL, "Could not find the track %s", [source_asset.tuid])
                        MERGE (track)-[trackHasAsset:HAS_ASSET]->(asset)
                            ON CREATE SET
                                trackHasAsset.createdAt = datetime(),
                                trackHasAsset.createdBy = by,
                                trackHasAsset.lastModifiedAt = datetime(),
                                trackHasAsset.lastModifiedBy = by
                    ',
                    {
                        batchSize: 1000
                    }
                )
                YIELD failedOperations, errorMessages, failedBatches, batch
                CALL apoc.util.validate(failedOperations > 0, "At least one sub-operation failed: %s", [reduce(all_errors = "", error IN keys(errorMessages) | all_errors + ", " + error)])
                CALL apoc.util.validate(failedBatches > 0, "At least one batch failed: %s", [reduce(all_errors = "", error IN keys(batch.errors) | all_errors + ", " + error)])
                RETURN 0
            ]]>
        </query>
        <query>
            CALL apoc.log.info("Finished acr_cloud data ingest part 148 of 169 at %s", [datetime()]);
        </query>

        <query>
            <![CDATA[
                CALL apoc.periodic.iterate(
                     "
                        WITH 'snowflake_orchard' AS url_alias,
                        '
                            SELECT * FROM facts.qa.jsonified_track_mapping ORDER BY ACR_ID ASC LIMIT 100000 OFFSET 14800000
                        '
                        AS sql
                        CALL apoc.load.jdbc(url_alias, sql)
                        YIELD row
                        return apoc.convert.fromJsonMap(row.NODE) AS row;
                    ",
                    '
                        WITH *, "database/distro-4707" AS by
                        MERGE (acrId:ACRID { id: row.acr_id })
                            ON CREATE SET
                                acrId.createdAt = datetime(),
                                acrId.createdBy = by,
                                acrId.lastModifiedAt = datetime(),
                                acrId.lastModifiedBy = by
                        MERGE (acrId)<-[acrIdToOsr:CONTAINS_FINGERPRINT]-(osr:OrchardSoundRecording)
                            ON CREATE SET
                                osr.id = apoc.create.uuid(),
                                osr.createdAt = datetime(),
                                osr.createdBy = by,
                                osr.lastModifiedAt = datetime(),
                                osr.lastModifiedBy = by,
                                acrIdToOsr.createdAt = datetime(),
                                acrIdToOsr.createdBy = by,
                                acrIdToOsr.lastModifiedAt = datetime(),
                                acrIdToOsr.lastModifiedBy = by
                        WITH *
                        UNWIND row.assets AS source_asset
                        MERGE (asset:OrchardAsset {
                            filename: source_asset.filename,
                            extension: "mp3",
                            source: "direct-delivery-db"
                        })
                            ON CREATE SET
                                asset.id = apoc.create.uuid(),
                                asset.createdAt = datetime(),
                                asset.createdBy = by,
                                asset.lastModifiedAt = datetime(),
                                asset.lastModifiedBy = by
                        MERGE (asset)-[assetToAcrId:FINGERPRINTED_AS]->(acrId)
                            ON CREATE SET
                                assetToAcrId.createdAt = datetime(),
                                assetToAcrId.createdBy = by
                            SET
                                assetToAcrId.lastModifiedAt = datetime(),
                                assetToAcrId.lastModifiedBy = by
                        WITH *
                        OPTIONAL MATCH (asset)-[assetToOldAcrId:FINGERPRINTED_AS]->(oldAcrId:ACRID)
                            WHERE oldAcrId <> acrId
                        FOREACH (hasOldAcrId IN CASE WHEN oldAcrId IS NOT NULL THEN [1] ELSE [] END |
                            CREATE (asset)-[deletedRelationship:DELETED_FINGERPRINTED_AS]->(oldAcrId)
                            SET
                                deletedRelationship += assetToOldAcrId,
                                deletedRelationship.deletedAt = datetime(),
                                deletedRelationship.deletedBy = by
                            DELETE assetToOldAcrId
                        )
                        WITH DISTINCT source_asset, by, asset
                        OPTIONAL MATCH (track:Track { id: toInteger(source_asset.tuid) })
                        CALL apoc.util.validate(track IS NULL, "Could not find the track %s", [source_asset.tuid])
                        MERGE (track)-[trackHasAsset:HAS_ASSET]->(asset)
                            ON CREATE SET
                                trackHasAsset.createdAt = datetime(),
                                trackHasAsset.createdBy = by,
                                trackHasAsset.lastModifiedAt = datetime(),
                                trackHasAsset.lastModifiedBy = by
                    ',
                    {
                        batchSize: 1000
                    }
                )
                YIELD failedOperations, errorMessages, failedBatches, batch
                CALL apoc.util.validate(failedOperations > 0, "At least one sub-operation failed: %s", [reduce(all_errors = "", error IN keys(errorMessages) | all_errors + ", " + error)])
                CALL apoc.util.validate(failedBatches > 0, "At least one batch failed: %s", [reduce(all_errors = "", error IN keys(batch.errors) | all_errors + ", " + error)])
                RETURN 0
            ]]>
        </query>
        <query>
            CALL apoc.log.info("Finished acr_cloud data ingest part 149 of 169 at %s", [datetime()]);
        </query>

        <query>
            <![CDATA[
                CALL apoc.periodic.iterate(
                     "
                        WITH 'snowflake_orchard' AS url_alias,
                        '
                            SELECT * FROM facts.qa.jsonified_track_mapping ORDER BY ACR_ID ASC LIMIT 100000 OFFSET 14900000
                        '
                        AS sql
                        CALL apoc.load.jdbc(url_alias, sql)
                        YIELD row
                        return apoc.convert.fromJsonMap(row.NODE) AS row;
                    ",
                    '
                        WITH *, "database/distro-4707" AS by
                        MERGE (acrId:ACRID { id: row.acr_id })
                            ON CREATE SET
                                acrId.createdAt = datetime(),
                                acrId.createdBy = by,
                                acrId.lastModifiedAt = datetime(),
                                acrId.lastModifiedBy = by
                        MERGE (acrId)<-[acrIdToOsr:CONTAINS_FINGERPRINT]-(osr:OrchardSoundRecording)
                            ON CREATE SET
                                osr.id = apoc.create.uuid(),
                                osr.createdAt = datetime(),
                                osr.createdBy = by,
                                osr.lastModifiedAt = datetime(),
                                osr.lastModifiedBy = by,
                                acrIdToOsr.createdAt = datetime(),
                                acrIdToOsr.createdBy = by,
                                acrIdToOsr.lastModifiedAt = datetime(),
                                acrIdToOsr.lastModifiedBy = by
                        WITH *
                        UNWIND row.assets AS source_asset
                        MERGE (asset:OrchardAsset {
                            filename: source_asset.filename,
                            extension: "mp3",
                            source: "direct-delivery-db"
                        })
                            ON CREATE SET
                                asset.id = apoc.create.uuid(),
                                asset.createdAt = datetime(),
                                asset.createdBy = by,
                                asset.lastModifiedAt = datetime(),
                                asset.lastModifiedBy = by
                        MERGE (asset)-[assetToAcrId:FINGERPRINTED_AS]->(acrId)
                            ON CREATE SET
                                assetToAcrId.createdAt = datetime(),
                                assetToAcrId.createdBy = by
                            SET
                                assetToAcrId.lastModifiedAt = datetime(),
                                assetToAcrId.lastModifiedBy = by
                        WITH *
                        OPTIONAL MATCH (asset)-[assetToOldAcrId:FINGERPRINTED_AS]->(oldAcrId:ACRID)
                            WHERE oldAcrId <> acrId
                        FOREACH (hasOldAcrId IN CASE WHEN oldAcrId IS NOT NULL THEN [1] ELSE [] END |
                            CREATE (asset)-[deletedRelationship:DELETED_FINGERPRINTED_AS]->(oldAcrId)
                            SET
                                deletedRelationship += assetToOldAcrId,
                                deletedRelationship.deletedAt = datetime(),
                                deletedRelationship.deletedBy = by
                            DELETE assetToOldAcrId
                        )
                        WITH DISTINCT source_asset, by, asset
                        OPTIONAL MATCH (track:Track { id: toInteger(source_asset.tuid) })
                        CALL apoc.util.validate(track IS NULL, "Could not find the track %s", [source_asset.tuid])
                        MERGE (track)-[trackHasAsset:HAS_ASSET]->(asset)
                            ON CREATE SET
                                trackHasAsset.createdAt = datetime(),
                                trackHasAsset.createdBy = by,
                                trackHasAsset.lastModifiedAt = datetime(),
                                trackHasAsset.lastModifiedBy = by
                    ',
                    {
                        batchSize: 1000
                    }
                )
                YIELD failedOperations, errorMessages, failedBatches, batch
                CALL apoc.util.validate(failedOperations > 0, "At least one sub-operation failed: %s", [reduce(all_errors = "", error IN keys(errorMessages) | all_errors + ", " + error)])
                CALL apoc.util.validate(failedBatches > 0, "At least one batch failed: %s", [reduce(all_errors = "", error IN keys(batch.errors) | all_errors + ", " + error)])
                RETURN 0
            ]]>
        </query>
        <query>
            CALL apoc.log.info("Finished acr_cloud data ingest part 150 of 169 at %s", [datetime()]);
        </query>

        <query>
            <![CDATA[
                CALL apoc.periodic.iterate(
                     "
                        WITH 'snowflake_orchard' AS url_alias,
                        '
                            SELECT * FROM facts.qa.jsonified_track_mapping ORDER BY ACR_ID ASC LIMIT 100000 OFFSET 15000000
                        '
                        AS sql
                        CALL apoc.load.jdbc(url_alias, sql)
                        YIELD row
                        return apoc.convert.fromJsonMap(row.NODE) AS row;
                    ",
                    '
                        WITH *, "database/distro-4707" AS by
                        MERGE (acrId:ACRID { id: row.acr_id })
                            ON CREATE SET
                                acrId.createdAt = datetime(),
                                acrId.createdBy = by,
                                acrId.lastModifiedAt = datetime(),
                                acrId.lastModifiedBy = by
                        MERGE (acrId)<-[acrIdToOsr:CONTAINS_FINGERPRINT]-(osr:OrchardSoundRecording)
                            ON CREATE SET
                                osr.id = apoc.create.uuid(),
                                osr.createdAt = datetime(),
                                osr.createdBy = by,
                                osr.lastModifiedAt = datetime(),
                                osr.lastModifiedBy = by,
                                acrIdToOsr.createdAt = datetime(),
                                acrIdToOsr.createdBy = by,
                                acrIdToOsr.lastModifiedAt = datetime(),
                                acrIdToOsr.lastModifiedBy = by
                        WITH *
                        UNWIND row.assets AS source_asset
                        MERGE (asset:OrchardAsset {
                            filename: source_asset.filename,
                            extension: "mp3",
                            source: "direct-delivery-db"
                        })
                            ON CREATE SET
                                asset.id = apoc.create.uuid(),
                                asset.createdAt = datetime(),
                                asset.createdBy = by,
                                asset.lastModifiedAt = datetime(),
                                asset.lastModifiedBy = by
                        MERGE (asset)-[assetToAcrId:FINGERPRINTED_AS]->(acrId)
                            ON CREATE SET
                                assetToAcrId.createdAt = datetime(),
                                assetToAcrId.createdBy = by
                            SET
                                assetToAcrId.lastModifiedAt = datetime(),
                                assetToAcrId.lastModifiedBy = by
                        WITH *
                        OPTIONAL MATCH (asset)-[assetToOldAcrId:FINGERPRINTED_AS]->(oldAcrId:ACRID)
                            WHERE oldAcrId <> acrId
                        FOREACH (hasOldAcrId IN CASE WHEN oldAcrId IS NOT NULL THEN [1] ELSE [] END |
                            CREATE (asset)-[deletedRelationship:DELETED_FINGERPRINTED_AS]->(oldAcrId)
                            SET
                                deletedRelationship += assetToOldAcrId,
                                deletedRelationship.deletedAt = datetime(),
                                deletedRelationship.deletedBy = by
                            DELETE assetToOldAcrId
                        )
                        WITH DISTINCT source_asset, by, asset
                        OPTIONAL MATCH (track:Track { id: toInteger(source_asset.tuid) })
                        CALL apoc.util.validate(track IS NULL, "Could not find the track %s", [source_asset.tuid])
                        MERGE (track)-[trackHasAsset:HAS_ASSET]->(asset)
                            ON CREATE SET
                                trackHasAsset.createdAt = datetime(),
                                trackHasAsset.createdBy = by,
                                trackHasAsset.lastModifiedAt = datetime(),
                                trackHasAsset.lastModifiedBy = by
                    ',
                    {
                        batchSize: 1000
                    }
                )
                YIELD failedOperations, errorMessages, failedBatches, batch
                CALL apoc.util.validate(failedOperations > 0, "At least one sub-operation failed: %s", [reduce(all_errors = "", error IN keys(errorMessages) | all_errors + ", " + error)])
                CALL apoc.util.validate(failedBatches > 0, "At least one batch failed: %s", [reduce(all_errors = "", error IN keys(batch.errors) | all_errors + ", " + error)])
                RETURN 0
            ]]>
        </query>
        <query>
            CALL apoc.log.info("Finished acr_cloud data ingest part 151 of 169 at %s", [datetime()]);
        </query>

        <query>
            <![CDATA[
                CALL apoc.periodic.iterate(
                     "
                        WITH 'snowflake_orchard' AS url_alias,
                        '
                            SELECT * FROM facts.qa.jsonified_track_mapping ORDER BY ACR_ID ASC LIMIT 100000 OFFSET 15100000
                        '
                        AS sql
                        CALL apoc.load.jdbc(url_alias, sql)
                        YIELD row
                        return apoc.convert.fromJsonMap(row.NODE) AS row;
                    ",
                    '
                        WITH *, "database/distro-4707" AS by
                        MERGE (acrId:ACRID { id: row.acr_id })
                            ON CREATE SET
                                acrId.createdAt = datetime(),
                                acrId.createdBy = by,
                                acrId.lastModifiedAt = datetime(),
                                acrId.lastModifiedBy = by
                        MERGE (acrId)<-[acrIdToOsr:CONTAINS_FINGERPRINT]-(osr:OrchardSoundRecording)
                            ON CREATE SET
                                osr.id = apoc.create.uuid(),
                                osr.createdAt = datetime(),
                                osr.createdBy = by,
                                osr.lastModifiedAt = datetime(),
                                osr.lastModifiedBy = by,
                                acrIdToOsr.createdAt = datetime(),
                                acrIdToOsr.createdBy = by,
                                acrIdToOsr.lastModifiedAt = datetime(),
                                acrIdToOsr.lastModifiedBy = by
                        WITH *
                        UNWIND row.assets AS source_asset
                        MERGE (asset:OrchardAsset {
                            filename: source_asset.filename,
                            extension: "mp3",
                            source: "direct-delivery-db"
                        })
                            ON CREATE SET
                                asset.id = apoc.create.uuid(),
                                asset.createdAt = datetime(),
                                asset.createdBy = by,
                                asset.lastModifiedAt = datetime(),
                                asset.lastModifiedBy = by
                        MERGE (asset)-[assetToAcrId:FINGERPRINTED_AS]->(acrId)
                            ON CREATE SET
                                assetToAcrId.createdAt = datetime(),
                                assetToAcrId.createdBy = by
                            SET
                                assetToAcrId.lastModifiedAt = datetime(),
                                assetToAcrId.lastModifiedBy = by
                        WITH *
                        OPTIONAL MATCH (asset)-[assetToOldAcrId:FINGERPRINTED_AS]->(oldAcrId:ACRID)
                            WHERE oldAcrId <> acrId
                        FOREACH (hasOldAcrId IN CASE WHEN oldAcrId IS NOT NULL THEN [1] ELSE [] END |
                            CREATE (asset)-[deletedRelationship:DELETED_FINGERPRINTED_AS]->(oldAcrId)
                            SET
                                deletedRelationship += assetToOldAcrId,
                                deletedRelationship.deletedAt = datetime(),
                                deletedRelationship.deletedBy = by
                            DELETE assetToOldAcrId
                        )
                        WITH DISTINCT source_asset, by, asset
                        OPTIONAL MATCH (track:Track { id: toInteger(source_asset.tuid) })
                        CALL apoc.util.validate(track IS NULL, "Could not find the track %s", [source_asset.tuid])
                        MERGE (track)-[trackHasAsset:HAS_ASSET]->(asset)
                            ON CREATE SET
                                trackHasAsset.createdAt = datetime(),
                                trackHasAsset.createdBy = by,
                                trackHasAsset.lastModifiedAt = datetime(),
                                trackHasAsset.lastModifiedBy = by
                    ',
                    {
                        batchSize: 1000
                    }
                )
                YIELD failedOperations, errorMessages, failedBatches, batch
                CALL apoc.util.validate(failedOperations > 0, "At least one sub-operation failed: %s", [reduce(all_errors = "", error IN keys(errorMessages) | all_errors + ", " + error)])
                CALL apoc.util.validate(failedBatches > 0, "At least one batch failed: %s", [reduce(all_errors = "", error IN keys(batch.errors) | all_errors + ", " + error)])
                RETURN 0
            ]]>
        </query>
        <query>
            CALL apoc.log.info("Finished acr_cloud data ingest part 152 of 169 at %s", [datetime()]);
        </query>

        <query>
            <![CDATA[
                CALL apoc.periodic.iterate(
                     "
                        WITH 'snowflake_orchard' AS url_alias,
                        '
                            SELECT * FROM facts.qa.jsonified_track_mapping ORDER BY ACR_ID ASC LIMIT 100000 OFFSET 15200000
                        '
                        AS sql
                        CALL apoc.load.jdbc(url_alias, sql)
                        YIELD row
                        return apoc.convert.fromJsonMap(row.NODE) AS row;
                    ",
                    '
                        WITH *, "database/distro-4707" AS by
                        MERGE (acrId:ACRID { id: row.acr_id })
                            ON CREATE SET
                                acrId.createdAt = datetime(),
                                acrId.createdBy = by,
                                acrId.lastModifiedAt = datetime(),
                                acrId.lastModifiedBy = by
                        MERGE (acrId)<-[acrIdToOsr:CONTAINS_FINGERPRINT]-(osr:OrchardSoundRecording)
                            ON CREATE SET
                                osr.id = apoc.create.uuid(),
                                osr.createdAt = datetime(),
                                osr.createdBy = by,
                                osr.lastModifiedAt = datetime(),
                                osr.lastModifiedBy = by,
                                acrIdToOsr.createdAt = datetime(),
                                acrIdToOsr.createdBy = by,
                                acrIdToOsr.lastModifiedAt = datetime(),
                                acrIdToOsr.lastModifiedBy = by
                        WITH *
                        UNWIND row.assets AS source_asset
                        MERGE (asset:OrchardAsset {
                            filename: source_asset.filename,
                            extension: "mp3",
                            source: "direct-delivery-db"
                        })
                            ON CREATE SET
                                asset.id = apoc.create.uuid(),
                                asset.createdAt = datetime(),
                                asset.createdBy = by,
                                asset.lastModifiedAt = datetime(),
                                asset.lastModifiedBy = by
                        MERGE (asset)-[assetToAcrId:FINGERPRINTED_AS]->(acrId)
                            ON CREATE SET
                                assetToAcrId.createdAt = datetime(),
                                assetToAcrId.createdBy = by
                            SET
                                assetToAcrId.lastModifiedAt = datetime(),
                                assetToAcrId.lastModifiedBy = by
                        WITH *
                        OPTIONAL MATCH (asset)-[assetToOldAcrId:FINGERPRINTED_AS]->(oldAcrId:ACRID)
                            WHERE oldAcrId <> acrId
                        FOREACH (hasOldAcrId IN CASE WHEN oldAcrId IS NOT NULL THEN [1] ELSE [] END |
                            CREATE (asset)-[deletedRelationship:DELETED_FINGERPRINTED_AS]->(oldAcrId)
                            SET
                                deletedRelationship += assetToOldAcrId,
                                deletedRelationship.deletedAt = datetime(),
                                deletedRelationship.deletedBy = by
                            DELETE assetToOldAcrId
                        )
                        WITH DISTINCT source_asset, by, asset
                        OPTIONAL MATCH (track:Track { id: toInteger(source_asset.tuid) })
                        CALL apoc.util.validate(track IS NULL, "Could not find the track %s", [source_asset.tuid])
                        MERGE (track)-[trackHasAsset:HAS_ASSET]->(asset)
                            ON CREATE SET
                                trackHasAsset.createdAt = datetime(),
                                trackHasAsset.createdBy = by,
                                trackHasAsset.lastModifiedAt = datetime(),
                                trackHasAsset.lastModifiedBy = by
                    ',
                    {
                        batchSize: 1000
                    }
                )
                YIELD failedOperations, errorMessages, failedBatches, batch
                CALL apoc.util.validate(failedOperations > 0, "At least one sub-operation failed: %s", [reduce(all_errors = "", error IN keys(errorMessages) | all_errors + ", " + error)])
                CALL apoc.util.validate(failedBatches > 0, "At least one batch failed: %s", [reduce(all_errors = "", error IN keys(batch.errors) | all_errors + ", " + error)])
                RETURN 0
            ]]>
        </query>
        <query>
            CALL apoc.log.info("Finished acr_cloud data ingest part 153 of 169 at %s", [datetime()]);
        </query>

        <query>
            <![CDATA[
                CALL apoc.periodic.iterate(
                     "
                        WITH 'snowflake_orchard' AS url_alias,
                        '
                            SELECT * FROM facts.qa.jsonified_track_mapping ORDER BY ACR_ID ASC LIMIT 100000 OFFSET 15300000
                        '
                        AS sql
                        CALL apoc.load.jdbc(url_alias, sql)
                        YIELD row
                        return apoc.convert.fromJsonMap(row.NODE) AS row;
                    ",
                    '
                        WITH *, "database/distro-4707" AS by
                        MERGE (acrId:ACRID { id: row.acr_id })
                            ON CREATE SET
                                acrId.createdAt = datetime(),
                                acrId.createdBy = by,
                                acrId.lastModifiedAt = datetime(),
                                acrId.lastModifiedBy = by
                        MERGE (acrId)<-[acrIdToOsr:CONTAINS_FINGERPRINT]-(osr:OrchardSoundRecording)
                            ON CREATE SET
                                osr.id = apoc.create.uuid(),
                                osr.createdAt = datetime(),
                                osr.createdBy = by,
                                osr.lastModifiedAt = datetime(),
                                osr.lastModifiedBy = by,
                                acrIdToOsr.createdAt = datetime(),
                                acrIdToOsr.createdBy = by,
                                acrIdToOsr.lastModifiedAt = datetime(),
                                acrIdToOsr.lastModifiedBy = by
                        WITH *
                        UNWIND row.assets AS source_asset
                        MERGE (asset:OrchardAsset {
                            filename: source_asset.filename,
                            extension: "mp3",
                            source: "direct-delivery-db"
                        })
                            ON CREATE SET
                                asset.id = apoc.create.uuid(),
                                asset.createdAt = datetime(),
                                asset.createdBy = by,
                                asset.lastModifiedAt = datetime(),
                                asset.lastModifiedBy = by
                        MERGE (asset)-[assetToAcrId:FINGERPRINTED_AS]->(acrId)
                            ON CREATE SET
                                assetToAcrId.createdAt = datetime(),
                                assetToAcrId.createdBy = by
                            SET
                                assetToAcrId.lastModifiedAt = datetime(),
                                assetToAcrId.lastModifiedBy = by
                        WITH *
                        OPTIONAL MATCH (asset)-[assetToOldAcrId:FINGERPRINTED_AS]->(oldAcrId:ACRID)
                            WHERE oldAcrId <> acrId
                        FOREACH (hasOldAcrId IN CASE WHEN oldAcrId IS NOT NULL THEN [1] ELSE [] END |
                            CREATE (asset)-[deletedRelationship:DELETED_FINGERPRINTED_AS]->(oldAcrId)
                            SET
                                deletedRelationship += assetToOldAcrId,
                                deletedRelationship.deletedAt = datetime(),
                                deletedRelationship.deletedBy = by
                            DELETE assetToOldAcrId
                        )
                        WITH DISTINCT source_asset, by, asset
                        OPTIONAL MATCH (track:Track { id: toInteger(source_asset.tuid) })
                        CALL apoc.util.validate(track IS NULL, "Could not find the track %s", [source_asset.tuid])
                        MERGE (track)-[trackHasAsset:HAS_ASSET]->(asset)
                            ON CREATE SET
                                trackHasAsset.createdAt = datetime(),
                                trackHasAsset.createdBy = by,
                                trackHasAsset.lastModifiedAt = datetime(),
                                trackHasAsset.lastModifiedBy = by
                    ',
                    {
                        batchSize: 1000
                    }
                )
                YIELD failedOperations, errorMessages, failedBatches, batch
                CALL apoc.util.validate(failedOperations > 0, "At least one sub-operation failed: %s", [reduce(all_errors = "", error IN keys(errorMessages) | all_errors + ", " + error)])
                CALL apoc.util.validate(failedBatches > 0, "At least one batch failed: %s", [reduce(all_errors = "", error IN keys(batch.errors) | all_errors + ", " + error)])
                RETURN 0
            ]]>
        </query>
        <query>
            CALL apoc.log.info("Finished acr_cloud data ingest part 154 of 169 at %s", [datetime()]);
        </query>

        <query>
            <![CDATA[
                CALL apoc.periodic.iterate(
                     "
                        WITH 'snowflake_orchard' AS url_alias,
                        '
                            SELECT * FROM facts.qa.jsonified_track_mapping ORDER BY ACR_ID ASC LIMIT 100000 OFFSET 15400000
                        '
                        AS sql
                        CALL apoc.load.jdbc(url_alias, sql)
                        YIELD row
                        return apoc.convert.fromJsonMap(row.NODE) AS row;
                    ",
                    '
                        WITH *, "database/distro-4707" AS by
                        MERGE (acrId:ACRID { id: row.acr_id })
                            ON CREATE SET
                                acrId.createdAt = datetime(),
                                acrId.createdBy = by,
                                acrId.lastModifiedAt = datetime(),
                                acrId.lastModifiedBy = by
                        MERGE (acrId)<-[acrIdToOsr:CONTAINS_FINGERPRINT]-(osr:OrchardSoundRecording)
                            ON CREATE SET
                                osr.id = apoc.create.uuid(),
                                osr.createdAt = datetime(),
                                osr.createdBy = by,
                                osr.lastModifiedAt = datetime(),
                                osr.lastModifiedBy = by,
                                acrIdToOsr.createdAt = datetime(),
                                acrIdToOsr.createdBy = by,
                                acrIdToOsr.lastModifiedAt = datetime(),
                                acrIdToOsr.lastModifiedBy = by
                        WITH *
                        UNWIND row.assets AS source_asset
                        MERGE (asset:OrchardAsset {
                            filename: source_asset.filename,
                            extension: "mp3",
                            source: "direct-delivery-db"
                        })
                            ON CREATE SET
                                asset.id = apoc.create.uuid(),
                                asset.createdAt = datetime(),
                                asset.createdBy = by,
                                asset.lastModifiedAt = datetime(),
                                asset.lastModifiedBy = by
                        MERGE (asset)-[assetToAcrId:FINGERPRINTED_AS]->(acrId)
                            ON CREATE SET
                                assetToAcrId.createdAt = datetime(),
                                assetToAcrId.createdBy = by
                            SET
                                assetToAcrId.lastModifiedAt = datetime(),
                                assetToAcrId.lastModifiedBy = by
                        WITH *
                        OPTIONAL MATCH (asset)-[assetToOldAcrId:FINGERPRINTED_AS]->(oldAcrId:ACRID)
                            WHERE oldAcrId <> acrId
                        FOREACH (hasOldAcrId IN CASE WHEN oldAcrId IS NOT NULL THEN [1] ELSE [] END |
                            CREATE (asset)-[deletedRelationship:DELETED_FINGERPRINTED_AS]->(oldAcrId)
                            SET
                                deletedRelationship += assetToOldAcrId,
                                deletedRelationship.deletedAt = datetime(),
                                deletedRelationship.deletedBy = by
                            DELETE assetToOldAcrId
                        )
                        WITH DISTINCT source_asset, by, asset
                        OPTIONAL MATCH (track:Track { id: toInteger(source_asset.tuid) })
                        CALL apoc.util.validate(track IS NULL, "Could not find the track %s", [source_asset.tuid])
                        MERGE (track)-[trackHasAsset:HAS_ASSET]->(asset)
                            ON CREATE SET
                                trackHasAsset.createdAt = datetime(),
                                trackHasAsset.createdBy = by,
                                trackHasAsset.lastModifiedAt = datetime(),
                                trackHasAsset.lastModifiedBy = by
                    ',
                    {
                        batchSize: 1000
                    }
                )
                YIELD failedOperations, errorMessages, failedBatches, batch
                CALL apoc.util.validate(failedOperations > 0, "At least one sub-operation failed: %s", [reduce(all_errors = "", error IN keys(errorMessages) | all_errors + ", " + error)])
                CALL apoc.util.validate(failedBatches > 0, "At least one batch failed: %s", [reduce(all_errors = "", error IN keys(batch.errors) | all_errors + ", " + error)])
                RETURN 0
            ]]>
        </query>
        <query>
            CALL apoc.log.info("Finished acr_cloud data ingest part 155 of 169 at %s", [datetime()]);
        </query>

        <query>
            <![CDATA[
                CALL apoc.periodic.iterate(
                     "
                        WITH 'snowflake_orchard' AS url_alias,
                        '
                            SELECT * FROM facts.qa.jsonified_track_mapping ORDER BY ACR_ID ASC LIMIT 100000 OFFSET 15500000
                        '
                        AS sql
                        CALL apoc.load.jdbc(url_alias, sql)
                        YIELD row
                        return apoc.convert.fromJsonMap(row.NODE) AS row;
                    ",
                    '
                        WITH *, "database/distro-4707" AS by
                        MERGE (acrId:ACRID { id: row.acr_id })
                            ON CREATE SET
                                acrId.createdAt = datetime(),
                                acrId.createdBy = by,
                                acrId.lastModifiedAt = datetime(),
                                acrId.lastModifiedBy = by
                        MERGE (acrId)<-[acrIdToOsr:CONTAINS_FINGERPRINT]-(osr:OrchardSoundRecording)
                            ON CREATE SET
                                osr.id = apoc.create.uuid(),
                                osr.createdAt = datetime(),
                                osr.createdBy = by,
                                osr.lastModifiedAt = datetime(),
                                osr.lastModifiedBy = by,
                                acrIdToOsr.createdAt = datetime(),
                                acrIdToOsr.createdBy = by,
                                acrIdToOsr.lastModifiedAt = datetime(),
                                acrIdToOsr.lastModifiedBy = by
                        WITH *
                        UNWIND row.assets AS source_asset
                        MERGE (asset:OrchardAsset {
                            filename: source_asset.filename,
                            extension: "mp3",
                            source: "direct-delivery-db"
                        })
                            ON CREATE SET
                                asset.id = apoc.create.uuid(),
                                asset.createdAt = datetime(),
                                asset.createdBy = by,
                                asset.lastModifiedAt = datetime(),
                                asset.lastModifiedBy = by
                        MERGE (asset)-[assetToAcrId:FINGERPRINTED_AS]->(acrId)
                            ON CREATE SET
                                assetToAcrId.createdAt = datetime(),
                                assetToAcrId.createdBy = by
                            SET
                                assetToAcrId.lastModifiedAt = datetime(),
                                assetToAcrId.lastModifiedBy = by
                        WITH *
                        OPTIONAL MATCH (asset)-[assetToOldAcrId:FINGERPRINTED_AS]->(oldAcrId:ACRID)
                            WHERE oldAcrId <> acrId
                        FOREACH (hasOldAcrId IN CASE WHEN oldAcrId IS NOT NULL THEN [1] ELSE [] END |
                            CREATE (asset)-[deletedRelationship:DELETED_FINGERPRINTED_AS]->(oldAcrId)
                            SET
                                deletedRelationship += assetToOldAcrId,
                                deletedRelationship.deletedAt = datetime(),
                                deletedRelationship.deletedBy = by
                            DELETE assetToOldAcrId
                        )
                        WITH DISTINCT source_asset, by, asset
                        OPTIONAL MATCH (track:Track { id: toInteger(source_asset.tuid) })
                        CALL apoc.util.validate(track IS NULL, "Could not find the track %s", [source_asset.tuid])
                        MERGE (track)-[trackHasAsset:HAS_ASSET]->(asset)
                            ON CREATE SET
                                trackHasAsset.createdAt = datetime(),
                                trackHasAsset.createdBy = by,
                                trackHasAsset.lastModifiedAt = datetime(),
                                trackHasAsset.lastModifiedBy = by
                    ',
                    {
                        batchSize: 1000
                    }
                )
                YIELD failedOperations, errorMessages, failedBatches, batch
                CALL apoc.util.validate(failedOperations > 0, "At least one sub-operation failed: %s", [reduce(all_errors = "", error IN keys(errorMessages) | all_errors + ", " + error)])
                CALL apoc.util.validate(failedBatches > 0, "At least one batch failed: %s", [reduce(all_errors = "", error IN keys(batch.errors) | all_errors + ", " + error)])
                RETURN 0
            ]]>
        </query>
        <query>
            CALL apoc.log.info("Finished acr_cloud data ingest part 156 of 169 at %s", [datetime()]);
        </query>

        <query>
            <![CDATA[
                CALL apoc.periodic.iterate(
                     "
                        WITH 'snowflake_orchard' AS url_alias,
                        '
                            SELECT * FROM facts.qa.jsonified_track_mapping ORDER BY ACR_ID ASC LIMIT 100000 OFFSET 15600000
                        '
                        AS sql
                        CALL apoc.load.jdbc(url_alias, sql)
                        YIELD row
                        return apoc.convert.fromJsonMap(row.NODE) AS row;
                    ",
                    '
                        WITH *, "database/distro-4707" AS by
                        MERGE (acrId:ACRID { id: row.acr_id })
                            ON CREATE SET
                                acrId.createdAt = datetime(),
                                acrId.createdBy = by,
                                acrId.lastModifiedAt = datetime(),
                                acrId.lastModifiedBy = by
                        MERGE (acrId)<-[acrIdToOsr:CONTAINS_FINGERPRINT]-(osr:OrchardSoundRecording)
                            ON CREATE SET
                                osr.id = apoc.create.uuid(),
                                osr.createdAt = datetime(),
                                osr.createdBy = by,
                                osr.lastModifiedAt = datetime(),
                                osr.lastModifiedBy = by,
                                acrIdToOsr.createdAt = datetime(),
                                acrIdToOsr.createdBy = by,
                                acrIdToOsr.lastModifiedAt = datetime(),
                                acrIdToOsr.lastModifiedBy = by
                        WITH *
                        UNWIND row.assets AS source_asset
                        MERGE (asset:OrchardAsset {
                            filename: source_asset.filename,
                            extension: "mp3",
                            source: "direct-delivery-db"
                        })
                            ON CREATE SET
                                asset.id = apoc.create.uuid(),
                                asset.createdAt = datetime(),
                                asset.createdBy = by,
                                asset.lastModifiedAt = datetime(),
                                asset.lastModifiedBy = by
                        MERGE (asset)-[assetToAcrId:FINGERPRINTED_AS]->(acrId)
                            ON CREATE SET
                                assetToAcrId.createdAt = datetime(),
                                assetToAcrId.createdBy = by
                            SET
                                assetToAcrId.lastModifiedAt = datetime(),
                                assetToAcrId.lastModifiedBy = by
                        WITH *
                        OPTIONAL MATCH (asset)-[assetToOldAcrId:FINGERPRINTED_AS]->(oldAcrId:ACRID)
                            WHERE oldAcrId <> acrId
                        FOREACH (hasOldAcrId IN CASE WHEN oldAcrId IS NOT NULL THEN [1] ELSE [] END |
                            CREATE (asset)-[deletedRelationship:DELETED_FINGERPRINTED_AS]->(oldAcrId)
                            SET
                                deletedRelationship += assetToOldAcrId,
                                deletedRelationship.deletedAt = datetime(),
                                deletedRelationship.deletedBy = by
                            DELETE assetToOldAcrId
                        )
                        WITH DISTINCT source_asset, by, asset
                        OPTIONAL MATCH (track:Track { id: toInteger(source_asset.tuid) })
                        CALL apoc.util.validate(track IS NULL, "Could not find the track %s", [source_asset.tuid])
                        MERGE (track)-[trackHasAsset:HAS_ASSET]->(asset)
                            ON CREATE SET
                                trackHasAsset.createdAt = datetime(),
                                trackHasAsset.createdBy = by,
                                trackHasAsset.lastModifiedAt = datetime(),
                                trackHasAsset.lastModifiedBy = by
                    ',
                    {
                        batchSize: 1000
                    }
                )
                YIELD failedOperations, errorMessages, failedBatches, batch
                CALL apoc.util.validate(failedOperations > 0, "At least one sub-operation failed: %s", [reduce(all_errors = "", error IN keys(errorMessages) | all_errors + ", " + error)])
                CALL apoc.util.validate(failedBatches > 0, "At least one batch failed: %s", [reduce(all_errors = "", error IN keys(batch.errors) | all_errors + ", " + error)])
                RETURN 0
            ]]>
        </query>
        <query>
            CALL apoc.log.info("Finished acr_cloud data ingest part 157 of 169 at %s", [datetime()]);
        </query>

        <query>
            <![CDATA[
                CALL apoc.periodic.iterate(
                     "
                        WITH 'snowflake_orchard' AS url_alias,
                        '
                            SELECT * FROM facts.qa.jsonified_track_mapping ORDER BY ACR_ID ASC LIMIT 100000 OFFSET 15700000
                        '
                        AS sql
                        CALL apoc.load.jdbc(url_alias, sql)
                        YIELD row
                        return apoc.convert.fromJsonMap(row.NODE) AS row;
                    ",
                    '
                        WITH *, "database/distro-4707" AS by
                        MERGE (acrId:ACRID { id: row.acr_id })
                            ON CREATE SET
                                acrId.createdAt = datetime(),
                                acrId.createdBy = by,
                                acrId.lastModifiedAt = datetime(),
                                acrId.lastModifiedBy = by
                        MERGE (acrId)<-[acrIdToOsr:CONTAINS_FINGERPRINT]-(osr:OrchardSoundRecording)
                            ON CREATE SET
                                osr.id = apoc.create.uuid(),
                                osr.createdAt = datetime(),
                                osr.createdBy = by,
                                osr.lastModifiedAt = datetime(),
                                osr.lastModifiedBy = by,
                                acrIdToOsr.createdAt = datetime(),
                                acrIdToOsr.createdBy = by,
                                acrIdToOsr.lastModifiedAt = datetime(),
                                acrIdToOsr.lastModifiedBy = by
                        WITH *
                        UNWIND row.assets AS source_asset
                        MERGE (asset:OrchardAsset {
                            filename: source_asset.filename,
                            extension: "mp3",
                            source: "direct-delivery-db"
                        })
                            ON CREATE SET
                                asset.id = apoc.create.uuid(),
                                asset.createdAt = datetime(),
                                asset.createdBy = by,
                                asset.lastModifiedAt = datetime(),
                                asset.lastModifiedBy = by
                        MERGE (asset)-[assetToAcrId:FINGERPRINTED_AS]->(acrId)
                            ON CREATE SET
                                assetToAcrId.createdAt = datetime(),
                                assetToAcrId.createdBy = by
                            SET
                                assetToAcrId.lastModifiedAt = datetime(),
                                assetToAcrId.lastModifiedBy = by
                        WITH *
                        OPTIONAL MATCH (asset)-[assetToOldAcrId:FINGERPRINTED_AS]->(oldAcrId:ACRID)
                            WHERE oldAcrId <> acrId
                        FOREACH (hasOldAcrId IN CASE WHEN oldAcrId IS NOT NULL THEN [1] ELSE [] END |
                            CREATE (asset)-[deletedRelationship:DELETED_FINGERPRINTED_AS]->(oldAcrId)
                            SET
                                deletedRelationship += assetToOldAcrId,
                                deletedRelationship.deletedAt = datetime(),
                                deletedRelationship.deletedBy = by
                            DELETE assetToOldAcrId
                        )
                        WITH DISTINCT source_asset, by, asset
                        OPTIONAL MATCH (track:Track { id: toInteger(source_asset.tuid) })
                        CALL apoc.util.validate(track IS NULL, "Could not find the track %s", [source_asset.tuid])
                        MERGE (track)-[trackHasAsset:HAS_ASSET]->(asset)
                            ON CREATE SET
                                trackHasAsset.createdAt = datetime(),
                                trackHasAsset.createdBy = by,
                                trackHasAsset.lastModifiedAt = datetime(),
                                trackHasAsset.lastModifiedBy = by
                    ',
                    {
                        batchSize: 1000
                    }
                )
                YIELD failedOperations, errorMessages, failedBatches, batch
                CALL apoc.util.validate(failedOperations > 0, "At least one sub-operation failed: %s", [reduce(all_errors = "", error IN keys(errorMessages) | all_errors + ", " + error)])
                CALL apoc.util.validate(failedBatches > 0, "At least one batch failed: %s", [reduce(all_errors = "", error IN keys(batch.errors) | all_errors + ", " + error)])
                RETURN 0
            ]]>
        </query>
        <query>
            CALL apoc.log.info("Finished acr_cloud data ingest part 158 of 169 at %s", [datetime()]);
        </query>

        <query>
            <![CDATA[
                CALL apoc.periodic.iterate(
                     "
                        WITH 'snowflake_orchard' AS url_alias,
                        '
                            SELECT * FROM facts.qa.jsonified_track_mapping ORDER BY ACR_ID ASC LIMIT 100000 OFFSET 15800000
                        '
                        AS sql
                        CALL apoc.load.jdbc(url_alias, sql)
                        YIELD row
                        return apoc.convert.fromJsonMap(row.NODE) AS row;
                    ",
                    '
                        WITH *, "database/distro-4707" AS by
                        MERGE (acrId:ACRID { id: row.acr_id })
                            ON CREATE SET
                                acrId.createdAt = datetime(),
                                acrId.createdBy = by,
                                acrId.lastModifiedAt = datetime(),
                                acrId.lastModifiedBy = by
                        MERGE (acrId)<-[acrIdToOsr:CONTAINS_FINGERPRINT]-(osr:OrchardSoundRecording)
                            ON CREATE SET
                                osr.id = apoc.create.uuid(),
                                osr.createdAt = datetime(),
                                osr.createdBy = by,
                                osr.lastModifiedAt = datetime(),
                                osr.lastModifiedBy = by,
                                acrIdToOsr.createdAt = datetime(),
                                acrIdToOsr.createdBy = by,
                                acrIdToOsr.lastModifiedAt = datetime(),
                                acrIdToOsr.lastModifiedBy = by
                        WITH *
                        UNWIND row.assets AS source_asset
                        MERGE (asset:OrchardAsset {
                            filename: source_asset.filename,
                            extension: "mp3",
                            source: "direct-delivery-db"
                        })
                            ON CREATE SET
                                asset.id = apoc.create.uuid(),
                                asset.createdAt = datetime(),
                                asset.createdBy = by,
                                asset.lastModifiedAt = datetime(),
                                asset.lastModifiedBy = by
                        MERGE (asset)-[assetToAcrId:FINGERPRINTED_AS]->(acrId)
                            ON CREATE SET
                                assetToAcrId.createdAt = datetime(),
                                assetToAcrId.createdBy = by
                            SET
                                assetToAcrId.lastModifiedAt = datetime(),
                                assetToAcrId.lastModifiedBy = by
                        WITH *
                        OPTIONAL MATCH (asset)-[assetToOldAcrId:FINGERPRINTED_AS]->(oldAcrId:ACRID)
                            WHERE oldAcrId <> acrId
                        FOREACH (hasOldAcrId IN CASE WHEN oldAcrId IS NOT NULL THEN [1] ELSE [] END |
                            CREATE (asset)-[deletedRelationship:DELETED_FINGERPRINTED_AS]->(oldAcrId)
                            SET
                                deletedRelationship += assetToOldAcrId,
                                deletedRelationship.deletedAt = datetime(),
                                deletedRelationship.deletedBy = by
                            DELETE assetToOldAcrId
                        )
                        WITH DISTINCT source_asset, by, asset
                        OPTIONAL MATCH (track:Track { id: toInteger(source_asset.tuid) })
                        CALL apoc.util.validate(track IS NULL, "Could not find the track %s", [source_asset.tuid])
                        MERGE (track)-[trackHasAsset:HAS_ASSET]->(asset)
                            ON CREATE SET
                                trackHasAsset.createdAt = datetime(),
                                trackHasAsset.createdBy = by,
                                trackHasAsset.lastModifiedAt = datetime(),
                                trackHasAsset.lastModifiedBy = by
                    ',
                    {
                        batchSize: 1000
                    }
                )
                YIELD failedOperations, errorMessages, failedBatches, batch
                CALL apoc.util.validate(failedOperations > 0, "At least one sub-operation failed: %s", [reduce(all_errors = "", error IN keys(errorMessages) | all_errors + ", " + error)])
                CALL apoc.util.validate(failedBatches > 0, "At least one batch failed: %s", [reduce(all_errors = "", error IN keys(batch.errors) | all_errors + ", " + error)])
                RETURN 0
            ]]>
        </query>
        <query>
            CALL apoc.log.info("Finished acr_cloud data ingest part 159 of 169 at %s", [datetime()]);
        </query>

        <query>
            <![CDATA[
                CALL apoc.periodic.iterate(
                     "
                        WITH 'snowflake_orchard' AS url_alias,
                        '
                            SELECT * FROM facts.qa.jsonified_track_mapping ORDER BY ACR_ID ASC LIMIT 100000 OFFSET 15900000
                        '
                        AS sql
                        CALL apoc.load.jdbc(url_alias, sql)
                        YIELD row
                        return apoc.convert.fromJsonMap(row.NODE) AS row;
                    ",
                    '
                        WITH *, "database/distro-4707" AS by
                        MERGE (acrId:ACRID { id: row.acr_id })
                            ON CREATE SET
                                acrId.createdAt = datetime(),
                                acrId.createdBy = by,
                                acrId.lastModifiedAt = datetime(),
                                acrId.lastModifiedBy = by
                        MERGE (acrId)<-[acrIdToOsr:CONTAINS_FINGERPRINT]-(osr:OrchardSoundRecording)
                            ON CREATE SET
                                osr.id = apoc.create.uuid(),
                                osr.createdAt = datetime(),
                                osr.createdBy = by,
                                osr.lastModifiedAt = datetime(),
                                osr.lastModifiedBy = by,
                                acrIdToOsr.createdAt = datetime(),
                                acrIdToOsr.createdBy = by,
                                acrIdToOsr.lastModifiedAt = datetime(),
                                acrIdToOsr.lastModifiedBy = by
                        WITH *
                        UNWIND row.assets AS source_asset
                        MERGE (asset:OrchardAsset {
                            filename: source_asset.filename,
                            extension: "mp3",
                            source: "direct-delivery-db"
                        })
                            ON CREATE SET
                                asset.id = apoc.create.uuid(),
                                asset.createdAt = datetime(),
                                asset.createdBy = by,
                                asset.lastModifiedAt = datetime(),
                                asset.lastModifiedBy = by
                        MERGE (asset)-[assetToAcrId:FINGERPRINTED_AS]->(acrId)
                            ON CREATE SET
                                assetToAcrId.createdAt = datetime(),
                                assetToAcrId.createdBy = by
                            SET
                                assetToAcrId.lastModifiedAt = datetime(),
                                assetToAcrId.lastModifiedBy = by
                        WITH *
                        OPTIONAL MATCH (asset)-[assetToOldAcrId:FINGERPRINTED_AS]->(oldAcrId:ACRID)
                            WHERE oldAcrId <> acrId
                        FOREACH (hasOldAcrId IN CASE WHEN oldAcrId IS NOT NULL THEN [1] ELSE [] END |
                            CREATE (asset)-[deletedRelationship:DELETED_FINGERPRINTED_AS]->(oldAcrId)
                            SET
                                deletedRelationship += assetToOldAcrId,
                                deletedRelationship.deletedAt = datetime(),
                                deletedRelationship.deletedBy = by
                            DELETE assetToOldAcrId
                        )
                        WITH DISTINCT source_asset, by, asset
                        OPTIONAL MATCH (track:Track { id: toInteger(source_asset.tuid) })
                        CALL apoc.util.validate(track IS NULL, "Could not find the track %s", [source_asset.tuid])
                        MERGE (track)-[trackHasAsset:HAS_ASSET]->(asset)
                            ON CREATE SET
                                trackHasAsset.createdAt = datetime(),
                                trackHasAsset.createdBy = by,
                                trackHasAsset.lastModifiedAt = datetime(),
                                trackHasAsset.lastModifiedBy = by
                    ',
                    {
                        batchSize: 1000
                    }
                )
                YIELD failedOperations, errorMessages, failedBatches, batch
                CALL apoc.util.validate(failedOperations > 0, "At least one sub-operation failed: %s", [reduce(all_errors = "", error IN keys(errorMessages) | all_errors + ", " + error)])
                CALL apoc.util.validate(failedBatches > 0, "At least one batch failed: %s", [reduce(all_errors = "", error IN keys(batch.errors) | all_errors + ", " + error)])
                RETURN 0
            ]]>
        </query>
        <query>
            CALL apoc.log.info("Finished acr_cloud data ingest part 160 of 169 at %s", [datetime()]);
        </query>

        <query>
            <![CDATA[
                CALL apoc.periodic.iterate(
                     "
                        WITH 'snowflake_orchard' AS url_alias,
                        '
                            SELECT * FROM facts.qa.jsonified_track_mapping ORDER BY ACR_ID ASC LIMIT 100000 OFFSET 16000000
                        '
                        AS sql
                        CALL apoc.load.jdbc(url_alias, sql)
                        YIELD row
                        return apoc.convert.fromJsonMap(row.NODE) AS row;
                    ",
                    '
                        WITH *, "database/distro-4707" AS by
                        MERGE (acrId:ACRID { id: row.acr_id })
                            ON CREATE SET
                                acrId.createdAt = datetime(),
                                acrId.createdBy = by,
                                acrId.lastModifiedAt = datetime(),
                                acrId.lastModifiedBy = by
                        MERGE (acrId)<-[acrIdToOsr:CONTAINS_FINGERPRINT]-(osr:OrchardSoundRecording)
                            ON CREATE SET
                                osr.id = apoc.create.uuid(),
                                osr.createdAt = datetime(),
                                osr.createdBy = by,
                                osr.lastModifiedAt = datetime(),
                                osr.lastModifiedBy = by,
                                acrIdToOsr.createdAt = datetime(),
                                acrIdToOsr.createdBy = by,
                                acrIdToOsr.lastModifiedAt = datetime(),
                                acrIdToOsr.lastModifiedBy = by
                        WITH *
                        UNWIND row.assets AS source_asset
                        MERGE (asset:OrchardAsset {
                            filename: source_asset.filename,
                            extension: "mp3",
                            source: "direct-delivery-db"
                        })
                            ON CREATE SET
                                asset.id = apoc.create.uuid(),
                                asset.createdAt = datetime(),
                                asset.createdBy = by,
                                asset.lastModifiedAt = datetime(),
                                asset.lastModifiedBy = by
                        MERGE (asset)-[assetToAcrId:FINGERPRINTED_AS]->(acrId)
                            ON CREATE SET
                                assetToAcrId.createdAt = datetime(),
                                assetToAcrId.createdBy = by
                            SET
                                assetToAcrId.lastModifiedAt = datetime(),
                                assetToAcrId.lastModifiedBy = by
                        WITH *
                        OPTIONAL MATCH (asset)-[assetToOldAcrId:FINGERPRINTED_AS]->(oldAcrId:ACRID)
                            WHERE oldAcrId <> acrId
                        FOREACH (hasOldAcrId IN CASE WHEN oldAcrId IS NOT NULL THEN [1] ELSE [] END |
                            CREATE (asset)-[deletedRelationship:DELETED_FINGERPRINTED_AS]->(oldAcrId)
                            SET
                                deletedRelationship += assetToOldAcrId,
                                deletedRelationship.deletedAt = datetime(),
                                deletedRelationship.deletedBy = by
                            DELETE assetToOldAcrId
                        )
                        WITH DISTINCT source_asset, by, asset
                        OPTIONAL MATCH (track:Track { id: toInteger(source_asset.tuid) })
                        CALL apoc.util.validate(track IS NULL, "Could not find the track %s", [source_asset.tuid])
                        MERGE (track)-[trackHasAsset:HAS_ASSET]->(asset)
                            ON CREATE SET
                                trackHasAsset.createdAt = datetime(),
                                trackHasAsset.createdBy = by,
                                trackHasAsset.lastModifiedAt = datetime(),
                                trackHasAsset.lastModifiedBy = by
                    ',
                    {
                        batchSize: 1000
                    }
                )
                YIELD failedOperations, errorMessages, failedBatches, batch
                CALL apoc.util.validate(failedOperations > 0, "At least one sub-operation failed: %s", [reduce(all_errors = "", error IN keys(errorMessages) | all_errors + ", " + error)])
                CALL apoc.util.validate(failedBatches > 0, "At least one batch failed: %s", [reduce(all_errors = "", error IN keys(batch.errors) | all_errors + ", " + error)])
                RETURN 0
            ]]>
        </query>
        <query>
            CALL apoc.log.info("Finished acr_cloud data ingest part 161 of 169 at %s", [datetime()]);
        </query>

        <query>
            <![CDATA[
                CALL apoc.periodic.iterate(
                     "
                        WITH 'snowflake_orchard' AS url_alias,
                        '
                            SELECT * FROM facts.qa.jsonified_track_mapping ORDER BY ACR_ID ASC LIMIT 100000 OFFSET 16100000
                        '
                        AS sql
                        CALL apoc.load.jdbc(url_alias, sql)
                        YIELD row
                        return apoc.convert.fromJsonMap(row.NODE) AS row;
                    ",
                    '
                        WITH *, "database/distro-4707" AS by
                        MERGE (acrId:ACRID { id: row.acr_id })
                            ON CREATE SET
                                acrId.createdAt = datetime(),
                                acrId.createdBy = by,
                                acrId.lastModifiedAt = datetime(),
                                acrId.lastModifiedBy = by
                        MERGE (acrId)<-[acrIdToOsr:CONTAINS_FINGERPRINT]-(osr:OrchardSoundRecording)
                            ON CREATE SET
                                osr.id = apoc.create.uuid(),
                                osr.createdAt = datetime(),
                                osr.createdBy = by,
                                osr.lastModifiedAt = datetime(),
                                osr.lastModifiedBy = by,
                                acrIdToOsr.createdAt = datetime(),
                                acrIdToOsr.createdBy = by,
                                acrIdToOsr.lastModifiedAt = datetime(),
                                acrIdToOsr.lastModifiedBy = by
                        WITH *
                        UNWIND row.assets AS source_asset
                        MERGE (asset:OrchardAsset {
                            filename: source_asset.filename,
                            extension: "mp3",
                            source: "direct-delivery-db"
                        })
                            ON CREATE SET
                                asset.id = apoc.create.uuid(),
                                asset.createdAt = datetime(),
                                asset.createdBy = by,
                                asset.lastModifiedAt = datetime(),
                                asset.lastModifiedBy = by
                        MERGE (asset)-[assetToAcrId:FINGERPRINTED_AS]->(acrId)
                            ON CREATE SET
                                assetToAcrId.createdAt = datetime(),
                                assetToAcrId.createdBy = by
                            SET
                                assetToAcrId.lastModifiedAt = datetime(),
                                assetToAcrId.lastModifiedBy = by
                        WITH *
                        OPTIONAL MATCH (asset)-[assetToOldAcrId:FINGERPRINTED_AS]->(oldAcrId:ACRID)
                            WHERE oldAcrId <> acrId
                        FOREACH (hasOldAcrId IN CASE WHEN oldAcrId IS NOT NULL THEN [1] ELSE [] END |
                            CREATE (asset)-[deletedRelationship:DELETED_FINGERPRINTED_AS]->(oldAcrId)
                            SET
                                deletedRelationship += assetToOldAcrId,
                                deletedRelationship.deletedAt = datetime(),
                                deletedRelationship.deletedBy = by
                            DELETE assetToOldAcrId
                        )
                        WITH DISTINCT source_asset, by, asset
                        OPTIONAL MATCH (track:Track { id: toInteger(source_asset.tuid) })
                        CALL apoc.util.validate(track IS NULL, "Could not find the track %s", [source_asset.tuid])
                        MERGE (track)-[trackHasAsset:HAS_ASSET]->(asset)
                            ON CREATE SET
                                trackHasAsset.createdAt = datetime(),
                                trackHasAsset.createdBy = by,
                                trackHasAsset.lastModifiedAt = datetime(),
                                trackHasAsset.lastModifiedBy = by
                    ',
                    {
                        batchSize: 1000
                    }
                )
                YIELD failedOperations, errorMessages, failedBatches, batch
                CALL apoc.util.validate(failedOperations > 0, "At least one sub-operation failed: %s", [reduce(all_errors = "", error IN keys(errorMessages) | all_errors + ", " + error)])
                CALL apoc.util.validate(failedBatches > 0, "At least one batch failed: %s", [reduce(all_errors = "", error IN keys(batch.errors) | all_errors + ", " + error)])
                RETURN 0
            ]]>
        </query>
        <query>
            CALL apoc.log.info("Finished acr_cloud data ingest part 162 of 169 at %s", [datetime()]);
        </query>

        <query>
            <![CDATA[
                CALL apoc.periodic.iterate(
                     "
                        WITH 'snowflake_orchard' AS url_alias,
                        '
                            SELECT * FROM facts.qa.jsonified_track_mapping ORDER BY ACR_ID ASC LIMIT 100000 OFFSET 16200000
                        '
                        AS sql
                        CALL apoc.load.jdbc(url_alias, sql)
                        YIELD row
                        return apoc.convert.fromJsonMap(row.NODE) AS row;
                    ",
                    '
                        WITH *, "database/distro-4707" AS by
                        MERGE (acrId:ACRID { id: row.acr_id })
                            ON CREATE SET
                                acrId.createdAt = datetime(),
                                acrId.createdBy = by,
                                acrId.lastModifiedAt = datetime(),
                                acrId.lastModifiedBy = by
                        MERGE (acrId)<-[acrIdToOsr:CONTAINS_FINGERPRINT]-(osr:OrchardSoundRecording)
                            ON CREATE SET
                                osr.id = apoc.create.uuid(),
                                osr.createdAt = datetime(),
                                osr.createdBy = by,
                                osr.lastModifiedAt = datetime(),
                                osr.lastModifiedBy = by,
                                acrIdToOsr.createdAt = datetime(),
                                acrIdToOsr.createdBy = by,
                                acrIdToOsr.lastModifiedAt = datetime(),
                                acrIdToOsr.lastModifiedBy = by
                        WITH *
                        UNWIND row.assets AS source_asset
                        MERGE (asset:OrchardAsset {
                            filename: source_asset.filename,
                            extension: "mp3",
                            source: "direct-delivery-db"
                        })
                            ON CREATE SET
                                asset.id = apoc.create.uuid(),
                                asset.createdAt = datetime(),
                                asset.createdBy = by,
                                asset.lastModifiedAt = datetime(),
                                asset.lastModifiedBy = by
                        MERGE (asset)-[assetToAcrId:FINGERPRINTED_AS]->(acrId)
                            ON CREATE SET
                                assetToAcrId.createdAt = datetime(),
                                assetToAcrId.createdBy = by
                            SET
                                assetToAcrId.lastModifiedAt = datetime(),
                                assetToAcrId.lastModifiedBy = by
                        WITH *
                        OPTIONAL MATCH (asset)-[assetToOldAcrId:FINGERPRINTED_AS]->(oldAcrId:ACRID)
                            WHERE oldAcrId <> acrId
                        FOREACH (hasOldAcrId IN CASE WHEN oldAcrId IS NOT NULL THEN [1] ELSE [] END |
                            CREATE (asset)-[deletedRelationship:DELETED_FINGERPRINTED_AS]->(oldAcrId)
                            SET
                                deletedRelationship += assetToOldAcrId,
                                deletedRelationship.deletedAt = datetime(),
                                deletedRelationship.deletedBy = by
                            DELETE assetToOldAcrId
                        )
                        WITH DISTINCT source_asset, by, asset
                        OPTIONAL MATCH (track:Track { id: toInteger(source_asset.tuid) })
                        CALL apoc.util.validate(track IS NULL, "Could not find the track %s", [source_asset.tuid])
                        MERGE (track)-[trackHasAsset:HAS_ASSET]->(asset)
                            ON CREATE SET
                                trackHasAsset.createdAt = datetime(),
                                trackHasAsset.createdBy = by,
                                trackHasAsset.lastModifiedAt = datetime(),
                                trackHasAsset.lastModifiedBy = by
                    ',
                    {
                        batchSize: 1000
                    }
                )
                YIELD failedOperations, errorMessages, failedBatches, batch
                CALL apoc.util.validate(failedOperations > 0, "At least one sub-operation failed: %s", [reduce(all_errors = "", error IN keys(errorMessages) | all_errors + ", " + error)])
                CALL apoc.util.validate(failedBatches > 0, "At least one batch failed: %s", [reduce(all_errors = "", error IN keys(batch.errors) | all_errors + ", " + error)])
                RETURN 0
            ]]>
        </query>
        <query>
            CALL apoc.log.info("Finished acr_cloud data ingest part 163 of 169 at %s", [datetime()]);
        </query>

        <query>
            <![CDATA[
                CALL apoc.periodic.iterate(
                     "
                        WITH 'snowflake_orchard' AS url_alias,
                        '
                            SELECT * FROM facts.qa.jsonified_track_mapping ORDER BY ACR_ID ASC LIMIT 100000 OFFSET 16300000
                        '
                        AS sql
                        CALL apoc.load.jdbc(url_alias, sql)
                        YIELD row
                        return apoc.convert.fromJsonMap(row.NODE) AS row;
                    ",
                    '
                        WITH *, "database/distro-4707" AS by
                        MERGE (acrId:ACRID { id: row.acr_id })
                            ON CREATE SET
                                acrId.createdAt = datetime(),
                                acrId.createdBy = by,
                                acrId.lastModifiedAt = datetime(),
                                acrId.lastModifiedBy = by
                        MERGE (acrId)<-[acrIdToOsr:CONTAINS_FINGERPRINT]-(osr:OrchardSoundRecording)
                            ON CREATE SET
                                osr.id = apoc.create.uuid(),
                                osr.createdAt = datetime(),
                                osr.createdBy = by,
                                osr.lastModifiedAt = datetime(),
                                osr.lastModifiedBy = by,
                                acrIdToOsr.createdAt = datetime(),
                                acrIdToOsr.createdBy = by,
                                acrIdToOsr.lastModifiedAt = datetime(),
                                acrIdToOsr.lastModifiedBy = by
                        WITH *
                        UNWIND row.assets AS source_asset
                        MERGE (asset:OrchardAsset {
                            filename: source_asset.filename,
                            extension: "mp3",
                            source: "direct-delivery-db"
                        })
                            ON CREATE SET
                                asset.id = apoc.create.uuid(),
                                asset.createdAt = datetime(),
                                asset.createdBy = by,
                                asset.lastModifiedAt = datetime(),
                                asset.lastModifiedBy = by
                        MERGE (asset)-[assetToAcrId:FINGERPRINTED_AS]->(acrId)
                            ON CREATE SET
                                assetToAcrId.createdAt = datetime(),
                                assetToAcrId.createdBy = by
                            SET
                                assetToAcrId.lastModifiedAt = datetime(),
                                assetToAcrId.lastModifiedBy = by
                        WITH *
                        OPTIONAL MATCH (asset)-[assetToOldAcrId:FINGERPRINTED_AS]->(oldAcrId:ACRID)
                            WHERE oldAcrId <> acrId
                        FOREACH (hasOldAcrId IN CASE WHEN oldAcrId IS NOT NULL THEN [1] ELSE [] END |
                            CREATE (asset)-[deletedRelationship:DELETED_FINGERPRINTED_AS]->(oldAcrId)
                            SET
                                deletedRelationship += assetToOldAcrId,
                                deletedRelationship.deletedAt = datetime(),
                                deletedRelationship.deletedBy = by
                            DELETE assetToOldAcrId
                        )
                        WITH DISTINCT source_asset, by, asset
                        OPTIONAL MATCH (track:Track { id: toInteger(source_asset.tuid) })
                        CALL apoc.util.validate(track IS NULL, "Could not find the track %s", [source_asset.tuid])
                        MERGE (track)-[trackHasAsset:HAS_ASSET]->(asset)
                            ON CREATE SET
                                trackHasAsset.createdAt = datetime(),
                                trackHasAsset.createdBy = by,
                                trackHasAsset.lastModifiedAt = datetime(),
                                trackHasAsset.lastModifiedBy = by
                    ',
                    {
                        batchSize: 1000
                    }
                )
                YIELD failedOperations, errorMessages, failedBatches, batch
                CALL apoc.util.validate(failedOperations > 0, "At least one sub-operation failed: %s", [reduce(all_errors = "", error IN keys(errorMessages) | all_errors + ", " + error)])
                CALL apoc.util.validate(failedBatches > 0, "At least one batch failed: %s", [reduce(all_errors = "", error IN keys(batch.errors) | all_errors + ", " + error)])
                RETURN 0
            ]]>
        </query>
        <query>
            CALL apoc.log.info("Finished acr_cloud data ingest part 164 of 169 at %s", [datetime()]);
        </query>

        <query>
            <![CDATA[
                CALL apoc.periodic.iterate(
                     "
                        WITH 'snowflake_orchard' AS url_alias,
                        '
                            SELECT * FROM facts.qa.jsonified_track_mapping ORDER BY ACR_ID ASC LIMIT 100000 OFFSET 16400000
                        '
                        AS sql
                        CALL apoc.load.jdbc(url_alias, sql)
                        YIELD row
                        return apoc.convert.fromJsonMap(row.NODE) AS row;
                    ",
                    '
                        WITH *, "database/distro-4707" AS by
                        MERGE (acrId:ACRID { id: row.acr_id })
                            ON CREATE SET
                                acrId.createdAt = datetime(),
                                acrId.createdBy = by,
                                acrId.lastModifiedAt = datetime(),
                                acrId.lastModifiedBy = by
                        MERGE (acrId)<-[acrIdToOsr:CONTAINS_FINGERPRINT]-(osr:OrchardSoundRecording)
                            ON CREATE SET
                                osr.id = apoc.create.uuid(),
                                osr.createdAt = datetime(),
                                osr.createdBy = by,
                                osr.lastModifiedAt = datetime(),
                                osr.lastModifiedBy = by,
                                acrIdToOsr.createdAt = datetime(),
                                acrIdToOsr.createdBy = by,
                                acrIdToOsr.lastModifiedAt = datetime(),
                                acrIdToOsr.lastModifiedBy = by
                        WITH *
                        UNWIND row.assets AS source_asset
                        MERGE (asset:OrchardAsset {
                            filename: source_asset.filename,
                            extension: "mp3",
                            source: "direct-delivery-db"
                        })
                            ON CREATE SET
                                asset.id = apoc.create.uuid(),
                                asset.createdAt = datetime(),
                                asset.createdBy = by,
                                asset.lastModifiedAt = datetime(),
                                asset.lastModifiedBy = by
                        MERGE (asset)-[assetToAcrId:FINGERPRINTED_AS]->(acrId)
                            ON CREATE SET
                                assetToAcrId.createdAt = datetime(),
                                assetToAcrId.createdBy = by
                            SET
                                assetToAcrId.lastModifiedAt = datetime(),
                                assetToAcrId.lastModifiedBy = by
                        WITH *
                        OPTIONAL MATCH (asset)-[assetToOldAcrId:FINGERPRINTED_AS]->(oldAcrId:ACRID)
                            WHERE oldAcrId <> acrId
                        FOREACH (hasOldAcrId IN CASE WHEN oldAcrId IS NOT NULL THEN [1] ELSE [] END |
                            CREATE (asset)-[deletedRelationship:DELETED_FINGERPRINTED_AS]->(oldAcrId)
                            SET
                                deletedRelationship += assetToOldAcrId,
                                deletedRelationship.deletedAt = datetime(),
                                deletedRelationship.deletedBy = by
                            DELETE assetToOldAcrId
                        )
                        WITH DISTINCT source_asset, by, asset
                        OPTIONAL MATCH (track:Track { id: toInteger(source_asset.tuid) })
                        CALL apoc.util.validate(track IS NULL, "Could not find the track %s", [source_asset.tuid])
                        MERGE (track)-[trackHasAsset:HAS_ASSET]->(asset)
                            ON CREATE SET
                                trackHasAsset.createdAt = datetime(),
                                trackHasAsset.createdBy = by,
                                trackHasAsset.lastModifiedAt = datetime(),
                                trackHasAsset.lastModifiedBy = by
                    ',
                    {
                        batchSize: 1000
                    }
                )
                YIELD failedOperations, errorMessages, failedBatches, batch
                CALL apoc.util.validate(failedOperations > 0, "At least one sub-operation failed: %s", [reduce(all_errors = "", error IN keys(errorMessages) | all_errors + ", " + error)])
                CALL apoc.util.validate(failedBatches > 0, "At least one batch failed: %s", [reduce(all_errors = "", error IN keys(batch.errors) | all_errors + ", " + error)])
                RETURN 0
            ]]>
        </query>
        <query>
            CALL apoc.log.info("Finished acr_cloud data ingest part 165 of 169 at %s", [datetime()]);
        </query>

        <query>
            <![CDATA[
                CALL apoc.periodic.iterate(
                     "
                        WITH 'snowflake_orchard' AS url_alias,
                        '
                            SELECT * FROM facts.qa.jsonified_track_mapping ORDER BY ACR_ID ASC LIMIT 100000 OFFSET 16500000
                        '
                        AS sql
                        CALL apoc.load.jdbc(url_alias, sql)
                        YIELD row
                        return apoc.convert.fromJsonMap(row.NODE) AS row;
                    ",
                    '
                        WITH *, "database/distro-4707" AS by
                        MERGE (acrId:ACRID { id: row.acr_id })
                            ON CREATE SET
                                acrId.createdAt = datetime(),
                                acrId.createdBy = by,
                                acrId.lastModifiedAt = datetime(),
                                acrId.lastModifiedBy = by
                        MERGE (acrId)<-[acrIdToOsr:CONTAINS_FINGERPRINT]-(osr:OrchardSoundRecording)
                            ON CREATE SET
                                osr.id = apoc.create.uuid(),
                                osr.createdAt = datetime(),
                                osr.createdBy = by,
                                osr.lastModifiedAt = datetime(),
                                osr.lastModifiedBy = by,
                                acrIdToOsr.createdAt = datetime(),
                                acrIdToOsr.createdBy = by,
                                acrIdToOsr.lastModifiedAt = datetime(),
                                acrIdToOsr.lastModifiedBy = by
                        WITH *
                        UNWIND row.assets AS source_asset
                        MERGE (asset:OrchardAsset {
                            filename: source_asset.filename,
                            extension: "mp3",
                            source: "direct-delivery-db"
                        })
                            ON CREATE SET
                                asset.id = apoc.create.uuid(),
                                asset.createdAt = datetime(),
                                asset.createdBy = by,
                                asset.lastModifiedAt = datetime(),
                                asset.lastModifiedBy = by
                        MERGE (asset)-[assetToAcrId:FINGERPRINTED_AS]->(acrId)
                            ON CREATE SET
                                assetToAcrId.createdAt = datetime(),
                                assetToAcrId.createdBy = by
                            SET
                                assetToAcrId.lastModifiedAt = datetime(),
                                assetToAcrId.lastModifiedBy = by
                        WITH *
                        OPTIONAL MATCH (asset)-[assetToOldAcrId:FINGERPRINTED_AS]->(oldAcrId:ACRID)
                            WHERE oldAcrId <> acrId
                        FOREACH (hasOldAcrId IN CASE WHEN oldAcrId IS NOT NULL THEN [1] ELSE [] END |
                            CREATE (asset)-[deletedRelationship:DELETED_FINGERPRINTED_AS]->(oldAcrId)
                            SET
                                deletedRelationship += assetToOldAcrId,
                                deletedRelationship.deletedAt = datetime(),
                                deletedRelationship.deletedBy = by
                            DELETE assetToOldAcrId
                        )
                        WITH DISTINCT source_asset, by, asset
                        OPTIONAL MATCH (track:Track { id: toInteger(source_asset.tuid) })
                        CALL apoc.util.validate(track IS NULL, "Could not find the track %s", [source_asset.tuid])
                        MERGE (track)-[trackHasAsset:HAS_ASSET]->(asset)
                            ON CREATE SET
                                trackHasAsset.createdAt = datetime(),
                                trackHasAsset.createdBy = by,
                                trackHasAsset.lastModifiedAt = datetime(),
                                trackHasAsset.lastModifiedBy = by
                    ',
                    {
                        batchSize: 1000
                    }
                )
                YIELD failedOperations, errorMessages, failedBatches, batch
                CALL apoc.util.validate(failedOperations > 0, "At least one sub-operation failed: %s", [reduce(all_errors = "", error IN keys(errorMessages) | all_errors + ", " + error)])
                CALL apoc.util.validate(failedBatches > 0, "At least one batch failed: %s", [reduce(all_errors = "", error IN keys(batch.errors) | all_errors + ", " + error)])
                RETURN 0
            ]]>
        </query>
        <query>
            CALL apoc.log.info("Finished acr_cloud data ingest part 166 of 169 at %s", [datetime()]);
        </query>

        <query>
            <![CDATA[
                CALL apoc.periodic.iterate(
                     "
                        WITH 'snowflake_orchard' AS url_alias,
                        '
                            SELECT * FROM facts.qa.jsonified_track_mapping ORDER BY ACR_ID ASC LIMIT 100000 OFFSET 16600000
                        '
                        AS sql
                        CALL apoc.load.jdbc(url_alias, sql)
                        YIELD row
                        return apoc.convert.fromJsonMap(row.NODE) AS row;
                    ",
                    '
                        WITH *, "database/distro-4707" AS by
                        MERGE (acrId:ACRID { id: row.acr_id })
                            ON CREATE SET
                                acrId.createdAt = datetime(),
                                acrId.createdBy = by,
                                acrId.lastModifiedAt = datetime(),
                                acrId.lastModifiedBy = by
                        MERGE (acrId)<-[acrIdToOsr:CONTAINS_FINGERPRINT]-(osr:OrchardSoundRecording)
                            ON CREATE SET
                                osr.id = apoc.create.uuid(),
                                osr.createdAt = datetime(),
                                osr.createdBy = by,
                                osr.lastModifiedAt = datetime(),
                                osr.lastModifiedBy = by,
                                acrIdToOsr.createdAt = datetime(),
                                acrIdToOsr.createdBy = by,
                                acrIdToOsr.lastModifiedAt = datetime(),
                                acrIdToOsr.lastModifiedBy = by
                        WITH *
                        UNWIND row.assets AS source_asset
                        MERGE (asset:OrchardAsset {
                            filename: source_asset.filename,
                            extension: "mp3",
                            source: "direct-delivery-db"
                        })
                            ON CREATE SET
                                asset.id = apoc.create.uuid(),
                                asset.createdAt = datetime(),
                                asset.createdBy = by,
                                asset.lastModifiedAt = datetime(),
                                asset.lastModifiedBy = by
                        MERGE (asset)-[assetToAcrId:FINGERPRINTED_AS]->(acrId)
                            ON CREATE SET
                                assetToAcrId.createdAt = datetime(),
                                assetToAcrId.createdBy = by
                            SET
                                assetToAcrId.lastModifiedAt = datetime(),
                                assetToAcrId.lastModifiedBy = by
                        WITH *
                        OPTIONAL MATCH (asset)-[assetToOldAcrId:FINGERPRINTED_AS]->(oldAcrId:ACRID)
                            WHERE oldAcrId <> acrId
                        FOREACH (hasOldAcrId IN CASE WHEN oldAcrId IS NOT NULL THEN [1] ELSE [] END |
                            CREATE (asset)-[deletedRelationship:DELETED_FINGERPRINTED_AS]->(oldAcrId)
                            SET
                                deletedRelationship += assetToOldAcrId,
                                deletedRelationship.deletedAt = datetime(),
                                deletedRelationship.deletedBy = by
                            DELETE assetToOldAcrId
                        )
                        WITH DISTINCT source_asset, by, asset
                        OPTIONAL MATCH (track:Track { id: toInteger(source_asset.tuid) })
                        CALL apoc.util.validate(track IS NULL, "Could not find the track %s", [source_asset.tuid])
                        MERGE (track)-[trackHasAsset:HAS_ASSET]->(asset)
                            ON CREATE SET
                                trackHasAsset.createdAt = datetime(),
                                trackHasAsset.createdBy = by,
                                trackHasAsset.lastModifiedAt = datetime(),
                                trackHasAsset.lastModifiedBy = by
                    ',
                    {
                        batchSize: 1000
                    }
                )
                YIELD failedOperations, errorMessages, failedBatches, batch
                CALL apoc.util.validate(failedOperations > 0, "At least one sub-operation failed: %s", [reduce(all_errors = "", error IN keys(errorMessages) | all_errors + ", " + error)])
                CALL apoc.util.validate(failedBatches > 0, "At least one batch failed: %s", [reduce(all_errors = "", error IN keys(batch.errors) | all_errors + ", " + error)])
                RETURN 0
            ]]>
        </query>
        <query>
            CALL apoc.log.info("Finished acr_cloud data ingest part 167 of 169 at %s", [datetime()]);
        </query>

        <query>
            <![CDATA[
                CALL apoc.periodic.iterate(
                     "
                        WITH 'snowflake_orchard' AS url_alias,
                        '
                            SELECT * FROM facts.qa.jsonified_track_mapping ORDER BY ACR_ID ASC LIMIT 100000 OFFSET 16700000
                        '
                        AS sql
                        CALL apoc.load.jdbc(url_alias, sql)
                        YIELD row
                        return apoc.convert.fromJsonMap(row.NODE) AS row;
                    ",
                    '
                        WITH *, "database/distro-4707" AS by
                        MERGE (acrId:ACRID { id: row.acr_id })
                            ON CREATE SET
                                acrId.createdAt = datetime(),
                                acrId.createdBy = by,
                                acrId.lastModifiedAt = datetime(),
                                acrId.lastModifiedBy = by
                        MERGE (acrId)<-[acrIdToOsr:CONTAINS_FINGERPRINT]-(osr:OrchardSoundRecording)
                            ON CREATE SET
                                osr.id = apoc.create.uuid(),
                                osr.createdAt = datetime(),
                                osr.createdBy = by,
                                osr.lastModifiedAt = datetime(),
                                osr.lastModifiedBy = by,
                                acrIdToOsr.createdAt = datetime(),
                                acrIdToOsr.createdBy = by,
                                acrIdToOsr.lastModifiedAt = datetime(),
                                acrIdToOsr.lastModifiedBy = by
                        WITH *
                        UNWIND row.assets AS source_asset
                        MERGE (asset:OrchardAsset {
                            filename: source_asset.filename,
                            extension: "mp3",
                            source: "direct-delivery-db"
                        })
                            ON CREATE SET
                                asset.id = apoc.create.uuid(),
                                asset.createdAt = datetime(),
                                asset.createdBy = by,
                                asset.lastModifiedAt = datetime(),
                                asset.lastModifiedBy = by
                        MERGE (asset)-[assetToAcrId:FINGERPRINTED_AS]->(acrId)
                            ON CREATE SET
                                assetToAcrId.createdAt = datetime(),
                                assetToAcrId.createdBy = by
                            SET
                                assetToAcrId.lastModifiedAt = datetime(),
                                assetToAcrId.lastModifiedBy = by
                        WITH *
                        OPTIONAL MATCH (asset)-[assetToOldAcrId:FINGERPRINTED_AS]->(oldAcrId:ACRID)
                            WHERE oldAcrId <> acrId
                        FOREACH (hasOldAcrId IN CASE WHEN oldAcrId IS NOT NULL THEN [1] ELSE [] END |
                            CREATE (asset)-[deletedRelationship:DELETED_FINGERPRINTED_AS]->(oldAcrId)
                            SET
                                deletedRelationship += assetToOldAcrId,
                                deletedRelationship.deletedAt = datetime(),
                                deletedRelationship.deletedBy = by
                            DELETE assetToOldAcrId
                        )
                        WITH DISTINCT source_asset, by, asset
                        OPTIONAL MATCH (track:Track { id: toInteger(source_asset.tuid) })
                        CALL apoc.util.validate(track IS NULL, "Could not find the track %s", [source_asset.tuid])
                        MERGE (track)-[trackHasAsset:HAS_ASSET]->(asset)
                            ON CREATE SET
                                trackHasAsset.createdAt = datetime(),
                                trackHasAsset.createdBy = by,
                                trackHasAsset.lastModifiedAt = datetime(),
                                trackHasAsset.lastModifiedBy = by
                    ',
                    {
                        batchSize: 1000
                    }
                )
                YIELD failedOperations, errorMessages, failedBatches, batch
                CALL apoc.util.validate(failedOperations > 0, "At least one sub-operation failed: %s", [reduce(all_errors = "", error IN keys(errorMessages) | all_errors + ", " + error)])
                CALL apoc.util.validate(failedBatches > 0, "At least one batch failed: %s", [reduce(all_errors = "", error IN keys(batch.errors) | all_errors + ", " + error)])
                RETURN 0
            ]]>
        </query>
        <query>
            CALL apoc.log.info("Finished acr_cloud data ingest part 168 of 169 at %s", [datetime()]);
        </query>

        <query>
            <![CDATA[
                CALL apoc.periodic.iterate(
                     "
                        WITH 'snowflake_orchard' AS url_alias,
                        '
                            SELECT * FROM facts.qa.jsonified_track_mapping ORDER BY ACR_ID ASC LIMIT 100000 OFFSET 16800000
                        '
                        AS sql
                        CALL apoc.load.jdbc(url_alias, sql)
                        YIELD row
                        return apoc.convert.fromJsonMap(row.NODE) AS row;
                    ",
                    '
                        WITH *, "database/distro-4707" AS by
                        MERGE (acrId:ACRID { id: row.acr_id })
                            ON CREATE SET
                                acrId.createdAt = datetime(),
                                acrId.createdBy = by,
                                acrId.lastModifiedAt = datetime(),
                                acrId.lastModifiedBy = by
                        MERGE (acrId)<-[acrIdToOsr:CONTAINS_FINGERPRINT]-(osr:OrchardSoundRecording)
                            ON CREATE SET
                                osr.id = apoc.create.uuid(),
                                osr.createdAt = datetime(),
                                osr.createdBy = by,
                                osr.lastModifiedAt = datetime(),
                                osr.lastModifiedBy = by,
                                acrIdToOsr.createdAt = datetime(),
                                acrIdToOsr.createdBy = by,
                                acrIdToOsr.lastModifiedAt = datetime(),
                                acrIdToOsr.lastModifiedBy = by
                        WITH *
                        UNWIND row.assets AS source_asset
                        MERGE (asset:OrchardAsset {
                            filename: source_asset.filename,
                            extension: "mp3",
                            source: "direct-delivery-db"
                        })
                            ON CREATE SET
                                asset.id = apoc.create.uuid(),
                                asset.createdAt = datetime(),
                                asset.createdBy = by,
                                asset.lastModifiedAt = datetime(),
                                asset.lastModifiedBy = by
                        MERGE (asset)-[assetToAcrId:FINGERPRINTED_AS]->(acrId)
                            ON CREATE SET
                                assetToAcrId.createdAt = datetime(),
                                assetToAcrId.createdBy = by
                            SET
                                assetToAcrId.lastModifiedAt = datetime(),
                                assetToAcrId.lastModifiedBy = by
                        WITH *
                        OPTIONAL MATCH (asset)-[assetToOldAcrId:FINGERPRINTED_AS]->(oldAcrId:ACRID)
                            WHERE oldAcrId <> acrId
                        FOREACH (hasOldAcrId IN CASE WHEN oldAcrId IS NOT NULL THEN [1] ELSE [] END |
                            CREATE (asset)-[deletedRelationship:DELETED_FINGERPRINTED_AS]->(oldAcrId)
                            SET
                                deletedRelationship += assetToOldAcrId,
                                deletedRelationship.deletedAt = datetime(),
                                deletedRelationship.deletedBy = by
                            DELETE assetToOldAcrId
                        )
                        WITH DISTINCT source_asset, by, asset
                        OPTIONAL MATCH (track:Track { id: toInteger(source_asset.tuid) })
                        CALL apoc.util.validate(track IS NULL, "Could not find the track %s", [source_asset.tuid])
                        MERGE (track)-[trackHasAsset:HAS_ASSET]->(asset)
                            ON CREATE SET
                                trackHasAsset.createdAt = datetime(),
                                trackHasAsset.createdBy = by,
                                trackHasAsset.lastModifiedAt = datetime(),
                                trackHasAsset.lastModifiedBy = by
                    ',
                    {
                        batchSize: 1000
                    }
                )
                YIELD failedOperations, errorMessages, failedBatches, batch
                CALL apoc.util.validate(failedOperations > 0, "At least one sub-operation failed: %s", [reduce(all_errors = "", error IN keys(errorMessages) | all_errors + ", " + error)])
                CALL apoc.util.validate(failedBatches > 0, "At least one batch failed: %s", [reduce(all_errors = "", error IN keys(batch.errors) | all_errors + ", " + error)])
                RETURN 0
            ]]>
        </query>
        <query>
            CALL apoc.log.info("Finished acr_cloud data ingest part 169 of 169 at %s", [datetime()]);
        </query>

        <query>
            CALL apoc.log.info("Ended run of acr_data ingest at %s", [datetime()]);
        </query>
    </changeset>
</changelog>

