<?xml version="1.0" encoding="UTF-8"?>
<changelog xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:noNamespaceSchemaLocation="http://www.liquigraph.org/schema/1.0/liquigraph.xsd">
    <changeset id="DISTRO-4707_acr_ingest_qa:1" author="pdumoulin" run-on-change="true">
        <query>
            CALL apoc.log.info("Starting run of acr_data ingest at %s", [datetime()]);
        </query>
        
        <query>
            CALL apoc.periodic.iterate("MATCH (n:OrchardAsset) RETURN n", "DETACH DELETE n", {batchSize:1000})
            yield batches, total
            return batches, total
        </query>

        <query>
            CALL apoc.periodic.iterate("MATCH (n:OrchardSoundRecording) RETURN n", "DETACH DELETE n", {batchSize:1000})
            yield batches, total
            return batches, total
        </query>

        <query>
            CALL apoc.periodic.iterate("MATCH (n:ACRID) RETURN n", "DETACH DELETE n", {batchSize:1000})
            yield batches, total
            return batches, total
        </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 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 106 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 106 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 106 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 106 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 106 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 106 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 106 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 106 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 106 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 106 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 106 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 106 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 106 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 106 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 106 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 106 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 106 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 106 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 106 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 106 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 106 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 106 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 106 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 106 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 106 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 106 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 106 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 106 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 106 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 106 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 106 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 106 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 106 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 106 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 106 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 106 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 106 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 106 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 106 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 106 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 106 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 106 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 106 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 106 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 106 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 106 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 106 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 106 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 106 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 106 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 106 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 106 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 106 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 106 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 106 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 106 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 106 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 106 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 106 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 106 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 106 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 106 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 106 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 106 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 106 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 106 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 106 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 106 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 106 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 106 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 106 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 106 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 106 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 106 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 106 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 106 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 106 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 106 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 106 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 106 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 106 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 106 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 106 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 106 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 106 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 106 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 106 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 106 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 106 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 106 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 106 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 106 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 106 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 106 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 106 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 106 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 106 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 106 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 106 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 106 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 106 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 106 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 106 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 106 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 106 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 106 at %s", [datetime()]);
        </query>

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

