<?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="ARTARCH-276_backfill_missing_data:1" author="gaguirre" run-on-change="true">
        <query>
            CALL apoc.log.info("Starting run of release_artist ingest at %s", [datetime()]);
        </query>
        <query>
            CALL apoc.periodic.iterate(
                "
                    WITH 'mysql_artrelations' as url_alias,
                    '
                        SELECT ra.release_artist_id, ra.release_id, ra.artist_name, ra.role, p.vendor_id, p.subaccount_id
                        FROM release_artist ra
                        INNER JOIN releases r on ra.release_id = r.release_id
                        INNER JOIN project p on r.project_id = p.project_id
                        WHERE ra.release_id IS NOT NULL
                        AND ra.release_artist_id IN (
                            6296056,
                            6295814,
                            6295813,
                            6295497,
                            6295461,
                            6295446,
                            6295224,
                            6294993,
                            6294960,
                            6294952,
                            6294910,
                            6294886,
                            6294851,
                            6294833,
                            6294817,
                            6294793,
                            6294769,
                            6294750,
                            6294744,
                            6294728,
                            6294727,
                            6294708,
                            6294705,
                            6294691,
                            6294677
                        )
                    ' as sql
                    CALL apoc.load.jdbc(url_alias, sql)
                    YIELD row
                    RETURN row
                ",
                "
                    MERGE (ra:ReleaseArtist {id: toInteger(row.release_artist_id)})
                        SET ra.productId = toInteger(row.release_id),
                            ra.name = row.artist_name,
                            ra.role = row.role,
                            ra.updated_at = datetime()
                    MERGE (p:Product:Orchard {id: ra.productId})
                    MERGE (p)-[:HAS_SOURCE_ARTIST]->(ra)
                    MERGE (i:IncrementId {nodeName: 'LabelParticipant'})
                        ON CREATE SET i.id = 1
                        ON MATCH SET i.id = i.id + 1
                    MERGE (
                        lp:LabelParticipant:Orchard {
                            name: trim(apoc.text.regreplace(ra.name, '[ ]{2,}', ' ')),
                            vendorId: toInteger(row.vendor_id),
                            subaccountId: toInteger(row.subaccount_id)
                        }
                    )
                        ON CREATE SET
                            lp.id = i.id,
                            lp.uuid = apoc.create.uuid()
                    MERGE (lp)-[:PARTICIPATED_IN {participated_as: ra.role}]->(p)
                    MERGE (lp)-[cf:CREATED_FROM]->(ra)
                        ON CREATE SET cf.created_at = datetime()
                ",
                {batchSize:1000}
            );
        </query>
        <query>
            CALL apoc.log.info("Finished release_artist ingest at %s", [datetime()]);
        </query>
    </changeset>
    <changeset id="ARTARCH-276_backfill_missing_data:2" author="gaguirre" run-on-change="true">
        <query>
            CALL apoc.log.info("Starting run of track_artist ingest at %s", [datetime()]);
        </query>
        <query>
            CALL apoc.periodic.iterate(
                "
                    WITH 'mysql_artrelations' as url_alias,
                    '
                        SELECT id, track_id, name, type
                        FROM track_artist ta
                        WHERE track_id IS NOT NULL
                        AND ta.id IN (
                            89207498,
                            89206623,
                            89206603,
                            89206605,
                            89206607,
                            89206606,
                            89206604,
                            89205467,
                            89205360,
                            89204125,
                            89204124,
                            89203328,
                            89203329,
                            89203316,
                            89203317,
                            89203318,
                            89203314,
                            89203265,
                            89203115,
                            89203116,
                            89203114,
                            89203113,
                            89203058,
                            89203055,
                            89203059,
                            89203057,
                            89203056,
                            89203017,
                            89203016,
                            89202941,
                            89202827,
                            89202790,
                            89202667,
                            89202570,
                            89202527,
                            89202524,
                            89202518,
                            89202425,
                            89202417,
                            89202385,
                            89202372,
                            89202349,
                            89202212,
                            89202213
                        )
                        ORDER BY id
                    ' as sql
                    CALL apoc.load.jdbc(url_alias, sql)
                    YIELD row
                    RETURN row",
                "
                    MERGE (ta:TrackArtist {id: toInteger(row.id)})
                        SET ta.trackId = toInteger(row.track_id),
                            ta.name = row.name,
                            ta.type = row.type,
                            ta.updated_at = datetime()
                    WITH ta
                    MATCH (t:Track:Orchard {id: ta.trackId})
                    MATCH (p:Product:Orchard)-[:INCLUDES]->(t)
                    MATCH (pr:Project)-[:INCLUDES]->(p)
                    WHERE exists(pr.subaccountId)
                    MERGE (t)-[:HAS_SOURCE_ARTIST]->(ta)
                    MERGE (i:IncrementId {nodeName: 'LabelParticipant'})
                        ON CREATE SET i.id = 1
                        ON MATCH SET i.id = i.id + 1
                    MERGE (
                        lp:LabelParticipant:Orchard {
                            name: trim(apoc.text.regreplace(ta.name, '[ ]{2,}', ' ')),
                            vendorId: pr.vendorId,
                            subaccountId: pr.subaccountId
                        }
                    )
                        ON CREATE SET
                            lp.id = i.id,
                            lp.uuid = apoc.create.uuid()
                    MERGE (lp)-[tp:PARTICIPATED_IN {participated_as: ta.type}]->(t)
                    MERGE (lp)-[cf:CREATED_FROM]->(ta)
                        ON CREATE SET cf.created_at = datetime()
                ",
                {batchSize:1000}
            );
        </query>
        <query>
            CALL apoc.log.info("Finished track_artist ingest at %s", [datetime()]);
        </query>
    </changeset>
    <changeset id="ARTARCH-276_backfill_missing_data:3" author="gaguirre" run-on-change="true">
        <query>
            CALL apoc.log.info("Starting run of track_writer ingest at %s", [datetime()]);
        </query>
        <query>
            CALL apoc.periodic.iterate(
                "
                    WITH 'mysql_artrelations' as url_alias,
                    '
                        SELECT track_writer_id, unique_track_id, writer_name
                        FROM track_writer tw
                        WHERE unique_track_id IS NOT NULL
                        AND tw.track_writer_id IN (
                            61087698,
                            61087618,
                            61086043,
                            61086044,
                            61086038,
                            61085981,
                            61085937,
                            61085762,
                            61085669,
                            61085641,
                            61085596,
                            61085510,
                            61085476,
                            61085474,
                            61085385,
                            61085354,
                            61085327
                        )
                        ORDER BY track_writer_id
                    ' as sql
                    CALL apoc.load.jdbc(url_alias, sql)
                    YIELD row
                    RETURN row
                ",
                "
                    MERGE (tw:TrackWriter {id: toInteger(row.track_writer_id)})
                        SET tw.uniqueTrackId = toInteger(row.unique_track_id),
                            tw.writerName = row.writer_name,
                            tw.updated_at = datetime()
                    WITH tw
                    MATCH (t:Track:Orchard {id: tw.uniqueTrackId})
                    MATCH (p:Product:Orchard)-[r:INCLUDES]->(t)
                    MATCH (pr:Project)-[r1:INCLUDES]->(p)
                    WHERE exists(pr.subaccountId)
                    MERGE (t)-[:HAS_SOURCE_ARTIST]->(tw)
                    MERGE (i:IncrementId {nodeName: 'LabelParticipant'})
                        ON CREATE SET i.id = 1
                        ON MATCH SET i.id = i.id + 1
                    MERGE (
                        lp:LabelParticipant:Orchard {
                            name: trim(apoc.text.regreplace(tw.writerName, '[ ]{2,}', ' ')),
                            vendorId: pr.vendorId,
                            subaccountId: pr.subaccountId
                        }
                    )
                        ON CREATE SET
                            lp.id = i.id,
                            lp.uuid = apoc.create.uuid()
                    MERGE (lp)-[:PARTICIPATED_IN {participated_as: 'track_writer'}]->(t)
                    MERGE (lp)-[cf:CREATED_FROM]->(tw)
                        ON CREATE SET cf.created_at = datetime()
                ",
                {batchSize:1000}
            );
        </query>
        <query>
            CALL apoc.log.info("Finished track_writer ingest at %s", [datetime()]);
        </query>
    </changeset>
    <changeset id="ARTARCH-276_backfill_missing_data:4" author="gaguirre" run-on-change="true">
        <query>
            CALL apoc.log.info("Starting run of artist_info ingest at %s", [datetime()]);
        </query>
        <query>
            CALL apoc.periodic.iterate(
                "
                    WITH 'mysql_artrelations' as url_alias,
                    '
                        SELECT ai.artist_id, ai.name, ai.vendor_id
                        FROM artist_info ai
                        INNER JOIN vendor v ON ai.vendor_id = v.vendor_id
                        WHERE ai.vendor_id IS NOT NULL AND v.is_distributor != \"Y\"
                        AND ai.artist_id IN (2173927)
                    ' as sql
                    CALL apoc.load.jdbc(url_alias, sql)
                    YIELD row
                    RETURN row
                ",
                "
                    MERGE (ai:ArtistInfo {id: toInteger(row.artist_id)})
                        SET ai.name = row.name,
                            ai.vendorId = toInteger(row.vendor_id),
                            ai.updated_at = datetime()
                    MERGE (v:Vendor {id: ai.vendorId})
                    MERGE (v)-[:HAS_ARTIST]->(ai)
                    MERGE (i:IncrementId {nodeName: 'LabelParticipant'})
                        ON CREATE SET i.id = 1
                        ON MATCH SET i.id = i.id + 1
                    MERGE (lp:LabelParticipant:Orchard {
                        name: trim(apoc.text.regreplace(ai.name, '[ ]{2,}', ' ')),
                        vendorId: toInteger(ai.vendorId),
                        subaccountId: 0
                    })
                        ON CREATE SET
                            lp.id = i.id,
                            lp.uuid = apoc.create.uuid()
                    MERGE (lp)-[cf:CREATED_FROM]->(ai)
                        ON CREATE SET cf.created_at = datetime()
                ",
                {batchSize:1000}
            );
        </query>
        <query>
            CALL apoc.log.info("Finished artist_info ingest at %s", [datetime()]);
        </query>
    </changeset>
    <changeset id="ARTARCH-276_backfill_missing_data:5" author="gaguirre" run-on-change="true">
        <query>
            CALL apoc.log.info("Starting run of participant_identifier for apple ingest at %s", [datetime()]);
        </query>
        <query>
            CALL apoc.periodic.iterate(
                "
                    WITH 'mysql_artrelations' as url_alias,
                    '
                        SELECT id, vendor_id, subaccount_id, orchard_artist_name, store_id, store_artist_id
                        FROM participant_identifier pi
                        WHERE store_id = 1
                        AND pi.id IN (
                            2184996,
                            2184997,
                            2184921,
                            2184920,
                            2184845,
                            2184844,
                            2184838,
                            2184837,
                            2184827,
                            2184826,
                            2184648,
                            2184636,
                            2184627,
                            2184611,
                            2184610,
                            2184608,
                            2184609,
                            2184605,
                            2184560,
                            2184561
                        )
                    ' as sql
                    CALL apoc.load.jdbc(url_alias, sql)
                    YIELD row
                    RETURN row
                ",
                "
                    MERGE (i:IncrementId {nodeName: 'LabelParticipant'})
                        ON CREATE SET i.id = 1
                        ON MATCH SET i.id = i.id + 1
                    MERGE (
                        lp:LabelParticipant:Orchard {
                            name: trim(apoc.text.regreplace(row.orchard_artist_name, '[ ]{2,}', ' ')),
                            vendorId: toInteger(row.vendor_id),
                            subaccountId: toInteger(row.subaccount_id)
                        }
                    )
                        ON CREATE SET
                            lp.id = i.id,
                            lp.uuid = apoc.create.uuid()
                    SET lp.appleMusicId = toInteger(row.store_artist_id)
                ",
                {batchSize:1000}
            );
        </query>
        <query>
            CALL apoc.log.info("Finished participant_identifier for apple ingest at %s", [datetime()]);
        </query>
    </changeset>
    <changeset id="ARTARCH-276_backfill_missing_data:6" author="gaguirre" run-on-change="true">
        <query>
            CALL apoc.log.info("Starting run of participant_identifier for spotify ingest at %s", [datetime()]);
        </query>
        <query>
            CALL apoc.periodic.iterate(
                "
                    WITH 'mysql_artrelations' as url_alias,
                    '
                        SELECT id, vendor_id, subaccount_id, orchard_artist_name, store_id, store_artist_id
                        FROM participant_identifier pi
                        WHERE store_id = 286
                        AND pi.id IN (
                            2184996,
                            2184997,
                            2184921,
                            2184920,
                            2184845,
                            2184844,
                            2184838,
                            2184837,
                            2184827,
                            2184826,
                            2184648,
                            2184636,
                            2184627,
                            2184611,
                            2184610,
                            2184608,
                            2184609,
                            2184605,
                            2184560,
                            2184561
                        )
                    ' as sql
                    CALL apoc.load.jdbc(url_alias, sql)
                    YIELD row
                    RETURN row
                ",
                "
                    MERGE (i:IncrementId {nodeName: 'LabelParticipant'})
                        ON CREATE SET i.id = 1
                        ON MATCH SET i.id = i.id + 1
                    MERGE (
                        lp:LabelParticipant:Orchard {
                            name: trim(apoc.text.regreplace(row.orchard_artist_name, '[ ]{2,}', ' ')),
                            vendorId: toInteger(row.vendor_id),
                            subaccountId: toInteger(row.subaccount_id)
                        }
                    )
                        ON CREATE SET
                            lp.id = i.id,
                            lp.uuid = apoc.create.uuid()
                    SET lp.spotifyId = row.store_artist_id
                ",
                {batchSize:1000}
            );
        </query>
        <query>
            CALL apoc.log.info("Finished participant_identifier for spotify ingest at %s", [datetime()]);
        </query>
    </changeset>
    <changeset id="ARTARCH-276_backfill_missing_data:7" author="gaguirre" run-on-change="true">
        <query>
            CALL apoc.log.info("Starting run of creating relationships between label participant and labels at %s", [datetime()]);
        </query>
        <query>
            CALL apoc.periodic.iterate(
                "
                    MATCH (lp:LabelParticipant:Orchard) RETURN lp
                ",
                "
                    MERGE (v:Vendor {id: lp.vendorId})
                    MERGE (v)-[:HAS_LABEL_PARTICIPANT]->(lp)
                    FOREACH (hasSubAccount IN CASE WHEN NOT (lp.subaccountId = 0) THEN [1] ELSE [] END |
                        MERGE (sa:SubAccount {id: lp.subaccountId})
                        MERGE (sa)-[:HAS_LABEL_PARTICIPANT]->(lp)
                    )
                ",
                {batchSize:1000}
            );
        </query>
        <query>
            CALL apoc.log.info("Finished creating relationships between label participant and labels at %s", [datetime()]);
        </query>
    </changeset>
</changelog>
