    CREATE LOCAL TEMPORARY TABLE "dbrdf_discharge_delta_new0"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://dbpedia.org/ontology/Stream/discharge$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/Stream/discharge$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_discharge_delta_new0"(s, o) SELECT t1.o, t0.o FROM "dbrdf_discharge_delta_old0" t0, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 26955 AND ex.o = t0.o);


        -- <http://dbpedia.org/ontology/Stream/discharge$delta_new>(?X0,?Y) :- <http://dbpedia.org/ontology/Stream/discharge$delta_old>(?X0,?X1), owl:sameAs(?X1,?Y) .
        INSERT INTO "dbrdf_discharge_delta_new0"(s, o) SELECT t0.s, t1.o FROM "dbrdf_discharge_delta_old0" t0, "__triples" t1 WHERE t0.o = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 26955 AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 26955, t0.o FROM "dbrdf_discharge_delta_new0" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_discharge_delta_old0";
        INSERT INTO "dbrdf_discharge_delta_old0"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_discharge_delta_new0" t0;
        TRUNCATE TABLE "dbrdf_discharge_delta_new0";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 473
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_vicePresident_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_vicePresident_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 26956;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_vicePresident_delta_old" ON "dbrdf_vicePresident_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_vicePresident_delta_old" ON "dbrdf_vicePresident_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_vicePresident_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://dbpedia.org/ontology/vicePresident$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/vicePresident$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_vicePresident_delta_new"(s, o) SELECT t1.o, t0.o FROM "dbrdf_vicePresident_delta_old" t0, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 26956 AND ex.o = t0.o);


        -- <http://dbpedia.org/ontology/vicePresident$delta_new>(?X0,?Y) :- <http://dbpedia.org/ontology/vicePresident$delta_old>(?X0,?X1), owl:sameAs(?X1,?Y) .
        INSERT INTO "dbrdf_vicePresident_delta_new"(s, o) SELECT t0.s, t1.o FROM "dbrdf_vicePresident_delta_old" t0, "__triples" t1 WHERE t0.o = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 26956 AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 26956, t0.o FROM "dbrdf_vicePresident_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_vicePresident_delta_old";
        INSERT INTO "dbrdf_vicePresident_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_vicePresident_delta_new" t0;
        TRUNCATE TABLE "dbrdf_vicePresident_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 474
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_WomensTennisAssociationTournament_delta_old"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_WomensTennisAssociationTournament_delta_old"(s) SELECT t0.s FROM "__triples" t0 WHERE t0.p = 2 AND t0.o = 26957;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_WomensTennisAssociationTournament_delta_old" ON "dbrdf_WomensTennisAssociationTournament_delta_old"(s);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_WomensTennisAssociationTournament_delta_new"(s integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://dbpedia.org/ontology/WomensTennisAssociationTournament$delta_new>(?Y) :- <http://dbpedia.org/ontology/WomensTennisAssociationTournament$delta_old>(?X0), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_WomensTennisAssociationTournament_delta_new"(s) SELECT t1.o FROM "dbrdf_WomensTennisAssociationTournament_delta_old" t0, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 2 AND ex.o = 26957);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 2, 26957 FROM "dbrdf_WomensTennisAssociationTournament_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_WomensTennisAssociationTournament_delta_old";
        INSERT INTO "dbrdf_WomensTennisAssociationTournament_delta_old"(s) SELECT DISTINCT t0.s FROM "dbrdf_WomensTennisAssociationTournament_delta_new" t0;
        TRUNCATE TABLE "dbrdf_WomensTennisAssociationTournament_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 475
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_canton_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_canton_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 26958;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_canton_delta_old" ON "dbrdf_canton_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_canton_delta_old" ON "dbrdf_canton_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_canton_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://dbpedia.org/ontology/canton$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/canton$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_canton_delta_new"(s, o) SELECT t1.o, t0.o FROM "dbrdf_canton_delta_old" t0, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 26958 AND ex.o = t0.o);


        -- <http://dbpedia.org/ontology/canton$delta_new>(?X0,?Y) :- <http://dbpedia.org/ontology/canton$delta_old>(?X0,?X1), owl:sameAs(?X1,?Y) .
        INSERT INTO "dbrdf_canton_delta_new"(s, o) SELECT t0.s, t1.o FROM "dbrdf_canton_delta_old" t0, "__triples" t1 WHERE t0.o = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 26958 AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 26958, t0.o FROM "dbrdf_canton_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_canton_delta_old";
        INSERT INTO "dbrdf_canton_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_canton_delta_new" t0;
        TRUNCATE TABLE "dbrdf_canton_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 476
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_meshId_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_meshId_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 26959;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_meshId_delta_old" ON "dbrdf_meshId_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_meshId_delta_old" ON "dbrdf_meshId_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_meshId_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://dbpedia.org/ontology/meshId$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/meshId$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_meshId_delta_new"(s, o) SELECT t1.o, t0.o FROM "dbrdf_meshId_delta_old" t0, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 26959 AND ex.o = t0.o);


        -- <http://dbpedia.org/ontology/meshId$delta_new>(?X0,?Y) :- <http://dbpedia.org/ontology/meshId$delta_old>(?X0,?X1), owl:sameAs(?X1,?Y) .
        INSERT INTO "dbrdf_meshId_delta_new"(s, o) SELECT t0.s, t1.o FROM "dbrdf_meshId_delta_old" t0, "__triples" t1 WHERE t0.o = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 26959 AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 26959, t0.o FROM "dbrdf_meshId_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_meshId_delta_old";
        INSERT INTO "dbrdf_meshId_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_meshId_delta_new" t0;
        TRUNCATE TABLE "dbrdf_meshId_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 477
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_firstLaunchDate_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_firstLaunchDate_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 26960;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_firstLaunchDate_delta_old" ON "dbrdf_firstLaunchDate_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_firstLaunchDate_delta_old" ON "dbrdf_firstLaunchDate_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_firstLaunchDate_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://dbpedia.org/ontology/firstLaunchDate$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/firstLaunchDate$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_firstLaunchDate_delta_new"(s, o) SELECT t1.o, t0.o FROM "dbrdf_firstLaunchDate_delta_old" t0, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 26960 AND ex.o = t0.o);


        -- <http://dbpedia.org/ontology/firstLaunchDate$delta_new>(?X0,?Y) :- <http://dbpedia.org/ontology/firstLaunchDate$delta_old>(?X0,?X1), owl:sameAs(?X1,?Y) .
        INSERT INTO "dbrdf_firstLaunchDate_delta_new"(s, o) SELECT t0.s, t1.o FROM "dbrdf_firstLaunchDate_delta_old" t0, "__triples" t1 WHERE t0.o = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 26960 AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 26960, t0.o FROM "dbrdf_firstLaunchDate_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_firstLaunchDate_delta_old";
        INSERT INTO "dbrdf_firstLaunchDate_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_firstLaunchDate_delta_new" t0;
        TRUNCATE TABLE "dbrdf_firstLaunchDate_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 478
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_muteCharacterInPlay_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_muteCharacterInPlay_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 26961;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_muteCharacterInPlay_delta_old" ON "dbrdf_muteCharacterInPlay_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_muteCharacterInPlay_delta_old" ON "dbrdf_muteCharacterInPlay_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_muteCharacterInPlay_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://dbpedia.org/ontology/muteCharacterInPlay$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/muteCharacterInPlay$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_muteCharacterInPlay_delta_new"(s, o) SELECT t1.o, t0.o FROM "dbrdf_muteCharacterInPlay_delta_old" t0, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 26961 AND ex.o = t0.o);


        -- <http://dbpedia.org/ontology/muteCharacterInPlay$delta_new>(?X0,?Y) :- <http://dbpedia.org/ontology/muteCharacterInPlay$delta_old>(?X0,?X1), owl:sameAs(?X1,?Y) .
        INSERT INTO "dbrdf_muteCharacterInPlay_delta_new"(s, o) SELECT t0.s, t1.o FROM "dbrdf_muteCharacterInPlay_delta_old" t0, "__triples" t1 WHERE t0.o = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 26961 AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 26961, t0.o FROM "dbrdf_muteCharacterInPlay_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_muteCharacterInPlay_delta_old";
        INSERT INTO "dbrdf_muteCharacterInPlay_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_muteCharacterInPlay_delta_new" t0;
        TRUNCATE TABLE "dbrdf_muteCharacterInPlay_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 479
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_populationTotalReference_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_populationTotalReference_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 26962;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_populationTotalReference_delta_old" ON "dbrdf_populationTotalReference_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_populationTotalReference_delta_old" ON "dbrdf_populationTotalReference_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_populationTotalReference_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://dbpedia.org/ontology/populationTotalReference$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/populationTotalReference$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_populationTotalReference_delta_new"(s, o) SELECT t1.o, t0.o FROM "dbrdf_populationTotalReference_delta_old" t0, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 26962 AND ex.o = t0.o);


        -- <http://dbpedia.org/ontology/populationTotalReference$delta_new>(?X0,?Y) :- <http://dbpedia.org/ontology/populationTotalReference$delta_old>(?X0,?X1), owl:sameAs(?X1,?Y) .
        INSERT INTO "dbrdf_populationTotalReference_delta_new"(s, o) SELECT t0.s, t1.o FROM "dbrdf_populationTotalReference_delta_old" t0, "__triples" t1 WHERE t0.o = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 26962 AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 26962, t0.o FROM "dbrdf_populationTotalReference_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_populationTotalReference_delta_old";
        INSERT INTO "dbrdf_populationTotalReference_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_populationTotalReference_delta_new" t0;
        TRUNCATE TABLE "dbrdf_populationTotalReference_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 480
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_voice_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_voice_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 26963;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_voice_delta_old" ON "dbrdf_voice_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_voice_delta_old" ON "dbrdf_voice_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_voice_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://dbpedia.org/ontology/voice$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/voice$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_voice_delta_new"(s, o) SELECT t1.o, t0.o FROM "dbrdf_voice_delta_old" t0, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 26963 AND ex.o = t0.o);


        -- <http://dbpedia.org/ontology/voice$delta_new>(?X0,?Y) :- <http://dbpedia.org/ontology/voice$delta_old>(?X0,?X1), owl:sameAs(?X1,?Y) .
        INSERT INTO "dbrdf_voice_delta_new"(s, o) SELECT t0.s, t1.o FROM "dbrdf_voice_delta_old" t0, "__triples" t1 WHERE t0.o = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 26963 AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 26963, t0.o FROM "dbrdf_voice_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_voice_delta_old";
        INSERT INTO "dbrdf_voice_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_voice_delta_new" t0;
        TRUNCATE TABLE "dbrdf_voice_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 481
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_surfaceFormOccurrenceOffset_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_surfaceFormOccurrenceOffset_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 26964;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_surfaceFormOccurrenceOffset_delta_old" ON "dbrdf_surfaceFormOccurrenceOffset_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_surfaceFormOccurrenceOffset_delta_old" ON "dbrdf_surfaceFormOccurrenceOffset_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_surfaceFormOccurrenceOffset_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://dbpedia.org/ontology/surfaceFormOccurrenceOffset$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/surfaceFormOccurrenceOffset$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_surfaceFormOccurrenceOffset_delta_new"(s, o) SELECT t1.o, t0.o FROM "dbrdf_surfaceFormOccurrenceOffset_delta_old" t0, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 26964 AND ex.o = t0.o);


        -- <http://dbpedia.org/ontology/surfaceFormOccurrenceOffset$delta_new>(?X0,?Y) :- <http://dbpedia.org/ontology/surfaceFormOccurrenceOffset$delta_old>(?X0,?X1), owl:sameAs(?X1,?Y) .
        INSERT INTO "dbrdf_surfaceFormOccurrenceOffset_delta_new"(s, o) SELECT t0.s, t1.o FROM "dbrdf_surfaceFormOccurrenceOffset_delta_old" t0, "__triples" t1 WHERE t0.o = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 26964 AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 26964, t0.o FROM "dbrdf_surfaceFormOccurrenceOffset_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_surfaceFormOccurrenceOffset_delta_old";
        INSERT INTO "dbrdf_surfaceFormOccurrenceOffset_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_surfaceFormOccurrenceOffset_delta_new" t0;
        TRUNCATE TABLE "dbrdf_surfaceFormOccurrenceOffset_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 482
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_heightAboveAverageTerrain_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_heightAboveAverageTerrain_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 26965;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_heightAboveAverageTerrain_delta_old" ON "dbrdf_heightAboveAverageTerrain_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_heightAboveAverageTerrain_delta_old" ON "dbrdf_heightAboveAverageTerrain_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_heightAboveAverageTerrain_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://dbpedia.org/ontology/heightAboveAverageTerrain$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/heightAboveAverageTerrain$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_heightAboveAverageTerrain_delta_new"(s, o) SELECT t1.o, t0.o FROM "dbrdf_heightAboveAverageTerrain_delta_old" t0, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 26965 AND ex.o = t0.o);


        -- <http://dbpedia.org/ontology/heightAboveAverageTerrain$delta_new>(?X0,?Y) :- <http://dbpedia.org/ontology/heightAboveAverageTerrain$delta_old>(?X0,?X1), owl:sameAs(?X1,?Y) .
        INSERT INTO "dbrdf_heightAboveAverageTerrain_delta_new"(s, o) SELECT t0.s, t1.o FROM "dbrdf_heightAboveAverageTerrain_delta_old" t0, "__triples" t1 WHERE t0.o = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 26965 AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 26965, t0.o FROM "dbrdf_heightAboveAverageTerrain_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_heightAboveAverageTerrain_delta_old";
        INSERT INTO "dbrdf_heightAboveAverageTerrain_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_heightAboveAverageTerrain_delta_new" t0;
        TRUNCATE TABLE "dbrdf_heightAboveAverageTerrain_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 483
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_sourceConfluenceElevation_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_sourceConfluenceElevation_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 26966;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_sourceConfluenceElevation_delta_old" ON "dbrdf_sourceConfluenceElevation_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_sourceConfluenceElevation_delta_old" ON "dbrdf_sourceConfluenceElevation_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_sourceConfluenceElevation_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://dbpedia.org/ontology/sourceConfluenceElevation$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/sourceConfluenceElevation$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_sourceConfluenceElevation_delta_new"(s, o) SELECT t1.o, t0.o FROM "dbrdf_sourceConfluenceElevation_delta_old" t0, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 26966 AND ex.o = t0.o);


        -- <http://dbpedia.org/ontology/sourceConfluenceElevation$delta_new>(?X0,?Y) :- <http://dbpedia.org/ontology/sourceConfluenceElevation$delta_old>(?X0,?X1), owl:sameAs(?X1,?Y) .
        INSERT INTO "dbrdf_sourceConfluenceElevation_delta_new"(s, o) SELECT t0.s, t1.o FROM "dbrdf_sourceConfluenceElevation_delta_old" t0, "__triples" t1 WHERE t0.o = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 26966 AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 26966, t0.o FROM "dbrdf_sourceConfluenceElevation_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_sourceConfluenceElevation_delta_old";
        INSERT INTO "dbrdf_sourceConfluenceElevation_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_sourceConfluenceElevation_delta_new" t0;
        TRUNCATE TABLE "dbrdf_sourceConfluenceElevation_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 484
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_populationRural_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_populationRural_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 26967;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_populationRural_delta_old" ON "dbrdf_populationRural_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_populationRural_delta_old" ON "dbrdf_populationRural_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_populationRural_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://dbpedia.org/ontology/populationRural$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/populationRural$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_populationRural_delta_new"(s, o) SELECT t1.o, t0.o FROM "dbrdf_populationRural_delta_old" t0, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 26967 AND ex.o = t0.o);


        -- <http://dbpedia.org/ontology/populationRural$delta_new>(?X0,?Y) :- <http://dbpedia.org/ontology/populationRural$delta_old>(?X0,?X1), owl:sameAs(?X1,?Y) .
        INSERT INTO "dbrdf_populationRural_delta_new"(s, o) SELECT t0.s, t1.o FROM "dbrdf_populationRural_delta_old" t0, "__triples" t1 WHERE t0.o = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 26967 AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 26967, t0.o FROM "dbrdf_populationRural_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_populationRural_delta_old";
        INSERT INTO "dbrdf_populationRural_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_populationRural_delta_new" t0;
        TRUNCATE TABLE "dbrdf_populationRural_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 485
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_musicalArtist_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_musicalArtist_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 26968;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_musicalArtist_delta_old" ON "dbrdf_musicalArtist_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_musicalArtist_delta_old" ON "dbrdf_musicalArtist_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_musicalArtist_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://dbpedia.org/ontology/musicalArtist$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/musicalArtist$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_musicalArtist_delta_new"(s, o) SELECT t1.o, t0.o FROM "dbrdf_musicalArtist_delta_old" t0, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 26968 AND ex.o = t0.o);


        -- <http://dbpedia.org/ontology/musicalArtist$delta_new>(?X0,?Y) :- <http://dbpedia.org/ontology/musicalArtist$delta_old>(?X0,?X1), owl:sameAs(?X1,?Y) .
        INSERT INTO "dbrdf_musicalArtist_delta_new"(s, o) SELECT t0.s, t1.o FROM "dbrdf_musicalArtist_delta_old" t0, "__triples" t1 WHERE t0.o = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 26968 AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 26968, t0.o FROM "dbrdf_musicalArtist_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_musicalArtist_delta_old";
        INSERT INTO "dbrdf_musicalArtist_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_musicalArtist_delta_new" t0;
        TRUNCATE TABLE "dbrdf_musicalArtist_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 486
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_assets_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_assets_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 26969;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_assets_delta_old" ON "dbrdf_assets_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_assets_delta_old" ON "dbrdf_assets_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_assets_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://dbpedia.org/ontology/assets$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/assets$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_assets_delta_new"(s, o) SELECT t1.o, t0.o FROM "dbrdf_assets_delta_old" t0, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 26969 AND ex.o = t0.o);


        -- <http://dbpedia.org/ontology/assets$delta_new>(?X0,?Y) :- <http://dbpedia.org/ontology/assets$delta_old>(?X0,?X1), owl:sameAs(?X1,?Y) .
        INSERT INTO "dbrdf_assets_delta_new"(s, o) SELECT t0.s, t1.o FROM "dbrdf_assets_delta_old" t0, "__triples" t1 WHERE t0.o = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 26969 AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 26969, t0.o FROM "dbrdf_assets_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_assets_delta_old";
        INSERT INTO "dbrdf_assets_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_assets_delta_new" t0;
        TRUNCATE TABLE "dbrdf_assets_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 487
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_width_delta_old0"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_width_delta_old0"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 26970;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_width_delta_old0" ON "dbrdf_width_delta_old0"(s, o); CREATE INDEX "IDX_1_dbrdf_width_delta_old0" ON "dbrdf_width_delta_old0"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_width_delta_new0"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://dbpedia.org/ontology/Weapon/width$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/Weapon/width$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_width_delta_new0"(s, o) SELECT t1.o, t0.o FROM "dbrdf_width_delta_old0" t0, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 26970 AND ex.o = t0.o);


        -- <http://dbpedia.org/ontology/Weapon/width$delta_new>(?X0,?Y) :- <http://dbpedia.org/ontology/Weapon/width$delta_old>(?X0,?X1), owl:sameAs(?X1,?Y) .
        INSERT INTO "dbrdf_width_delta_new0"(s, o) SELECT t0.s, t1.o FROM "dbrdf_width_delta_old0" t0, "__triples" t1 WHERE t0.o = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 26970 AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 26970, t0.o FROM "dbrdf_width_delta_new0" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_width_delta_old0";
        INSERT INTO "dbrdf_width_delta_old0"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_width_delta_new0" t0;
        TRUNCATE TABLE "dbrdf_width_delta_new0";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 488
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_cylinderBore_delta_old0"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_cylinderBore_delta_old0"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 26971;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_cylinderBore_delta_old0" ON "dbrdf_cylinderBore_delta_old0"(s, o); CREATE INDEX "IDX_1_dbrdf_cylinderBore_delta_old0" ON "dbrdf_cylinderBore_delta_old0"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_cylinderBore_delta_new0"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://dbpedia.org/ontology/cylinderBore$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/cylinderBore$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_cylinderBore_delta_new0"(s, o) SELECT t1.o, t0.o FROM "dbrdf_cylinderBore_delta_old0" t0, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 26971 AND ex.o = t0.o);


        -- <http://dbpedia.org/ontology/cylinderBore$delta_new>(?X0,?Y) :- <http://dbpedia.org/ontology/cylinderBore$delta_old>(?X0,?X1), owl:sameAs(?X1,?Y) .
        INSERT INTO "dbrdf_cylinderBore_delta_new0"(s, o) SELECT t0.s, t1.o FROM "dbrdf_cylinderBore_delta_old0" t0, "__triples" t1 WHERE t0.o = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 26971 AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 26971, t0.o FROM "dbrdf_cylinderBore_delta_new0" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_cylinderBore_delta_old0";
        INSERT INTO "dbrdf_cylinderBore_delta_old0"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_cylinderBore_delta_new0" t0;
        TRUNCATE TABLE "dbrdf_cylinderBore_delta_new0";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 489
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_politicalPartyOfLeader_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_politicalPartyOfLeader_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 26972;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_politicalPartyOfLeader_delta_old" ON "dbrdf_politicalPartyOfLeader_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_politicalPartyOfLeader_delta_old" ON "dbrdf_politicalPartyOfLeader_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_politicalPartyOfLeader_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://dbpedia.org/ontology/politicalPartyOfLeader$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/politicalPartyOfLeader$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_politicalPartyOfLeader_delta_new"(s, o) SELECT t1.o, t0.o FROM "dbrdf_politicalPartyOfLeader_delta_old" t0, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 26972 AND ex.o = t0.o);


        -- <http://dbpedia.org/ontology/politicalPartyOfLeader$delta_new>(?X0,?Y) :- <http://dbpedia.org/ontology/politicalPartyOfLeader$delta_old>(?X0,?X1), owl:sameAs(?X1,?Y) .
        INSERT INTO "dbrdf_politicalPartyOfLeader_delta_new"(s, o) SELECT t0.s, t1.o FROM "dbrdf_politicalPartyOfLeader_delta_old" t0, "__triples" t1 WHERE t0.o = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 26972 AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 26972, t0.o FROM "dbrdf_politicalPartyOfLeader_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_politicalPartyOfLeader_delta_old";
        INSERT INTO "dbrdf_politicalPartyOfLeader_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_politicalPartyOfLeader_delta_new" t0;
        TRUNCATE TABLE "dbrdf_politicalPartyOfLeader_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 490
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_Mayor_delta_old"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_Mayor_delta_old"(s) SELECT t0.s FROM "__triples" t0 WHERE t0.p = 2 AND t0.o = 26973;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_Mayor_delta_old" ON "dbrdf_Mayor_delta_old"(s);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_Mayor_delta_new"(s integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://dbpedia.org/ontology/Mayor$delta_new>(?Y) :- <http://dbpedia.org/ontology/Mayor$delta_old>(?X0), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_Mayor_delta_new"(s) SELECT t1.o FROM "dbrdf_Mayor_delta_old" t0, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 2 AND ex.o = 26973);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 2, 26973 FROM "dbrdf_Mayor_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_Mayor_delta_old";
        INSERT INTO "dbrdf_Mayor_delta_old"(s) SELECT DISTINCT t0.s FROM "dbrdf_Mayor_delta_new" t0;
        TRUNCATE TABLE "dbrdf_Mayor_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 491
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_currentStatus_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_currentStatus_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 26974;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_currentStatus_delta_old" ON "dbrdf_currentStatus_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_currentStatus_delta_old" ON "dbrdf_currentStatus_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_currentStatus_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://dbpedia.org/ontology/currentStatus$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/currentStatus$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_currentStatus_delta_new"(s, o) SELECT t1.o, t0.o FROM "dbrdf_currentStatus_delta_old" t0, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 26974 AND ex.o = t0.o);


        -- <http://dbpedia.org/ontology/currentStatus$delta_new>(?X0,?Y) :- <http://dbpedia.org/ontology/currentStatus$delta_old>(?X0,?X1), owl:sameAs(?X1,?Y) .
        INSERT INTO "dbrdf_currentStatus_delta_new"(s, o) SELECT t0.s, t1.o FROM "dbrdf_currentStatus_delta_old" t0, "__triples" t1 WHERE t0.o = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 26974 AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 26974, t0.o FROM "dbrdf_currentStatus_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_currentStatus_delta_old";
        INSERT INTO "dbrdf_currentStatus_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_currentStatus_delta_new" t0;
        TRUNCATE TABLE "dbrdf_currentStatus_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 492
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_militaryCommand_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_militaryCommand_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 26975;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_militaryCommand_delta_old" ON "dbrdf_militaryCommand_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_militaryCommand_delta_old" ON "dbrdf_militaryCommand_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_militaryCommand_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://dbpedia.org/ontology/militaryCommand$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/militaryCommand$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_militaryCommand_delta_new"(s, o) SELECT t1.o, t0.o FROM "dbrdf_militaryCommand_delta_old" t0, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 26975 AND ex.o = t0.o);


        -- <http://dbpedia.org/ontology/militaryCommand$delta_new>(?X0,?Y) :- <http://dbpedia.org/ontology/militaryCommand$delta_old>(?X0,?X1), owl:sameAs(?X1,?Y) .
        INSERT INTO "dbrdf_militaryCommand_delta_new"(s, o) SELECT t0.s, t1.o FROM "dbrdf_militaryCommand_delta_old" t0, "__triples" t1 WHERE t0.o = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 26975 AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 26975, t0.o FROM "dbrdf_militaryCommand_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_militaryCommand_delta_old";
        INSERT INTO "dbrdf_militaryCommand_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_militaryCommand_delta_new" t0;
        TRUNCATE TABLE "dbrdf_militaryCommand_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 493
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_broadcastRepeater_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_broadcastRepeater_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 26976;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_broadcastRepeater_delta_old" ON "dbrdf_broadcastRepeater_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_broadcastRepeater_delta_old" ON "dbrdf_broadcastRepeater_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_broadcastRepeater_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://dbpedia.org/ontology/broadcastRepeater$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/broadcastRepeater$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_broadcastRepeater_delta_new"(s, o) SELECT t1.o, t0.o FROM "dbrdf_broadcastRepeater_delta_old" t0, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 26976 AND ex.o = t0.o);


        -- <http://dbpedia.org/ontology/broadcastRepeater$delta_new>(?X0,?Y) :- <http://dbpedia.org/ontology/broadcastRepeater$delta_old>(?X0,?X1), owl:sameAs(?X1,?Y) .
        INSERT INTO "dbrdf_broadcastRepeater_delta_new"(s, o) SELECT t0.s, t1.o FROM "dbrdf_broadcastRepeater_delta_old" t0, "__triples" t1 WHERE t0.o = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 26976 AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 26976, t0.o FROM "dbrdf_broadcastRepeater_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_broadcastRepeater_delta_old";
        INSERT INTO "dbrdf_broadcastRepeater_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_broadcastRepeater_delta_new" t0;
        TRUNCATE TABLE "dbrdf_broadcastRepeater_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 494
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_Muscle_delta_old"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_Muscle_delta_old"(s) SELECT t0.s FROM "__triples" t0 WHERE t0.p = 2 AND t0.o = 26977;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_Muscle_delta_old" ON "dbrdf_Muscle_delta_old"(s);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_Muscle_delta_new"(s integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://dbpedia.org/ontology/Muscle$delta_new>(?Y) :- <http://dbpedia.org/ontology/Muscle$delta_old>(?X0), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_Muscle_delta_new"(s) SELECT t1.o FROM "dbrdf_Muscle_delta_old" t0, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 2 AND ex.o = 26977);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 2, 26977 FROM "dbrdf_Muscle_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_Muscle_delta_old";
        INSERT INTO "dbrdf_Muscle_delta_old"(s) SELECT DISTINCT t0.s FROM "dbrdf_Muscle_delta_new" t0;
        TRUNCATE TABLE "dbrdf_Muscle_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 495
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_runtime_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_runtime_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 26978;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_runtime_delta_old" ON "dbrdf_runtime_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_runtime_delta_old" ON "dbrdf_runtime_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_runtime_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://dbpedia.org/ontology/Work/runtime$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/Work/runtime$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_runtime_delta_new"(s, o) SELECT t1.o, t0.o FROM "dbrdf_runtime_delta_old" t0, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 26978 AND ex.o = t0.o);


        -- <http://dbpedia.org/ontology/Work/runtime$delta_new>(?X0,?Y) :- <http://dbpedia.org/ontology/Work/runtime$delta_old>(?X0,?X1), owl:sameAs(?X1,?Y) .
        INSERT INTO "dbrdf_runtime_delta_new"(s, o) SELECT t0.s, t1.o FROM "dbrdf_runtime_delta_old" t0, "__triples" t1 WHERE t0.o = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 26978 AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 26978, t0.o FROM "dbrdf_runtime_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_runtime_delta_old";
        INSERT INTO "dbrdf_runtime_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_runtime_delta_new" t0;
        TRUNCATE TABLE "dbrdf_runtime_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 496
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_olympicOathSwornByJudge_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_olympicOathSwornByJudge_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 26979;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_olympicOathSwornByJudge_delta_old" ON "dbrdf_olympicOathSwornByJudge_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_olympicOathSwornByJudge_delta_old" ON "dbrdf_olympicOathSwornByJudge_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_olympicOathSwornByJudge_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://dbpedia.org/ontology/olympicOathSwornByJudge$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/olympicOathSwornByJudge$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_olympicOathSwornByJudge_delta_new"(s, o) SELECT t1.o, t0.o FROM "dbrdf_olympicOathSwornByJudge_delta_old" t0, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 26979 AND ex.o = t0.o);


        -- <http://dbpedia.org/ontology/olympicOathSwornByJudge$delta_new>(?X0,?Y) :- <http://dbpedia.org/ontology/olympicOathSwornByJudge$delta_old>(?X0,?X1), owl:sameAs(?X1,?Y) .
        INSERT INTO "dbrdf_olympicOathSwornByJudge_delta_new"(s, o) SELECT t0.s, t1.o FROM "dbrdf_olympicOathSwornByJudge_delta_old" t0, "__triples" t1 WHERE t0.o = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 26979 AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 26979, t0.o FROM "dbrdf_olympicOathSwornByJudge_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_olympicOathSwornByJudge_delta_old";
        INSERT INTO "dbrdf_olympicOathSwornByJudge_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_olympicOathSwornByJudge_delta_new" t0;
        TRUNCATE TABLE "dbrdf_olympicOathSwornByJudge_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 497
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_personFunction_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_personFunction_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 26980;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_personFunction_delta_old" ON "dbrdf_personFunction_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_personFunction_delta_old" ON "dbrdf_personFunction_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_personFunction_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://dbpedia.org/ontology/personFunction$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/personFunction$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_personFunction_delta_new"(s, o) SELECT t1.o, t0.o FROM "dbrdf_personFunction_delta_old" t0, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 26980 AND ex.o = t0.o);


        -- <http://dbpedia.org/ontology/personFunction$delta_new>(?X0,?Y) :- <http://dbpedia.org/ontology/personFunction$delta_old>(?X0,?X1), owl:sameAs(?X1,?Y) .
        INSERT INTO "dbrdf_personFunction_delta_new"(s, o) SELECT t0.s, t1.o FROM "dbrdf_personFunction_delta_old" t0, "__triples" t1 WHERE t0.o = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 26980 AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 26980, t0.o FROM "dbrdf_personFunction_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_personFunction_delta_old";
        INSERT INTO "dbrdf_personFunction_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_personFunction_delta_new" t0;
        TRUNCATE TABLE "dbrdf_personFunction_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 498
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_podiums_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_podiums_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 26981;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_podiums_delta_old" ON "dbrdf_podiums_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_podiums_delta_old" ON "dbrdf_podiums_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_podiums_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://dbpedia.org/ontology/podiums$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/podiums$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_podiums_delta_new"(s, o) SELECT t1.o, t0.o FROM "dbrdf_podiums_delta_old" t0, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 26981 AND ex.o = t0.o);


        -- <http://dbpedia.org/ontology/podiums$delta_new>(?X0,?Y) :- <http://dbpedia.org/ontology/podiums$delta_old>(?X0,?X1), owl:sameAs(?X1,?Y) .
        INSERT INTO "dbrdf_podiums_delta_new"(s, o) SELECT t0.s, t1.o FROM "dbrdf_podiums_delta_old" t0, "__triples" t1 WHERE t0.o = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 26981 AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 26981, t0.o FROM "dbrdf_podiums_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_podiums_delta_old";
        INSERT INTO "dbrdf_podiums_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_podiums_delta_new" t0;
        TRUNCATE TABLE "dbrdf_podiums_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 499
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_languageRegulator_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_languageRegulator_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 26982;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_languageRegulator_delta_old" ON "dbrdf_languageRegulator_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_languageRegulator_delta_old" ON "dbrdf_languageRegulator_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_languageRegulator_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://dbpedia.org/ontology/languageRegulator$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/languageRegulator$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_languageRegulator_delta_new"(s, o) SELECT t1.o, t0.o FROM "dbrdf_languageRegulator_delta_old" t0, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 26982 AND ex.o = t0.o);


        -- <http://dbpedia.org/ontology/languageRegulator$delta_new>(?X0,?Y) :- <http://dbpedia.org/ontology/languageRegulator$delta_old>(?X0,?X1), owl:sameAs(?X1,?Y) .
        INSERT INTO "dbrdf_languageRegulator_delta_new"(s, o) SELECT t0.s, t1.o FROM "dbrdf_languageRegulator_delta_old" t0, "__triples" t1 WHERE t0.o = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 26982 AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 26982, t0.o FROM "dbrdf_languageRegulator_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_languageRegulator_delta_old";
        INSERT INTO "dbrdf_languageRegulator_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_languageRegulator_delta_new" t0;
        TRUNCATE TABLE "dbrdf_languageRegulator_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 500
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_areaTotal_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_areaTotal_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 26983;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_areaTotal_delta_old" ON "dbrdf_areaTotal_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_areaTotal_delta_old" ON "dbrdf_areaTotal_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_areaTotal_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://dbpedia.org/ontology/areaTotal$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/areaTotal$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_areaTotal_delta_new"(s, o) SELECT t1.o, t0.o FROM "dbrdf_areaTotal_delta_old" t0, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 26983 AND ex.o = t0.o);


        -- <http://dbpedia.org/ontology/areaTotal$delta_new>(?X0,?Y) :- <http://dbpedia.org/ontology/areaTotal$delta_old>(?X0,?X1), owl:sameAs(?X1,?Y) .
        INSERT INTO "dbrdf_areaTotal_delta_new"(s, o) SELECT t0.s, t1.o FROM "dbrdf_areaTotal_delta_old" t0, "__triples" t1 WHERE t0.o = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 26983 AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 26983, t0.o FROM "dbrdf_areaTotal_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_areaTotal_delta_old";
        INSERT INTO "dbrdf_areaTotal_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_areaTotal_delta_new" t0;
        TRUNCATE TABLE "dbrdf_areaTotal_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 501
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_stylisticOrigin_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_stylisticOrigin_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 26984;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_stylisticOrigin_delta_old" ON "dbrdf_stylisticOrigin_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_stylisticOrigin_delta_old" ON "dbrdf_stylisticOrigin_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_stylisticOrigin_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://dbpedia.org/ontology/stylisticOrigin$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/stylisticOrigin$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_stylisticOrigin_delta_new"(s, o) SELECT t1.o, t0.o FROM "dbrdf_stylisticOrigin_delta_old" t0, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 26984 AND ex.o = t0.o);


        -- <http://dbpedia.org/ontology/stylisticOrigin$delta_new>(?X0,?Y) :- <http://dbpedia.org/ontology/stylisticOrigin$delta_old>(?X0,?X1), owl:sameAs(?X1,?Y) .
        INSERT INTO "dbrdf_stylisticOrigin_delta_new"(s, o) SELECT t0.s, t1.o FROM "dbrdf_stylisticOrigin_delta_old" t0, "__triples" t1 WHERE t0.o = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 26984 AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 26984, t0.o FROM "dbrdf_stylisticOrigin_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_stylisticOrigin_delta_old";
        INSERT INTO "dbrdf_stylisticOrigin_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_stylisticOrigin_delta_new" t0;
        TRUNCATE TABLE "dbrdf_stylisticOrigin_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 502
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_RadioControlledRacingLeague_delta_old"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_RadioControlledRacingLeague_delta_old"(s) SELECT t0.s FROM "__triples" t0 WHERE t0.p = 2 AND t0.o = 26985;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_RadioControlledRacingLeague_delta_old" ON "dbrdf_RadioControlledRacingLeague_delta_old"(s);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_RadioControlledRacingLeague_delta_new"(s integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://dbpedia.org/ontology/RadioControlledRacingLeague$delta_new>(?Y) :- <http://dbpedia.org/ontology/RadioControlledRacingLeague$delta_old>(?X0), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_RadioControlledRacingLeague_delta_new"(s) SELECT t1.o FROM "dbrdf_RadioControlledRacingLeague_delta_old" t0, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 2 AND ex.o = 26985);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 2, 26985 FROM "dbrdf_RadioControlledRacingLeague_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_RadioControlledRacingLeague_delta_old";
        INSERT INTO "dbrdf_RadioControlledRacingLeague_delta_old"(s) SELECT DISTINCT t0.s FROM "dbrdf_RadioControlledRacingLeague_delta_new" t0;
        TRUNCATE TABLE "dbrdf_RadioControlledRacingLeague_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 503
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_musicComposer_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_musicComposer_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 26986;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_musicComposer_delta_old" ON "dbrdf_musicComposer_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_musicComposer_delta_old" ON "dbrdf_musicComposer_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_musicComposer_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://dbpedia.org/ontology/musicComposer$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/musicComposer$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_musicComposer_delta_new"(s, o) SELECT t1.o, t0.o FROM "dbrdf_musicComposer_delta_old" t0, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 26986 AND ex.o = t0.o);


        -- <http://dbpedia.org/ontology/musicComposer$delta_new>(?X0,?Y) :- <http://dbpedia.org/ontology/musicComposer$delta_old>(?X0,?X1), owl:sameAs(?X1,?Y) .
        INSERT INTO "dbrdf_musicComposer_delta_new"(s, o) SELECT t0.s, t1.o FROM "dbrdf_musicComposer_delta_old" t0, "__triples" t1 WHERE t0.o = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 26986 AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 26986, t0.o FROM "dbrdf_musicComposer_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_musicComposer_delta_old";
        INSERT INTO "dbrdf_musicComposer_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_musicComposer_delta_new" t0;
        TRUNCATE TABLE "dbrdf_musicComposer_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 504
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_numberOfFederalDeputies_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_numberOfFederalDeputies_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 26987;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_numberOfFederalDeputies_delta_old" ON "dbrdf_numberOfFederalDeputies_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_numberOfFederalDeputies_delta_old" ON "dbrdf_numberOfFederalDeputies_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_numberOfFederalDeputies_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://dbpedia.org/ontology/numberOfFederalDeputies$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/numberOfFederalDeputies$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_numberOfFederalDeputies_delta_new"(s, o) SELECT t1.o, t0.o FROM "dbrdf_numberOfFederalDeputies_delta_old" t0, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 26987 AND ex.o = t0.o);


        -- <http://dbpedia.org/ontology/numberOfFederalDeputies$delta_new>(?X0,?Y) :- <http://dbpedia.org/ontology/numberOfFederalDeputies$delta_old>(?X0,?X1), owl:sameAs(?X1,?Y) .
        INSERT INTO "dbrdf_numberOfFederalDeputies_delta_new"(s, o) SELECT t0.s, t1.o FROM "dbrdf_numberOfFederalDeputies_delta_old" t0, "__triples" t1 WHERE t0.o = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 26987 AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 26987, t0.o FROM "dbrdf_numberOfFederalDeputies_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_numberOfFederalDeputies_delta_old";
        INSERT INTO "dbrdf_numberOfFederalDeputies_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_numberOfFederalDeputies_delta_new" t0;
        TRUNCATE TABLE "dbrdf_numberOfFederalDeputies_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 505
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_mass_delta_old0"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_mass_delta_old0"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 26988;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_mass_delta_old0" ON "dbrdf_mass_delta_old0"(s, o); CREATE INDEX "IDX_1_dbrdf_mass_delta_old0" ON "dbrdf_mass_delta_old0"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_mass_delta_new0"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://dbpedia.org/ontology/SpaceMission/mass$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/SpaceMission/mass$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_mass_delta_new0"(s, o) SELECT t1.o, t0.o FROM "dbrdf_mass_delta_old0" t0, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 26988 AND ex.o = t0.o);


        -- <http://dbpedia.org/ontology/SpaceMission/mass$delta_new>(?X0,?Y) :- <http://dbpedia.org/ontology/SpaceMission/mass$delta_old>(?X0,?X1), owl:sameAs(?X1,?Y) .
        INSERT INTO "dbrdf_mass_delta_new0"(s, o) SELECT t0.s, t1.o FROM "dbrdf_mass_delta_old0" t0, "__triples" t1 WHERE t0.o = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 26988 AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 26988, t0.o FROM "dbrdf_mass_delta_new0" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_mass_delta_old0";
        INSERT INTO "dbrdf_mass_delta_old0"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_mass_delta_new0" t0;
        TRUNCATE TABLE "dbrdf_mass_delta_new0";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 506
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_port2DockedTime_delta_old0"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_port2DockedTime_delta_old0"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 26989;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_port2DockedTime_delta_old0" ON "dbrdf_port2DockedTime_delta_old0"(s, o); CREATE INDEX "IDX_1_dbrdf_port2DockedTime_delta_old0" ON "dbrdf_port2DockedTime_delta_old0"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_port2DockedTime_delta_new0"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://dbpedia.org/ontology/port2DockedTime$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/port2DockedTime$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_port2DockedTime_delta_new0"(s, o) SELECT t1.o, t0.o FROM "dbrdf_port2DockedTime_delta_old0" t0, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 26989 AND ex.o = t0.o);


        -- <http://dbpedia.org/ontology/port2DockedTime$delta_new>(?X0,?Y) :- <http://dbpedia.org/ontology/port2DockedTime$delta_old>(?X0,?X1), owl:sameAs(?X1,?Y) .
        INSERT INTO "dbrdf_port2DockedTime_delta_new0"(s, o) SELECT t0.s, t1.o FROM "dbrdf_port2DockedTime_delta_old0" t0, "__triples" t1 WHERE t0.o = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 26989 AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 26989, t0.o FROM "dbrdf_port2DockedTime_delta_new0" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_port2DockedTime_delta_old0";
        INSERT INTO "dbrdf_port2DockedTime_delta_old0"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_port2DockedTime_delta_new0" t0;
        TRUNCATE TABLE "dbrdf_port2DockedTime_delta_new0";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 507
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_modelStartDate_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_modelStartDate_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 26990;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_modelStartDate_delta_old" ON "dbrdf_modelStartDate_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_modelStartDate_delta_old" ON "dbrdf_modelStartDate_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_modelStartDate_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://dbpedia.org/ontology/modelStartDate$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/modelStartDate$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_modelStartDate_delta_new"(s, o) SELECT t1.o, t0.o FROM "dbrdf_modelStartDate_delta_old" t0, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 26990 AND ex.o = t0.o);


        -- <http://dbpedia.org/ontology/modelStartDate$delta_new>(?X0,?Y) :- <http://dbpedia.org/ontology/modelStartDate$delta_old>(?X0,?X1), owl:sameAs(?X1,?Y) .
        INSERT INTO "dbrdf_modelStartDate_delta_new"(s, o) SELECT t0.s, t1.o FROM "dbrdf_modelStartDate_delta_old" t0, "__triples" t1 WHERE t0.o = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 26990 AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 26990, t0.o FROM "dbrdf_modelStartDate_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_modelStartDate_delta_old";
        INSERT INTO "dbrdf_modelStartDate_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_modelStartDate_delta_new" t0;
        TRUNCATE TABLE "dbrdf_modelStartDate_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 508
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_BasketballPlayer_delta_old"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_BasketballPlayer_delta_old"(s) SELECT t0.s FROM "__triples" t0 WHERE t0.p = 2 AND t0.o = 26991;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_BasketballPlayer_delta_old" ON "dbrdf_BasketballPlayer_delta_old"(s);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_BasketballPlayer_delta_new"(s integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://dbpedia.org/ontology/BasketballPlayer$delta_new>(?Y) :- <http://dbpedia.org/ontology/BasketballPlayer$delta_old>(?X0), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_BasketballPlayer_delta_new"(s) SELECT t1.o FROM "dbrdf_BasketballPlayer_delta_old" t0, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 2 AND ex.o = 26991);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 2, 26991 FROM "dbrdf_BasketballPlayer_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_BasketballPlayer_delta_old";
        INSERT INTO "dbrdf_BasketballPlayer_delta_old"(s) SELECT DISTINCT t0.s FROM "dbrdf_BasketballPlayer_delta_new" t0;
        TRUNCATE TABLE "dbrdf_BasketballPlayer_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 509
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_cmykCoordinateCyanic_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_cmykCoordinateCyanic_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 26992;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_cmykCoordinateCyanic_delta_old" ON "dbrdf_cmykCoordinateCyanic_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_cmykCoordinateCyanic_delta_old" ON "dbrdf_cmykCoordinateCyanic_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_cmykCoordinateCyanic_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://dbpedia.org/ontology/cmykCoordinateCyanic$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/cmykCoordinateCyanic$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_cmykCoordinateCyanic_delta_new"(s, o) SELECT t1.o, t0.o FROM "dbrdf_cmykCoordinateCyanic_delta_old" t0, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 26992 AND ex.o = t0.o);


        -- <http://dbpedia.org/ontology/cmykCoordinateCyanic$delta_new>(?X0,?Y) :- <http://dbpedia.org/ontology/cmykCoordinateCyanic$delta_old>(?X0,?X1), owl:sameAs(?X1,?Y) .
        INSERT INTO "dbrdf_cmykCoordinateCyanic_delta_new"(s, o) SELECT t0.s, t1.o FROM "dbrdf_cmykCoordinateCyanic_delta_old" t0, "__triples" t1 WHERE t0.o = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 26992 AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 26992, t0.o FROM "dbrdf_cmykCoordinateCyanic_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_cmykCoordinateCyanic_delta_old";
        INSERT INTO "dbrdf_cmykCoordinateCyanic_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_cmykCoordinateCyanic_delta_new" t0;
        TRUNCATE TABLE "dbrdf_cmykCoordinateCyanic_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 510
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_soccerTournamentMostSteady_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_soccerTournamentMostSteady_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 26993;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_soccerTournamentMostSteady_delta_old" ON "dbrdf_soccerTournamentMostSteady_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_soccerTournamentMostSteady_delta_old" ON "dbrdf_soccerTournamentMostSteady_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_soccerTournamentMostSteady_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://dbpedia.org/ontology/soccerTournamentMostSteady$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/soccerTournamentMostSteady$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_soccerTournamentMostSteady_delta_new"(s, o) SELECT t1.o, t0.o FROM "dbrdf_soccerTournamentMostSteady_delta_old" t0, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 26993 AND ex.o = t0.o);


        -- <http://dbpedia.org/ontology/soccerTournamentMostSteady$delta_new>(?X0,?Y) :- <http://dbpedia.org/ontology/soccerTournamentMostSteady$delta_old>(?X0,?X1), owl:sameAs(?X1,?Y) .
        INSERT INTO "dbrdf_soccerTournamentMostSteady_delta_new"(s, o) SELECT t0.s, t1.o FROM "dbrdf_soccerTournamentMostSteady_delta_old" t0, "__triples" t1 WHERE t0.o = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 26993 AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 26993, t0.o FROM "dbrdf_soccerTournamentMostSteady_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_soccerTournamentMostSteady_delta_old";
        INSERT INTO "dbrdf_soccerTournamentMostSteady_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_soccerTournamentMostSteady_delta_new" t0;
        TRUNCATE TABLE "dbrdf_soccerTournamentMostSteady_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 511
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_schoolNumber_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_schoolNumber_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 26994;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_schoolNumber_delta_old" ON "dbrdf_schoolNumber_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_schoolNumber_delta_old" ON "dbrdf_schoolNumber_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_schoolNumber_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://dbpedia.org/ontology/schoolNumber$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/schoolNumber$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_schoolNumber_delta_new"(s, o) SELECT t1.o, t0.o FROM "dbrdf_schoolNumber_delta_old" t0, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 26994 AND ex.o = t0.o);


        -- <http://dbpedia.org/ontology/schoolNumber$delta_new>(?X0,?Y) :- <http://dbpedia.org/ontology/schoolNumber$delta_old>(?X0,?X1), owl:sameAs(?X1,?Y) .
        INSERT INTO "dbrdf_schoolNumber_delta_new"(s, o) SELECT t0.s, t1.o FROM "dbrdf_schoolNumber_delta_old" t0, "__triples" t1 WHERE t0.o = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 26994 AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 26994, t0.o FROM "dbrdf_schoolNumber_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_schoolNumber_delta_old";
        INSERT INTO "dbrdf_schoolNumber_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_schoolNumber_delta_new" t0;
        TRUNCATE TABLE "dbrdf_schoolNumber_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 512
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_title_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_title_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 26995;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_title_delta_old" ON "dbrdf_title_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_title_delta_old" ON "dbrdf_title_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_title_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://dbpedia.org/ontology/title$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/title$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_title_delta_new"(s, o) SELECT t1.o, t0.o FROM "dbrdf_title_delta_old" t0, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 26995 AND ex.o = t0.o);


        -- <http://dbpedia.org/ontology/title$delta_new>(?X0,?Y) :- <http://dbpedia.org/ontology/title$delta_old>(?X0,?X1), owl:sameAs(?X1,?Y) .
        INSERT INTO "dbrdf_title_delta_new"(s, o) SELECT t0.s, t1.o FROM "dbrdf_title_delta_old" t0, "__triples" t1 WHERE t0.o = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 26995 AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 26995, t0.o FROM "dbrdf_title_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_title_delta_old";
        INSERT INTO "dbrdf_title_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_title_delta_new" t0;
        TRUNCATE TABLE "dbrdf_title_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 513
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_decideDate_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_decideDate_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 26996;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_decideDate_delta_old" ON "dbrdf_decideDate_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_decideDate_delta_old" ON "dbrdf_decideDate_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_decideDate_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://dbpedia.org/ontology/decideDate$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/decideDate$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_decideDate_delta_new"(s, o) SELECT t1.o, t0.o FROM "dbrdf_decideDate_delta_old" t0, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 26996 AND ex.o = t0.o);


        -- <http://dbpedia.org/ontology/decideDate$delta_new>(?X0,?Y) :- <http://dbpedia.org/ontology/decideDate$delta_old>(?X0,?X1), owl:sameAs(?X1,?Y) .
        INSERT INTO "dbrdf_decideDate_delta_new"(s, o) SELECT t0.s, t1.o FROM "dbrdf_decideDate_delta_old" t0, "__triples" t1 WHERE t0.o = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 26996 AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 26996, t0.o FROM "dbrdf_decideDate_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_decideDate_delta_old";
        INSERT INTO "dbrdf_decideDate_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_decideDate_delta_new" t0;
        TRUNCATE TABLE "dbrdf_decideDate_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 514
    ---- DEPENDS ON: 513, 110, 0
    ----------------------------------------

    -- Nonrecursive rules

    -- [Rule] <http://dbpedia.org/ontology/SupremeCourtOfTheUnitedStatesCase>(?X) :- <http://dbpedia.org/ontology/decideDate>(?X,?X1) .
    INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 2, 26997 FROM "__triples" t0 WHERE t0.p = 26996 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 2 AND ex.o = 26997);
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    total_tuples := total_tuples + rows_nr;

    -- [Rule] <http://dbpedia.org/ontology/SupremeCourtOfTheUnitedStatesCase>(?X) :- <http://dbpedia.org/ontology/argueDate>(?X,?X1) .
    INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 2, 26997 FROM "__triples" t0 WHERE t0.p = 26592 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 2 AND ex.o = 26997);
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    total_tuples := total_tuples + rows_nr;

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_SupremeCourtOfTheUnitedStatesCase_delta_old"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_SupremeCourtOfTheUnitedStatesCase_delta_old"(s) SELECT t0.s FROM "__triples" t0 WHERE t0.p = 2 AND t0.o = 26997;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_SupremeCourtOfTheUnitedStatesCase_delta_old" ON "dbrdf_SupremeCourtOfTheUnitedStatesCase_delta_old"(s);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_SupremeCourtOfTheUnitedStatesCase_delta_new"(s integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://dbpedia.org/ontology/SupremeCourtOfTheUnitedStatesCase$delta_new>(?Y) :- <http://dbpedia.org/ontology/SupremeCourtOfTheUnitedStatesCase$delta_old>(?X0), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_SupremeCourtOfTheUnitedStatesCase_delta_new"(s) SELECT t1.o FROM "dbrdf_SupremeCourtOfTheUnitedStatesCase_delta_old" t0, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 2 AND ex.o = 26997);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 2, 26997 FROM "dbrdf_SupremeCourtOfTheUnitedStatesCase_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_SupremeCourtOfTheUnitedStatesCase_delta_old";
        INSERT INTO "dbrdf_SupremeCourtOfTheUnitedStatesCase_delta_old"(s) SELECT DISTINCT t0.s FROM "dbrdf_SupremeCourtOfTheUnitedStatesCase_delta_new" t0;
        TRUNCATE TABLE "dbrdf_SupremeCourtOfTheUnitedStatesCase_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 515
    ---- DEPENDS ON: 514, 0
    ----------------------------------------

    -- Nonrecursive rules

    -- [Rule] <http://dbpedia.org/ontology/LegalCase>(?X) :- <http://dbpedia.org/ontology/SupremeCourtOfTheUnitedStatesCase>(?X) .
    INSERT INTO "__triples"(s, p, o) SELECT t0.s, 2, 26998 FROM "__triples" t0 WHERE t0.p = 2 AND t0.o = 26997 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 2 AND ex.o = 26998);
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    total_tuples := total_tuples + rows_nr;

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_LegalCase_delta_old"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_LegalCase_delta_old"(s) SELECT t0.s FROM "__triples" t0 WHERE t0.p = 2 AND t0.o = 26998;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_LegalCase_delta_old" ON "dbrdf_LegalCase_delta_old"(s);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_LegalCase_delta_new"(s integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://dbpedia.org/ontology/LegalCase$delta_new>(?Y) :- <http://dbpedia.org/ontology/LegalCase$delta_old>(?X0), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_LegalCase_delta_new"(s) SELECT t1.o FROM "dbrdf_LegalCase_delta_old" t0, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 2 AND ex.o = 26998);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 2, 26998 FROM "dbrdf_LegalCase_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_LegalCase_delta_old";
        INSERT INTO "dbrdf_LegalCase_delta_old"(s) SELECT DISTINCT t0.s FROM "dbrdf_LegalCase_delta_new" t0;
        TRUNCATE TABLE "dbrdf_LegalCase_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 516
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_creationYear_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_creationYear_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 26999;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_creationYear_delta_old" ON "dbrdf_creationYear_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_creationYear_delta_old" ON "dbrdf_creationYear_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_creationYear_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://dbpedia.org/ontology/creationYear$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/creationYear$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_creationYear_delta_new"(s, o) SELECT t1.o, t0.o FROM "dbrdf_creationYear_delta_old" t0, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 26999 AND ex.o = t0.o);


        -- <http://dbpedia.org/ontology/creationYear$delta_new>(?X0,?Y) :- <http://dbpedia.org/ontology/creationYear$delta_old>(?X0,?X1), owl:sameAs(?X1,?Y) .
        INSERT INTO "dbrdf_creationYear_delta_new"(s, o) SELECT t0.s, t1.o FROM "dbrdf_creationYear_delta_old" t0, "__triples" t1 WHERE t0.o = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 26999 AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 26999, t0.o FROM "dbrdf_creationYear_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_creationYear_delta_old";
        INSERT INTO "dbrdf_creationYear_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_creationYear_delta_new" t0;
        TRUNCATE TABLE "dbrdf_creationYear_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 517
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_ascent_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_ascent_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27000;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_ascent_delta_old" ON "dbrdf_ascent_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_ascent_delta_old" ON "dbrdf_ascent_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_ascent_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://dbpedia.org/ontology/ascent$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/ascent$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_ascent_delta_new"(s, o) SELECT t1.o, t0.o FROM "dbrdf_ascent_delta_old" t0, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 27000 AND ex.o = t0.o);


        -- <http://dbpedia.org/ontology/ascent$delta_new>(?X0,?Y) :- <http://dbpedia.org/ontology/ascent$delta_old>(?X0,?X1), owl:sameAs(?X1,?Y) .
        INSERT INTO "dbrdf_ascent_delta_new"(s, o) SELECT t0.s, t1.o FROM "dbrdf_ascent_delta_old" t0, "__triples" t1 WHERE t0.o = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 27000 AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 27000, t0.o FROM "dbrdf_ascent_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_ascent_delta_old";
        INSERT INTO "dbrdf_ascent_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_ascent_delta_new" t0;
        TRUNCATE TABLE "dbrdf_ascent_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 518
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_spacewalkBegin_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_spacewalkBegin_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27001;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_spacewalkBegin_delta_old" ON "dbrdf_spacewalkBegin_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_spacewalkBegin_delta_old" ON "dbrdf_spacewalkBegin_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_spacewalkBegin_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://dbpedia.org/ontology/spacewalkBegin$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/spacewalkBegin$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_spacewalkBegin_delta_new"(s, o) SELECT t1.o, t0.o FROM "dbrdf_spacewalkBegin_delta_old" t0, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 27001 AND ex.o = t0.o);


        -- <http://dbpedia.org/ontology/spacewalkBegin$delta_new>(?X0,?Y) :- <http://dbpedia.org/ontology/spacewalkBegin$delta_old>(?X0,?X1), owl:sameAs(?X1,?Y) .
        INSERT INTO "dbrdf_spacewalkBegin_delta_new"(s, o) SELECT t0.s, t1.o FROM "dbrdf_spacewalkBegin_delta_old" t0, "__triples" t1 WHERE t0.o = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 27001 AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 27001, t0.o FROM "dbrdf_spacewalkBegin_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_spacewalkBegin_delta_old";
        INSERT INTO "dbrdf_spacewalkBegin_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_spacewalkBegin_delta_new" t0;
        TRUNCATE TABLE "dbrdf_spacewalkBegin_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 519
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_nextMission_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_nextMission_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27002;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_nextMission_delta_old" ON "dbrdf_nextMission_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_nextMission_delta_old" ON "dbrdf_nextMission_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_nextMission_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://dbpedia.org/ontology/nextMission$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/nextMission$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_nextMission_delta_new"(s, o) SELECT t1.o, t0.o FROM "dbrdf_nextMission_delta_old" t0, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 27002 AND ex.o = t0.o);


        -- <http://dbpedia.org/ontology/nextMission$delta_new>(?X0,?Y) :- <http://dbpedia.org/ontology/nextMission$delta_old>(?X0,?X1), owl:sameAs(?X1,?Y) .
        INSERT INTO "dbrdf_nextMission_delta_new"(s, o) SELECT t0.s, t1.o FROM "dbrdf_nextMission_delta_old" t0, "__triples" t1 WHERE t0.o = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 27002 AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 27002, t0.o FROM "dbrdf_nextMission_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_nextMission_delta_old";
        INSERT INTO "dbrdf_nextMission_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_nextMission_delta_new" t0;
        TRUNCATE TABLE "dbrdf_nextMission_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 520
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_officerInCharge_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_officerInCharge_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27003;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_officerInCharge_delta_old" ON "dbrdf_officerInCharge_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_officerInCharge_delta_old" ON "dbrdf_officerInCharge_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_officerInCharge_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://dbpedia.org/ontology/officerInCharge$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/officerInCharge$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_officerInCharge_delta_new"(s, o) SELECT t1.o, t0.o FROM "dbrdf_officerInCharge_delta_old" t0, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 27003 AND ex.o = t0.o);


        -- <http://dbpedia.org/ontology/officerInCharge$delta_new>(?X0,?Y) :- <http://dbpedia.org/ontology/officerInCharge$delta_old>(?X0,?X1), owl:sameAs(?X1,?Y) .
        INSERT INTO "dbrdf_officerInCharge_delta_new"(s, o) SELECT t0.s, t1.o FROM "dbrdf_officerInCharge_delta_old" t0, "__triples" t1 WHERE t0.o = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 27003 AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 27003, t0.o FROM "dbrdf_officerInCharge_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_officerInCharge_delta_old";
        INSERT INTO "dbrdf_officerInCharge_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_officerInCharge_delta_new" t0;
        TRUNCATE TABLE "dbrdf_officerInCharge_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 521
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_head_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_head_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27004;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_head_delta_old" ON "dbrdf_head_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_head_delta_old" ON "dbrdf_head_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_head_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://dbpedia.org/ontology/head$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/head$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_head_delta_new"(s, o) SELECT t1.o, t0.o FROM "dbrdf_head_delta_old" t0, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 27004 AND ex.o = t0.o);


        -- <http://dbpedia.org/ontology/head$delta_new>(?X0,?Y) :- <http://dbpedia.org/ontology/head$delta_old>(?X0,?X1), owl:sameAs(?X1,?Y) .
        INSERT INTO "dbrdf_head_delta_new"(s, o) SELECT t0.s, t1.o FROM "dbrdf_head_delta_old" t0, "__triples" t1 WHERE t0.o = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 27004 AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 27004, t0.o FROM "dbrdf_head_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_head_delta_old";
        INSERT INTO "dbrdf_head_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_head_delta_new" t0;
        TRUNCATE TABLE "dbrdf_head_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 522
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_MouseGene_delta_old"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_MouseGene_delta_old"(s) SELECT t0.s FROM "__triples" t0 WHERE t0.p = 2 AND t0.o = 27005;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_MouseGene_delta_old" ON "dbrdf_MouseGene_delta_old"(s);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_MouseGene_delta_new"(s integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://dbpedia.org/ontology/MouseGene$delta_new>(?Y) :- <http://dbpedia.org/ontology/MouseGene$delta_old>(?X0), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_MouseGene_delta_new"(s) SELECT t1.o FROM "dbrdf_MouseGene_delta_old" t0, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 2 AND ex.o = 27005);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 2, 27005 FROM "dbrdf_MouseGene_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_MouseGene_delta_old";
        INSERT INTO "dbrdf_MouseGene_delta_old"(s) SELECT DISTINCT t0.s FROM "dbrdf_MouseGene_delta_new" t0;
        TRUNCATE TABLE "dbrdf_MouseGene_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 523
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_youthWing_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_youthWing_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27006;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_youthWing_delta_old" ON "dbrdf_youthWing_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_youthWing_delta_old" ON "dbrdf_youthWing_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_youthWing_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://dbpedia.org/ontology/youthWing$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/youthWing$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_youthWing_delta_new"(s, o) SELECT t1.o, t0.o FROM "dbrdf_youthWing_delta_old" t0, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 27006 AND ex.o = t0.o);


        -- <http://dbpedia.org/ontology/youthWing$delta_new>(?X0,?Y) :- <http://dbpedia.org/ontology/youthWing$delta_old>(?X0,?X1), owl:sameAs(?X1,?Y) .
        INSERT INTO "dbrdf_youthWing_delta_new"(s, o) SELECT t0.s, t1.o FROM "dbrdf_youthWing_delta_old" t0, "__triples" t1 WHERE t0.o = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 27006 AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 27006, t0.o FROM "dbrdf_youthWing_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_youthWing_delta_old";
        INSERT INTO "dbrdf_youthWing_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_youthWing_delta_new" t0;
        TRUNCATE TABLE "dbrdf_youthWing_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 524
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_coExecutiveProducer_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_coExecutiveProducer_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27007;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_coExecutiveProducer_delta_old" ON "dbrdf_coExecutiveProducer_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_coExecutiveProducer_delta_old" ON "dbrdf_coExecutiveProducer_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_coExecutiveProducer_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://dbpedia.org/ontology/coExecutiveProducer$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/coExecutiveProducer$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_coExecutiveProducer_delta_new"(s, o) SELECT t1.o, t0.o FROM "dbrdf_coExecutiveProducer_delta_old" t0, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 27007 AND ex.o = t0.o);


        -- <http://dbpedia.org/ontology/coExecutiveProducer$delta_new>(?X0,?Y) :- <http://dbpedia.org/ontology/coExecutiveProducer$delta_old>(?X0,?X1), owl:sameAs(?X1,?Y) .
        INSERT INTO "dbrdf_coExecutiveProducer_delta_new"(s, o) SELECT t0.s, t1.o FROM "dbrdf_coExecutiveProducer_delta_old" t0, "__triples" t1 WHERE t0.o = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 27007 AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 27007, t0.o FROM "dbrdf_coExecutiveProducer_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_coExecutiveProducer_delta_old";
        INSERT INTO "dbrdf_coExecutiveProducer_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_coExecutiveProducer_delta_new" t0;
        TRUNCATE TABLE "dbrdf_coExecutiveProducer_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 525
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_winsAtLAGT_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_winsAtLAGT_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27008;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_winsAtLAGT_delta_old" ON "dbrdf_winsAtLAGT_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_winsAtLAGT_delta_old" ON "dbrdf_winsAtLAGT_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_winsAtLAGT_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://dbpedia.org/ontology/winsAtLAGT$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/winsAtLAGT$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_winsAtLAGT_delta_new"(s, o) SELECT t1.o, t0.o FROM "dbrdf_winsAtLAGT_delta_old" t0, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 27008 AND ex.o = t0.o);


        -- <http://dbpedia.org/ontology/winsAtLAGT$delta_new>(?X0,?Y) :- <http://dbpedia.org/ontology/winsAtLAGT$delta_old>(?X0,?X1), owl:sameAs(?X1,?Y) .
        INSERT INTO "dbrdf_winsAtLAGT_delta_new"(s, o) SELECT t0.s, t1.o FROM "dbrdf_winsAtLAGT_delta_old" t0, "__triples" t1 WHERE t0.o = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 27008 AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 27008, t0.o FROM "dbrdf_winsAtLAGT_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_winsAtLAGT_delta_old";
        INSERT INTO "dbrdf_winsAtLAGT_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_winsAtLAGT_delta_new" t0;
        TRUNCATE TABLE "dbrdf_winsAtLAGT_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 526
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_maximumBoatLength_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_maximumBoatLength_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27009;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_maximumBoatLength_delta_old" ON "dbrdf_maximumBoatLength_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_maximumBoatLength_delta_old" ON "dbrdf_maximumBoatLength_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_maximumBoatLength_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://dbpedia.org/ontology/maximumBoatLength$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/maximumBoatLength$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_maximumBoatLength_delta_new"(s, o) SELECT t1.o, t0.o FROM "dbrdf_maximumBoatLength_delta_old" t0, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 27009 AND ex.o = t0.o);


        -- <http://dbpedia.org/ontology/maximumBoatLength$delta_new>(?X0,?Y) :- <http://dbpedia.org/ontology/maximumBoatLength$delta_old>(?X0,?X1), owl:sameAs(?X1,?Y) .
        INSERT INTO "dbrdf_maximumBoatLength_delta_new"(s, o) SELECT t0.s, t1.o FROM "dbrdf_maximumBoatLength_delta_old" t0, "__triples" t1 WHERE t0.o = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 27009 AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 27009, t0.o FROM "dbrdf_maximumBoatLength_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_maximumBoatLength_delta_old";
        INSERT INTO "dbrdf_maximumBoatLength_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_maximumBoatLength_delta_new" t0;
        TRUNCATE TABLE "dbrdf_maximumBoatLength_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 527
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_winsAtLET_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_winsAtLET_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27010;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_winsAtLET_delta_old" ON "dbrdf_winsAtLET_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_winsAtLET_delta_old" ON "dbrdf_winsAtLET_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_winsAtLET_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://dbpedia.org/ontology/winsAtLET$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/winsAtLET$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_winsAtLET_delta_new"(s, o) SELECT t1.o, t0.o FROM "dbrdf_winsAtLET_delta_old" t0, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 27010 AND ex.o = t0.o);


        -- <http://dbpedia.org/ontology/winsAtLET$delta_new>(?X0,?Y) :- <http://dbpedia.org/ontology/winsAtLET$delta_old>(?X0,?X1), owl:sameAs(?X1,?Y) .
        INSERT INTO "dbrdf_winsAtLET_delta_new"(s, o) SELECT t0.s, t1.o FROM "dbrdf_winsAtLET_delta_old" t0, "__triples" t1 WHERE t0.o = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 27010 AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 27010, t0.o FROM "dbrdf_winsAtLET_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_winsAtLET_delta_old";
        INSERT INTO "dbrdf_winsAtLET_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_winsAtLET_delta_new" t0;
        TRUNCATE TABLE "dbrdf_winsAtLET_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 528
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_pistonStroke_delta_old0"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_pistonStroke_delta_old0"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27011;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_pistonStroke_delta_old0" ON "dbrdf_pistonStroke_delta_old0"(s, o); CREATE INDEX "IDX_1_dbrdf_pistonStroke_delta_old0" ON "dbrdf_pistonStroke_delta_old0"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_pistonStroke_delta_new0"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://dbpedia.org/ontology/AutomobileEngine/pistonStroke$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/AutomobileEngine/pistonStroke$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_pistonStroke_delta_new0"(s, o) SELECT t1.o, t0.o FROM "dbrdf_pistonStroke_delta_old0" t0, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 27011 AND ex.o = t0.o);


        -- <http://dbpedia.org/ontology/AutomobileEngine/pistonStroke$delta_new>(?X0,?Y) :- <http://dbpedia.org/ontology/AutomobileEngine/pistonStroke$delta_old>(?X0,?X1), owl:sameAs(?X1,?Y) .
        INSERT INTO "dbrdf_pistonStroke_delta_new0"(s, o) SELECT t0.s, t1.o FROM "dbrdf_pistonStroke_delta_old0" t0, "__triples" t1 WHERE t0.o = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 27011 AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 27011, t0.o FROM "dbrdf_pistonStroke_delta_new0" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_pistonStroke_delta_old0";
        INSERT INTO "dbrdf_pistonStroke_delta_old0"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_pistonStroke_delta_new0" t0;
        TRUNCATE TABLE "dbrdf_pistonStroke_delta_new0";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 529
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_senator_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_senator_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27012;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_senator_delta_old" ON "dbrdf_senator_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_senator_delta_old" ON "dbrdf_senator_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_senator_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://dbpedia.org/ontology/senator$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/senator$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_senator_delta_new"(s, o) SELECT t1.o, t0.o FROM "dbrdf_senator_delta_old" t0, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 27012 AND ex.o = t0.o);


        -- <http://dbpedia.org/ontology/senator$delta_new>(?X0,?Y) :- <http://dbpedia.org/ontology/senator$delta_old>(?X0,?X1), owl:sameAs(?X1,?Y) .
        INSERT INTO "dbrdf_senator_delta_new"(s, o) SELECT t0.s, t1.o FROM "dbrdf_senator_delta_old" t0, "__triples" t1 WHERE t0.o = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 27012 AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 27012, t0.o FROM "dbrdf_senator_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_senator_delta_old";
        INSERT INTO "dbrdf_senator_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_senator_delta_new" t0;
        TRUNCATE TABLE "dbrdf_senator_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 530
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_aircraftHelicopterCargo_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_aircraftHelicopterCargo_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27013;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_aircraftHelicopterCargo_delta_old" ON "dbrdf_aircraftHelicopterCargo_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_aircraftHelicopterCargo_delta_old" ON "dbrdf_aircraftHelicopterCargo_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_aircraftHelicopterCargo_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://dbpedia.org/ontology/aircraftHelicopterCargo$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/aircraftHelicopterCargo$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_aircraftHelicopterCargo_delta_new"(s, o) SELECT t1.o, t0.o FROM "dbrdf_aircraftHelicopterCargo_delta_old" t0, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 27013 AND ex.o = t0.o);


        -- <http://dbpedia.org/ontology/aircraftHelicopterCargo$delta_new>(?X0,?Y) :- <http://dbpedia.org/ontology/aircraftHelicopterCargo$delta_old>(?X0,?X1), owl:sameAs(?X1,?Y) .
        INSERT INTO "dbrdf_aircraftHelicopterCargo_delta_new"(s, o) SELECT t0.s, t1.o FROM "dbrdf_aircraftHelicopterCargo_delta_old" t0, "__triples" t1 WHERE t0.o = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 27013 AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 27013, t0.o FROM "dbrdf_aircraftHelicopterCargo_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_aircraftHelicopterCargo_delta_old";
        INSERT INTO "dbrdf_aircraftHelicopterCargo_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_aircraftHelicopterCargo_delta_new" t0;
        TRUNCATE TABLE "dbrdf_aircraftHelicopterCargo_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 531
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_broadcastStationClass_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_broadcastStationClass_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27014;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_broadcastStationClass_delta_old" ON "dbrdf_broadcastStationClass_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_broadcastStationClass_delta_old" ON "dbrdf_broadcastStationClass_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_broadcastStationClass_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://dbpedia.org/ontology/broadcastStationClass$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/broadcastStationClass$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_broadcastStationClass_delta_new"(s, o) SELECT t1.o, t0.o FROM "dbrdf_broadcastStationClass_delta_old" t0, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 27014 AND ex.o = t0.o);


        -- <http://dbpedia.org/ontology/broadcastStationClass$delta_new>(?X0,?Y) :- <http://dbpedia.org/ontology/broadcastStationClass$delta_old>(?X0,?X1), owl:sameAs(?X1,?Y) .
        INSERT INTO "dbrdf_broadcastStationClass_delta_new"(s, o) SELECT t0.s, t1.o FROM "dbrdf_broadcastStationClass_delta_old" t0, "__triples" t1 WHERE t0.o = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 27014 AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 27014, t0.o FROM "dbrdf_broadcastStationClass_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_broadcastStationClass_delta_old";
        INSERT INTO "dbrdf_broadcastStationClass_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_broadcastStationClass_delta_new" t0;
        TRUNCATE TABLE "dbrdf_broadcastStationClass_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 532
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_numberOfBronzeMedalsWon_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_numberOfBronzeMedalsWon_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27015;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_numberOfBronzeMedalsWon_delta_old" ON "dbrdf_numberOfBronzeMedalsWon_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_numberOfBronzeMedalsWon_delta_old" ON "dbrdf_numberOfBronzeMedalsWon_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_numberOfBronzeMedalsWon_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://dbpedia.org/ontology/numberOfBronzeMedalsWon$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/numberOfBronzeMedalsWon$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_numberOfBronzeMedalsWon_delta_new"(s, o) SELECT t1.o, t0.o FROM "dbrdf_numberOfBronzeMedalsWon_delta_old" t0, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 27015 AND ex.o = t0.o);


        -- <http://dbpedia.org/ontology/numberOfBronzeMedalsWon$delta_new>(?X0,?Y) :- <http://dbpedia.org/ontology/numberOfBronzeMedalsWon$delta_old>(?X0,?X1), owl:sameAs(?X1,?Y) .
        INSERT INTO "dbrdf_numberOfBronzeMedalsWon_delta_new"(s, o) SELECT t0.s, t1.o FROM "dbrdf_numberOfBronzeMedalsWon_delta_old" t0, "__triples" t1 WHERE t0.o = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 27015 AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 27015, t0.o FROM "dbrdf_numberOfBronzeMedalsWon_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_numberOfBronzeMedalsWon_delta_old";
        INSERT INTO "dbrdf_numberOfBronzeMedalsWon_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_numberOfBronzeMedalsWon_delta_new" t0;
        TRUNCATE TABLE "dbrdf_numberOfBronzeMedalsWon_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 533
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_shipBeam_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_shipBeam_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27016;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_shipBeam_delta_old" ON "dbrdf_shipBeam_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_shipBeam_delta_old" ON "dbrdf_shipBeam_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_shipBeam_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://dbpedia.org/ontology/shipBeam$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/shipBeam$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_shipBeam_delta_new"(s, o) SELECT t1.o, t0.o FROM "dbrdf_shipBeam_delta_old" t0, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 27016 AND ex.o = t0.o);


        -- <http://dbpedia.org/ontology/shipBeam$delta_new>(?X0,?Y) :- <http://dbpedia.org/ontology/shipBeam$delta_old>(?X0,?X1), owl:sameAs(?X1,?Y) .
        INSERT INTO "dbrdf_shipBeam_delta_new"(s, o) SELECT t0.s, t1.o FROM "dbrdf_shipBeam_delta_old" t0, "__triples" t1 WHERE t0.o = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 27016 AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 27016, t0.o FROM "dbrdf_shipBeam_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_shipBeam_delta_old";
        INSERT INTO "dbrdf_shipBeam_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_shipBeam_delta_new" t0;
        TRUNCATE TABLE "dbrdf_shipBeam_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 534
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_draft_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_draft_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27017;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_draft_delta_old" ON "dbrdf_draft_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_draft_delta_old" ON "dbrdf_draft_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_draft_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://dbpedia.org/ontology/draft$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/draft$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_draft_delta_new"(s, o) SELECT t1.o, t0.o FROM "dbrdf_draft_delta_old" t0, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 27017 AND ex.o = t0.o);


        -- <http://dbpedia.org/ontology/draft$delta_new>(?X0,?Y) :- <http://dbpedia.org/ontology/draft$delta_old>(?X0,?X1), owl:sameAs(?X1,?Y) .
        INSERT INTO "dbrdf_draft_delta_new"(s, o) SELECT t0.s, t1.o FROM "dbrdf_draft_delta_old" t0, "__triples" t1 WHERE t0.o = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 27017 AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 27017, t0.o FROM "dbrdf_draft_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_draft_delta_old";
        INSERT INTO "dbrdf_draft_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_draft_delta_new" t0;
        TRUNCATE TABLE "dbrdf_draft_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 535
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_licensee_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_licensee_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27018;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_licensee_delta_old" ON "dbrdf_licensee_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_licensee_delta_old" ON "dbrdf_licensee_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_licensee_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://dbpedia.org/ontology/licensee$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/licensee$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_licensee_delta_new"(s, o) SELECT t1.o, t0.o FROM "dbrdf_licensee_delta_old" t0, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 27018 AND ex.o = t0.o);


        -- <http://dbpedia.org/ontology/licensee$delta_new>(?X0,?Y) :- <http://dbpedia.org/ontology/licensee$delta_old>(?X0,?X1), owl:sameAs(?X1,?Y) .
        INSERT INTO "dbrdf_licensee_delta_new"(s, o) SELECT t0.s, t1.o FROM "dbrdf_licensee_delta_old" t0, "__triples" t1 WHERE t0.o = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 27018 AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 27018, t0.o FROM "dbrdf_licensee_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_licensee_delta_old";
        INSERT INTO "dbrdf_licensee_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_licensee_delta_new" t0;
        TRUNCATE TABLE "dbrdf_licensee_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 536
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_ChristianPatriarch_delta_old"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_ChristianPatriarch_delta_old"(s) SELECT t0.s FROM "__triples" t0 WHERE t0.p = 2 AND t0.o = 27019;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_ChristianPatriarch_delta_old" ON "dbrdf_ChristianPatriarch_delta_old"(s);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_ChristianPatriarch_delta_new"(s integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://dbpedia.org/ontology/ChristianPatriarch$delta_new>(?Y) :- <http://dbpedia.org/ontology/ChristianPatriarch$delta_old>(?X0), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_ChristianPatriarch_delta_new"(s) SELECT t1.o FROM "dbrdf_ChristianPatriarch_delta_old" t0, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 2 AND ex.o = 27019);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 2, 27019 FROM "dbrdf_ChristianPatriarch_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_ChristianPatriarch_delta_old";
        INSERT INTO "dbrdf_ChristianPatriarch_delta_old"(s) SELECT DISTINCT t0.s FROM "dbrdf_ChristianPatriarch_delta_new" t0;
        TRUNCATE TABLE "dbrdf_ChristianPatriarch_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 537
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_summerTemperature_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_summerTemperature_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27020;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_summerTemperature_delta_old" ON "dbrdf_summerTemperature_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_summerTemperature_delta_old" ON "dbrdf_summerTemperature_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_summerTemperature_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://dbpedia.org/ontology/summerTemperature$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/summerTemperature$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_summerTemperature_delta_new"(s, o) SELECT t1.o, t0.o FROM "dbrdf_summerTemperature_delta_old" t0, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 27020 AND ex.o = t0.o);


        -- <http://dbpedia.org/ontology/summerTemperature$delta_new>(?X0,?Y) :- <http://dbpedia.org/ontology/summerTemperature$delta_old>(?X0,?X1), owl:sameAs(?X1,?Y) .
        INSERT INTO "dbrdf_summerTemperature_delta_new"(s, o) SELECT t0.s, t1.o FROM "dbrdf_summerTemperature_delta_old" t0, "__triples" t1 WHERE t0.o = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 27020 AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 27020, t0.o FROM "dbrdf_summerTemperature_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_summerTemperature_delta_old";
        INSERT INTO "dbrdf_summerTemperature_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_summerTemperature_delta_new" t0;
        TRUNCATE TABLE "dbrdf_summerTemperature_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 538
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_shipDisplacement_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_shipDisplacement_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27021;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_shipDisplacement_delta_old" ON "dbrdf_shipDisplacement_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_shipDisplacement_delta_old" ON "dbrdf_shipDisplacement_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_shipDisplacement_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://dbpedia.org/ontology/shipDisplacement$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/shipDisplacement$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_shipDisplacement_delta_new"(s, o) SELECT t1.o, t0.o FROM "dbrdf_shipDisplacement_delta_old" t0, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 27021 AND ex.o = t0.o);


        -- <http://dbpedia.org/ontology/shipDisplacement$delta_new>(?X0,?Y) :- <http://dbpedia.org/ontology/shipDisplacement$delta_old>(?X0,?X1), owl:sameAs(?X1,?Y) .
        INSERT INTO "dbrdf_shipDisplacement_delta_new"(s, o) SELECT t0.s, t1.o FROM "dbrdf_shipDisplacement_delta_old" t0, "__triples" t1 WHERE t0.o = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 27021 AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 27021, t0.o FROM "dbrdf_shipDisplacement_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_shipDisplacement_delta_old";
        INSERT INTO "dbrdf_shipDisplacement_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_shipDisplacement_delta_new" t0;
        TRUNCATE TABLE "dbrdf_shipDisplacement_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 539
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_councilArea_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_councilArea_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27022;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_councilArea_delta_old" ON "dbrdf_councilArea_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_councilArea_delta_old" ON "dbrdf_councilArea_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_councilArea_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://dbpedia.org/ontology/councilArea$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/councilArea$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_councilArea_delta_new"(s, o) SELECT t1.o, t0.o FROM "dbrdf_councilArea_delta_old" t0, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 27022 AND ex.o = t0.o);


        -- <http://dbpedia.org/ontology/councilArea$delta_new>(?X0,?Y) :- <http://dbpedia.org/ontology/councilArea$delta_old>(?X0,?X1), owl:sameAs(?X1,?Y) .
        INSERT INTO "dbrdf_councilArea_delta_new"(s, o) SELECT t0.s, t1.o FROM "dbrdf_councilArea_delta_old" t0, "__triples" t1 WHERE t0.o = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 27022 AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 27022, t0.o FROM "dbrdf_councilArea_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_councilArea_delta_old";
        INSERT INTO "dbrdf_councilArea_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_councilArea_delta_new" t0;
        TRUNCATE TABLE "dbrdf_councilArea_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 540
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_projectStartDate_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_projectStartDate_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27023;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_projectStartDate_delta_old" ON "dbrdf_projectStartDate_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_projectStartDate_delta_old" ON "dbrdf_projectStartDate_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_projectStartDate_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://dbpedia.org/ontology/projectStartDate$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/projectStartDate$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_projectStartDate_delta_new"(s, o) SELECT t1.o, t0.o FROM "dbrdf_projectStartDate_delta_old" t0, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 27023 AND ex.o = t0.o);


        -- <http://dbpedia.org/ontology/projectStartDate$delta_new>(?X0,?Y) :- <http://dbpedia.org/ontology/projectStartDate$delta_old>(?X0,?X1), owl:sameAs(?X1,?Y) .
        INSERT INTO "dbrdf_projectStartDate_delta_new"(s, o) SELECT t0.s, t1.o FROM "dbrdf_projectStartDate_delta_old" t0, "__triples" t1 WHERE t0.o = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 27023 AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 27023, t0.o FROM "dbrdf_projectStartDate_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_projectStartDate_delta_old";
        INSERT INTO "dbrdf_projectStartDate_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_projectStartDate_delta_new" t0;
        TRUNCATE TABLE "dbrdf_projectStartDate_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 541
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_firstGame_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_firstGame_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27024;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_firstGame_delta_old" ON "dbrdf_firstGame_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_firstGame_delta_old" ON "dbrdf_firstGame_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_firstGame_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://dbpedia.org/ontology/firstGame$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/firstGame$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_firstGame_delta_new"(s, o) SELECT t1.o, t0.o FROM "dbrdf_firstGame_delta_old" t0, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 27024 AND ex.o = t0.o);


        -- <http://dbpedia.org/ontology/firstGame$delta_new>(?X0,?Y) :- <http://dbpedia.org/ontology/firstGame$delta_old>(?X0,?X1), owl:sameAs(?X1,?Y) .
        INSERT INTO "dbrdf_firstGame_delta_new"(s, o) SELECT t0.s, t1.o FROM "dbrdf_firstGame_delta_old" t0, "__triples" t1 WHERE t0.o = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 27024 AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 27024, t0.o FROM "dbrdf_firstGame_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_firstGame_delta_old";
        INSERT INTO "dbrdf_firstGame_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_firstGame_delta_new" t0;
        TRUNCATE TABLE "dbrdf_firstGame_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 542
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_loadLimit_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_loadLimit_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27025;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_loadLimit_delta_old" ON "dbrdf_loadLimit_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_loadLimit_delta_old" ON "dbrdf_loadLimit_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_loadLimit_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://dbpedia.org/ontology/loadLimit$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/loadLimit$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_loadLimit_delta_new"(s, o) SELECT t1.o, t0.o FROM "dbrdf_loadLimit_delta_old" t0, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 27025 AND ex.o = t0.o);


        -- <http://dbpedia.org/ontology/loadLimit$delta_new>(?X0,?Y) :- <http://dbpedia.org/ontology/loadLimit$delta_old>(?X0,?X1), owl:sameAs(?X1,?Y) .
        INSERT INTO "dbrdf_loadLimit_delta_new"(s, o) SELECT t0.s, t1.o FROM "dbrdf_loadLimit_delta_old" t0, "__triples" t1 WHERE t0.o = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 27025 AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 27025, t0.o FROM "dbrdf_loadLimit_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_loadLimit_delta_old";
        INSERT INTO "dbrdf_loadLimit_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_loadLimit_delta_new" t0;
        TRUNCATE TABLE "dbrdf_loadLimit_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 543
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_yearOfElectrification_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_yearOfElectrification_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27026;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_yearOfElectrification_delta_old" ON "dbrdf_yearOfElectrification_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_yearOfElectrification_delta_old" ON "dbrdf_yearOfElectrification_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_yearOfElectrification_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://dbpedia.org/ontology/yearOfElectrification$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/yearOfElectrification$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_yearOfElectrification_delta_new"(s, o) SELECT t1.o, t0.o FROM "dbrdf_yearOfElectrification_delta_old" t0, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 27026 AND ex.o = t0.o);


        -- <http://dbpedia.org/ontology/yearOfElectrification$delta_new>(?X0,?Y) :- <http://dbpedia.org/ontology/yearOfElectrification$delta_old>(?X0,?X1), owl:sameAs(?X1,?Y) .
        INSERT INTO "dbrdf_yearOfElectrification_delta_new"(s, o) SELECT t0.s, t1.o FROM "dbrdf_yearOfElectrification_delta_old" t0, "__triples" t1 WHERE t0.o = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 27026 AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 27026, t0.o FROM "dbrdf_yearOfElectrification_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_yearOfElectrification_delta_old";
        INSERT INTO "dbrdf_yearOfElectrification_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_yearOfElectrification_delta_new" t0;
        TRUNCATE TABLE "dbrdf_yearOfElectrification_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 544
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_cuisine_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_cuisine_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27027;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_cuisine_delta_old" ON "dbrdf_cuisine_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_cuisine_delta_old" ON "dbrdf_cuisine_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_cuisine_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://dbpedia.org/ontology/cuisine$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/cuisine$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_cuisine_delta_new"(s, o) SELECT t1.o, t0.o FROM "dbrdf_cuisine_delta_old" t0, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 27027 AND ex.o = t0.o);


        -- <http://dbpedia.org/ontology/cuisine$delta_new>(?X0,?Y) :- <http://dbpedia.org/ontology/cuisine$delta_old>(?X0,?X1), owl:sameAs(?X1,?Y) .
        INSERT INTO "dbrdf_cuisine_delta_new"(s, o) SELECT t0.s, t1.o FROM "dbrdf_cuisine_delta_old" t0, "__triples" t1 WHERE t0.o = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 27027 AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 27027, t0.o FROM "dbrdf_cuisine_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_cuisine_delta_old";
        INSERT INTO "dbrdf_cuisine_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_cuisine_delta_new" t0;
        TRUNCATE TABLE "dbrdf_cuisine_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 545
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_supplies_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_supplies_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27028;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_supplies_delta_old" ON "dbrdf_supplies_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_supplies_delta_old" ON "dbrdf_supplies_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_supplies_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://dbpedia.org/ontology/supplies$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/supplies$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_supplies_delta_new"(s, o) SELECT t1.o, t0.o FROM "dbrdf_supplies_delta_old" t0, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 27028 AND ex.o = t0.o);


        -- <http://dbpedia.org/ontology/supplies$delta_new>(?X0,?Y) :- <http://dbpedia.org/ontology/supplies$delta_old>(?X0,?X1), owl:sameAs(?X1,?Y) .
        INSERT INTO "dbrdf_supplies_delta_new"(s, o) SELECT t0.s, t1.o FROM "dbrdf_supplies_delta_old" t0, "__triples" t1 WHERE t0.o = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 27028 AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 27028, t0.o FROM "dbrdf_supplies_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_supplies_delta_old";
        INSERT INTO "dbrdf_supplies_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_supplies_delta_new" t0;
        TRUNCATE TABLE "dbrdf_supplies_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 546
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_PowerStation_delta_old"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_PowerStation_delta_old"(s) SELECT t0.s FROM "__triples" t0 WHERE t0.p = 2 AND t0.o = 27029;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_PowerStation_delta_old" ON "dbrdf_PowerStation_delta_old"(s);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_PowerStation_delta_new"(s integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://dbpedia.org/ontology/PowerStation$delta_new>(?Y) :- <http://dbpedia.org/ontology/PowerStation$delta_old>(?X0), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_PowerStation_delta_new"(s) SELECT t1.o FROM "dbrdf_PowerStation_delta_old" t0, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 2 AND ex.o = 27029);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 2, 27029 FROM "dbrdf_PowerStation_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_PowerStation_delta_old";
        INSERT INTO "dbrdf_PowerStation_delta_old"(s) SELECT DISTINCT t0.s FROM "dbrdf_PowerStation_delta_new" t0;
        TRUNCATE TABLE "dbrdf_PowerStation_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 547
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_transmission_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_transmission_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27030;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_transmission_delta_old" ON "dbrdf_transmission_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_transmission_delta_old" ON "dbrdf_transmission_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_transmission_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://dbpedia.org/ontology/transmission$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/transmission$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_transmission_delta_new"(s, o) SELECT t1.o, t0.o FROM "dbrdf_transmission_delta_old" t0, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 27030 AND ex.o = t0.o);


        -- <http://dbpedia.org/ontology/transmission$delta_new>(?X0,?Y) :- <http://dbpedia.org/ontology/transmission$delta_old>(?X0,?X1), owl:sameAs(?X1,?Y) .
        INSERT INTO "dbrdf_transmission_delta_new"(s, o) SELECT t0.s, t1.o FROM "dbrdf_transmission_delta_old" t0, "__triples" t1 WHERE t0.o = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 27030 AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 27030, t0.o FROM "dbrdf_transmission_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_transmission_delta_old";
        INSERT INTO "dbrdf_transmission_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_transmission_delta_new" t0;
        TRUNCATE TABLE "dbrdf_transmission_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 548
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_inchi_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_inchi_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27031;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_inchi_delta_old" ON "dbrdf_inchi_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_inchi_delta_old" ON "dbrdf_inchi_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_inchi_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://dbpedia.org/ontology/inchi$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/inchi$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_inchi_delta_new"(s, o) SELECT t1.o, t0.o FROM "dbrdf_inchi_delta_old" t0, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 27031 AND ex.o = t0.o);


        -- <http://dbpedia.org/ontology/inchi$delta_new>(?X0,?Y) :- <http://dbpedia.org/ontology/inchi$delta_old>(?X0,?X1), owl:sameAs(?X1,?Y) .
        INSERT INTO "dbrdf_inchi_delta_new"(s, o) SELECT t0.s, t1.o FROM "dbrdf_inchi_delta_old" t0, "__triples" t1 WHERE t0.o = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 27031 AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 27031, t0.o FROM "dbrdf_inchi_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_inchi_delta_old";
        INSERT INTO "dbrdf_inchi_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_inchi_delta_new" t0;
        TRUNCATE TABLE "dbrdf_inchi_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 549
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_bSide_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_bSide_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27032;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_bSide_delta_old" ON "dbrdf_bSide_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_bSide_delta_old" ON "dbrdf_bSide_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_bSide_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://dbpedia.org/ontology/bSide$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/bSide$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_bSide_delta_new"(s, o) SELECT t1.o, t0.o FROM "dbrdf_bSide_delta_old" t0, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 27032 AND ex.o = t0.o);


        -- <http://dbpedia.org/ontology/bSide$delta_new>(?X0,?Y) :- <http://dbpedia.org/ontology/bSide$delta_old>(?X0,?X1), owl:sameAs(?X1,?Y) .
        INSERT INTO "dbrdf_bSide_delta_new"(s, o) SELECT t0.s, t1.o FROM "dbrdf_bSide_delta_old" t0, "__triples" t1 WHERE t0.o = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 27032 AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 27032, t0.o FROM "dbrdf_bSide_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_bSide_delta_old";
        INSERT INTO "dbrdf_bSide_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_bSide_delta_new" t0;
        TRUNCATE TABLE "dbrdf_bSide_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 550
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_headAlloy_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_headAlloy_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27033;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_headAlloy_delta_old" ON "dbrdf_headAlloy_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_headAlloy_delta_old" ON "dbrdf_headAlloy_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_headAlloy_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://dbpedia.org/ontology/headAlloy$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/headAlloy$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_headAlloy_delta_new"(s, o) SELECT t1.o, t0.o FROM "dbrdf_headAlloy_delta_old" t0, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 27033 AND ex.o = t0.o);


        -- <http://dbpedia.org/ontology/headAlloy$delta_new>(?X0,?Y) :- <http://dbpedia.org/ontology/headAlloy$delta_old>(?X0,?X1), owl:sameAs(?X1,?Y) .
        INSERT INTO "dbrdf_headAlloy_delta_new"(s, o) SELECT t0.s, t1.o FROM "dbrdf_headAlloy_delta_old" t0, "__triples" t1 WHERE t0.o = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 27033 AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 27033, t0.o FROM "dbrdf_headAlloy_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_headAlloy_delta_old";
        INSERT INTO "dbrdf_headAlloy_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_headAlloy_delta_new" t0;
        TRUNCATE TABLE "dbrdf_headAlloy_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 551
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_numberOfMinistries_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_numberOfMinistries_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27034;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_numberOfMinistries_delta_old" ON "dbrdf_numberOfMinistries_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_numberOfMinistries_delta_old" ON "dbrdf_numberOfMinistries_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_numberOfMinistries_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://dbpedia.org/ontology/numberOfMinistries$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/numberOfMinistries$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_numberOfMinistries_delta_new"(s, o) SELECT t1.o, t0.o FROM "dbrdf_numberOfMinistries_delta_old" t0, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 27034 AND ex.o = t0.o);


        -- <http://dbpedia.org/ontology/numberOfMinistries$delta_new>(?X0,?Y) :- <http://dbpedia.org/ontology/numberOfMinistries$delta_old>(?X0,?X1), owl:sameAs(?X1,?Y) .
        INSERT INTO "dbrdf_numberOfMinistries_delta_new"(s, o) SELECT t0.s, t1.o FROM "dbrdf_numberOfMinistries_delta_old" t0, "__triples" t1 WHERE t0.o = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 27034 AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 27034, t0.o FROM "dbrdf_numberOfMinistries_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_numberOfMinistries_delta_old";
        INSERT INTO "dbrdf_numberOfMinistries_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_numberOfMinistries_delta_new" t0;
        TRUNCATE TABLE "dbrdf_numberOfMinistries_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 552
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_dorlandsPrefix_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_dorlandsPrefix_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27035;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_dorlandsPrefix_delta_old" ON "dbrdf_dorlandsPrefix_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_dorlandsPrefix_delta_old" ON "dbrdf_dorlandsPrefix_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_dorlandsPrefix_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://dbpedia.org/ontology/dorlandsPrefix$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/dorlandsPrefix$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_dorlandsPrefix_delta_new"(s, o) SELECT t1.o, t0.o FROM "dbrdf_dorlandsPrefix_delta_old" t0, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 27035 AND ex.o = t0.o);


        -- <http://dbpedia.org/ontology/dorlandsPrefix$delta_new>(?X0,?Y) :- <http://dbpedia.org/ontology/dorlandsPrefix$delta_old>(?X0,?X1), owl:sameAs(?X1,?Y) .
        INSERT INTO "dbrdf_dorlandsPrefix_delta_new"(s, o) SELECT t0.s, t1.o FROM "dbrdf_dorlandsPrefix_delta_old" t0, "__triples" t1 WHERE t0.o = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 27035 AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 27035, t0.o FROM "dbrdf_dorlandsPrefix_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_dorlandsPrefix_delta_old";
        INSERT INTO "dbrdf_dorlandsPrefix_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_dorlandsPrefix_delta_new" t0;
        TRUNCATE TABLE "dbrdf_dorlandsPrefix_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 553
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_giniCoefficientRanking_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_giniCoefficientRanking_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27036;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_giniCoefficientRanking_delta_old" ON "dbrdf_giniCoefficientRanking_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_giniCoefficientRanking_delta_old" ON "dbrdf_giniCoefficientRanking_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_giniCoefficientRanking_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://dbpedia.org/ontology/giniCoefficientRanking$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/giniCoefficientRanking$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_giniCoefficientRanking_delta_new"(s, o) SELECT t1.o, t0.o FROM "dbrdf_giniCoefficientRanking_delta_old" t0, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 27036 AND ex.o = t0.o);


        -- <http://dbpedia.org/ontology/giniCoefficientRanking$delta_new>(?X0,?Y) :- <http://dbpedia.org/ontology/giniCoefficientRanking$delta_old>(?X0,?X1), owl:sameAs(?X1,?Y) .
        INSERT INTO "dbrdf_giniCoefficientRanking_delta_new"(s, o) SELECT t0.s, t1.o FROM "dbrdf_giniCoefficientRanking_delta_old" t0, "__triples" t1 WHERE t0.o = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 27036 AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 27036, t0.o FROM "dbrdf_giniCoefficientRanking_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_giniCoefficientRanking_delta_old";
        INSERT INTO "dbrdf_giniCoefficientRanking_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_giniCoefficientRanking_delta_new" t0;
        TRUNCATE TABLE "dbrdf_giniCoefficientRanking_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 554
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_coronationDate_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_coronationDate_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27037;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_coronationDate_delta_old" ON "dbrdf_coronationDate_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_coronationDate_delta_old" ON "dbrdf_coronationDate_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_coronationDate_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://dbpedia.org/ontology/coronationDate$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/coronationDate$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_coronationDate_delta_new"(s, o) SELECT t1.o, t0.o FROM "dbrdf_coronationDate_delta_old" t0, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 27037 AND ex.o = t0.o);


        -- <http://dbpedia.org/ontology/coronationDate$delta_new>(?X0,?Y) :- <http://dbpedia.org/ontology/coronationDate$delta_old>(?X0,?X1), owl:sameAs(?X1,?Y) .
        INSERT INTO "dbrdf_coronationDate_delta_new"(s, o) SELECT t0.s, t1.o FROM "dbrdf_coronationDate_delta_old" t0, "__triples" t1 WHERE t0.o = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 27037 AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 27037, t0.o FROM "dbrdf_coronationDate_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_coronationDate_delta_old";
        INSERT INTO "dbrdf_coronationDate_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_coronationDate_delta_new" t0;
        TRUNCATE TABLE "dbrdf_coronationDate_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 555
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_passengersPerYear_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_passengersPerYear_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27038;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_passengersPerYear_delta_old" ON "dbrdf_passengersPerYear_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_passengersPerYear_delta_old" ON "dbrdf_passengersPerYear_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_passengersPerYear_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://dbpedia.org/ontology/passengersPerYear$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/passengersPerYear$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_passengersPerYear_delta_new"(s, o) SELECT t1.o, t0.o FROM "dbrdf_passengersPerYear_delta_old" t0, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 27038 AND ex.o = t0.o);


        -- <http://dbpedia.org/ontology/passengersPerYear$delta_new>(?X0,?Y) :- <http://dbpedia.org/ontology/passengersPerYear$delta_old>(?X0,?X1), owl:sameAs(?X1,?Y) .
        INSERT INTO "dbrdf_passengersPerYear_delta_new"(s, o) SELECT t0.s, t1.o FROM "dbrdf_passengersPerYear_delta_old" t0, "__triples" t1 WHERE t0.o = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 27038 AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 27038, t0.o FROM "dbrdf_passengersPerYear_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_passengersPerYear_delta_old";
        INSERT INTO "dbrdf_passengersPerYear_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_passengersPerYear_delta_new" t0;
        TRUNCATE TABLE "dbrdf_passengersPerYear_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 556
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_lounge_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_lounge_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27039;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_lounge_delta_old" ON "dbrdf_lounge_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_lounge_delta_old" ON "dbrdf_lounge_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_lounge_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://dbpedia.org/ontology/lounge$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/lounge$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_lounge_delta_new"(s, o) SELECT t1.o, t0.o FROM "dbrdf_lounge_delta_old" t0, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 27039 AND ex.o = t0.o);


        -- <http://dbpedia.org/ontology/lounge$delta_new>(?X0,?Y) :- <http://dbpedia.org/ontology/lounge$delta_old>(?X0,?X1), owl:sameAs(?X1,?Y) .
        INSERT INTO "dbrdf_lounge_delta_new"(s, o) SELECT t0.s, t1.o FROM "dbrdf_lounge_delta_old" t0, "__triples" t1 WHERE t0.o = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 27039 AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 27039, t0.o FROM "dbrdf_lounge_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_lounge_delta_old";
        INSERT INTO "dbrdf_lounge_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_lounge_delta_new" t0;
        TRUNCATE TABLE "dbrdf_lounge_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 557
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_shoeNumber_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_shoeNumber_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27040;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_shoeNumber_delta_old" ON "dbrdf_shoeNumber_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_shoeNumber_delta_old" ON "dbrdf_shoeNumber_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_shoeNumber_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://dbpedia.org/ontology/shoeNumber$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/shoeNumber$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_shoeNumber_delta_new"(s, o) SELECT t1.o, t0.o FROM "dbrdf_shoeNumber_delta_old" t0, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 27040 AND ex.o = t0.o);


        -- <http://dbpedia.org/ontology/shoeNumber$delta_new>(?X0,?Y) :- <http://dbpedia.org/ontology/shoeNumber$delta_old>(?X0,?X1), owl:sameAs(?X1,?Y) .
        INSERT INTO "dbrdf_shoeNumber_delta_new"(s, o) SELECT t0.s, t1.o FROM "dbrdf_shoeNumber_delta_old" t0, "__triples" t1 WHERE t0.o = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 27040 AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 27040, t0.o FROM "dbrdf_shoeNumber_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_shoeNumber_delta_old";
        INSERT INTO "dbrdf_shoeNumber_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_shoeNumber_delta_new" t0;
        TRUNCATE TABLE "dbrdf_shoeNumber_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 558
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_numberOfRooms_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_numberOfRooms_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27041;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_numberOfRooms_delta_old" ON "dbrdf_numberOfRooms_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_numberOfRooms_delta_old" ON "dbrdf_numberOfRooms_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_numberOfRooms_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://dbpedia.org/ontology/numberOfRooms$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/numberOfRooms$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_numberOfRooms_delta_new"(s, o) SELECT t1.o, t0.o FROM "dbrdf_numberOfRooms_delta_old" t0, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 27041 AND ex.o = t0.o);


        -- <http://dbpedia.org/ontology/numberOfRooms$delta_new>(?X0,?Y) :- <http://dbpedia.org/ontology/numberOfRooms$delta_old>(?X0,?X1), owl:sameAs(?X1,?Y) .
        INSERT INTO "dbrdf_numberOfRooms_delta_new"(s, o) SELECT t0.s, t1.o FROM "dbrdf_numberOfRooms_delta_old" t0, "__triples" t1 WHERE t0.o = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 27041 AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 27041, t0.o FROM "dbrdf_numberOfRooms_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_numberOfRooms_delta_old";
        INSERT INTO "dbrdf_numberOfRooms_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_numberOfRooms_delta_new" t0;
        TRUNCATE TABLE "dbrdf_numberOfRooms_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 559
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_wikiPageID_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_wikiPageID_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27042;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_wikiPageID_delta_old" ON "dbrdf_wikiPageID_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_wikiPageID_delta_old" ON "dbrdf_wikiPageID_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_wikiPageID_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://dbpedia.org/ontology/wikiPageID$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/wikiPageID$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_wikiPageID_delta_new"(s, o) SELECT t1.o, t0.o FROM "dbrdf_wikiPageID_delta_old" t0, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 27042 AND ex.o = t0.o);


        -- <http://dbpedia.org/ontology/wikiPageID$delta_new>(?X0,?Y) :- <http://dbpedia.org/ontology/wikiPageID$delta_old>(?X0,?X1), owl:sameAs(?X1,?Y) .
        INSERT INTO "dbrdf_wikiPageID_delta_new"(s, o) SELECT t0.s, t1.o FROM "dbrdf_wikiPageID_delta_old" t0, "__triples" t1 WHERE t0.o = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 27042 AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 27042, t0.o FROM "dbrdf_wikiPageID_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_wikiPageID_delta_old";
        INSERT INTO "dbrdf_wikiPageID_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_wikiPageID_delta_new" t0;
        TRUNCATE TABLE "dbrdf_wikiPageID_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 560
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_atcPrefix_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_atcPrefix_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27043;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_atcPrefix_delta_old" ON "dbrdf_atcPrefix_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_atcPrefix_delta_old" ON "dbrdf_atcPrefix_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_atcPrefix_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://dbpedia.org/ontology/atcPrefix$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/atcPrefix$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_atcPrefix_delta_new"(s, o) SELECT t1.o, t0.o FROM "dbrdf_atcPrefix_delta_old" t0, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 27043 AND ex.o = t0.o);


        -- <http://dbpedia.org/ontology/atcPrefix$delta_new>(?X0,?Y) :- <http://dbpedia.org/ontology/atcPrefix$delta_old>(?X0,?X1), owl:sameAs(?X1,?Y) .
        INSERT INTO "dbrdf_atcPrefix_delta_new"(s, o) SELECT t0.s, t1.o FROM "dbrdf_atcPrefix_delta_old" t0, "__triples" t1 WHERE t0.o = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 27043 AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 27043, t0.o FROM "dbrdf_atcPrefix_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_atcPrefix_delta_old";
        INSERT INTO "dbrdf_atcPrefix_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_atcPrefix_delta_new" t0;
        TRUNCATE TABLE "dbrdf_atcPrefix_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 561
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_numberOfTracks_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_numberOfTracks_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27044;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_numberOfTracks_delta_old" ON "dbrdf_numberOfTracks_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_numberOfTracks_delta_old" ON "dbrdf_numberOfTracks_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_numberOfTracks_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://dbpedia.org/ontology/numberOfTracks$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/numberOfTracks$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_numberOfTracks_delta_new"(s, o) SELECT t1.o, t0.o FROM "dbrdf_numberOfTracks_delta_old" t0, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 27044 AND ex.o = t0.o);


        -- <http://dbpedia.org/ontology/numberOfTracks$delta_new>(?X0,?Y) :- <http://dbpedia.org/ontology/numberOfTracks$delta_old>(?X0,?X1), owl:sameAs(?X1,?Y) .
        INSERT INTO "dbrdf_numberOfTracks_delta_new"(s, o) SELECT t0.s, t1.o FROM "dbrdf_numberOfTracks_delta_old" t0, "__triples" t1 WHERE t0.o = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 27044 AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 27044, t0.o FROM "dbrdf_numberOfTracks_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_numberOfTracks_delta_old";
        INSERT INTO "dbrdf_numberOfTracks_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_numberOfTracks_delta_new" t0;
        TRUNCATE TABLE "dbrdf_numberOfTracks_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 562
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_projectReferenceID_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_projectReferenceID_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27045;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_projectReferenceID_delta_old" ON "dbrdf_projectReferenceID_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_projectReferenceID_delta_old" ON "dbrdf_projectReferenceID_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_projectReferenceID_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://dbpedia.org/ontology/projectReferenceID$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/projectReferenceID$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_projectReferenceID_delta_new"(s, o) SELECT t1.o, t0.o FROM "dbrdf_projectReferenceID_delta_old" t0, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 27045 AND ex.o = t0.o);


        -- <http://dbpedia.org/ontology/projectReferenceID$delta_new>(?X0,?Y) :- <http://dbpedia.org/ontology/projectReferenceID$delta_old>(?X0,?X1), owl:sameAs(?X1,?Y) .
        INSERT INTO "dbrdf_projectReferenceID_delta_new"(s, o) SELECT t0.s, t1.o FROM "dbrdf_projectReferenceID_delta_old" t0, "__triples" t1 WHERE t0.o = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 27045 AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 27045, t0.o FROM "dbrdf_projectReferenceID_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_projectReferenceID_delta_old";
        INSERT INTO "dbrdf_projectReferenceID_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_projectReferenceID_delta_new" t0;
        TRUNCATE TABLE "dbrdf_projectReferenceID_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 563
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_patent_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_patent_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27046;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_patent_delta_old" ON "dbrdf_patent_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_patent_delta_old" ON "dbrdf_patent_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_patent_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://dbpedia.org/ontology/patent$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/patent$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_patent_delta_new"(s, o) SELECT t1.o, t0.o FROM "dbrdf_patent_delta_old" t0, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 27046 AND ex.o = t0.o);


        -- <http://dbpedia.org/ontology/patent$delta_new>(?X0,?Y) :- <http://dbpedia.org/ontology/patent$delta_old>(?X0,?X1), owl:sameAs(?X1,?Y) .
        INSERT INTO "dbrdf_patent_delta_new"(s, o) SELECT t0.s, t1.o FROM "dbrdf_patent_delta_old" t0, "__triples" t1 WHERE t0.o = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 27046 AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 27046, t0.o FROM "dbrdf_patent_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_patent_delta_old";
        INSERT INTO "dbrdf_patent_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_patent_delta_new" t0;
        TRUNCATE TABLE "dbrdf_patent_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 564
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_GovernmentOrganization_delta_old"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_GovernmentOrganization_delta_old"(s) SELECT t0.s FROM "__triples" t0 WHERE t0.p = 2 AND t0.o = 27047;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_GovernmentOrganization_delta_old" ON "dbrdf_GovernmentOrganization_delta_old"(s);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_GovernmentOrganization_delta_new"(s integer) ON COMMIT DROP;
    CREATE LOCAL TEMPORARY TABLE "dbrdf_GovernmentAgency_delta_old"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_GovernmentAgency_delta_old"(s) SELECT t0.s FROM "__triples" t0 WHERE t0.p = 2 AND t0.o = 27048;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_GovernmentAgency_delta_old" ON "dbrdf_GovernmentAgency_delta_old"(s);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_GovernmentAgency_delta_new"(s integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://schema.org/GovernmentOrganization$delta_new>(?X) :- <http://dbpedia.org/ontology/GovernmentAgency$delta_old>(?X) .
        INSERT INTO "dbrdf_GovernmentOrganization_delta_new"(s) SELECT t0.s FROM "dbrdf_GovernmentAgency_delta_old" t0 WHERE NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 2 AND ex.o = 27047);


        -- <http://schema.org/GovernmentOrganization$delta_new>(?Y) :- <http://schema.org/GovernmentOrganization$delta_old>(?X0), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_GovernmentOrganization_delta_new"(s) SELECT t1.o FROM "dbrdf_GovernmentOrganization_delta_old" t0, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 2 AND ex.o = 27047);


        -- <http://dbpedia.org/ontology/GovernmentAgency$delta_new>(?X) :- <http://schema.org/GovernmentOrganization$delta_old>(?X) .
        INSERT INTO "dbrdf_GovernmentAgency_delta_new"(s) SELECT t0.s FROM "dbrdf_GovernmentOrganization_delta_old" t0 WHERE NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 2 AND ex.o = 27048);


        -- <http://dbpedia.org/ontology/GovernmentAgency$delta_new>(?Y) :- <http://dbpedia.org/ontology/GovernmentAgency$delta_old>(?X0), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_GovernmentAgency_delta_new"(s) SELECT t1.o FROM "dbrdf_GovernmentAgency_delta_old" t0, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 2 AND ex.o = 27048);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 2, 27047 FROM "dbrdf_GovernmentOrganization_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_GovernmentOrganization_delta_old";
        INSERT INTO "dbrdf_GovernmentOrganization_delta_old"(s) SELECT DISTINCT t0.s FROM "dbrdf_GovernmentOrganization_delta_new" t0;
        TRUNCATE TABLE "dbrdf_GovernmentOrganization_delta_new";

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 2, 27048 FROM "dbrdf_GovernmentAgency_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_GovernmentAgency_delta_old";
        INSERT INTO "dbrdf_GovernmentAgency_delta_old"(s) SELECT DISTINCT t0.s FROM "dbrdf_GovernmentAgency_delta_new" t0;
        TRUNCATE TABLE "dbrdf_GovernmentAgency_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 565
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_publicationDate_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_publicationDate_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27049;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_publicationDate_delta_old" ON "dbrdf_publicationDate_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_publicationDate_delta_old" ON "dbrdf_publicationDate_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_publicationDate_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://dbpedia.org/ontology/publicationDate$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/publicationDate$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_publicationDate_delta_new"(s, o) SELECT t1.o, t0.o FROM "dbrdf_publicationDate_delta_old" t0, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 27049 AND ex.o = t0.o);


        -- <http://dbpedia.org/ontology/publicationDate$delta_new>(?X0,?Y) :- <http://dbpedia.org/ontology/publicationDate$delta_old>(?X0,?X1), owl:sameAs(?X1,?Y) .
        INSERT INTO "dbrdf_publicationDate_delta_new"(s, o) SELECT t0.s, t1.o FROM "dbrdf_publicationDate_delta_old" t0, "__triples" t1 WHERE t0.o = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 27049 AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 27049, t0.o FROM "dbrdf_publicationDate_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_publicationDate_delta_old";
        INSERT INTO "dbrdf_publicationDate_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_publicationDate_delta_new" t0;
        TRUNCATE TABLE "dbrdf_publicationDate_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 566
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_bronzeMedalist_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_bronzeMedalist_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27050;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_bronzeMedalist_delta_old" ON "dbrdf_bronzeMedalist_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_bronzeMedalist_delta_old" ON "dbrdf_bronzeMedalist_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_bronzeMedalist_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://dbpedia.org/ontology/bronzeMedalist$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/bronzeMedalist$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_bronzeMedalist_delta_new"(s, o) SELECT t1.o, t0.o FROM "dbrdf_bronzeMedalist_delta_old" t0, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 27050 AND ex.o = t0.o);


        -- <http://dbpedia.org/ontology/bronzeMedalist$delta_new>(?X0,?Y) :- <http://dbpedia.org/ontology/bronzeMedalist$delta_old>(?X0,?X1), owl:sameAs(?X1,?Y) .
        INSERT INTO "dbrdf_bronzeMedalist_delta_new"(s, o) SELECT t0.s, t1.o FROM "dbrdf_bronzeMedalist_delta_old" t0, "__triples" t1 WHERE t0.o = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 27050 AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 27050, t0.o FROM "dbrdf_bronzeMedalist_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_bronzeMedalist_delta_old";
        INSERT INTO "dbrdf_bronzeMedalist_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_bronzeMedalist_delta_new" t0;
        TRUNCATE TABLE "dbrdf_bronzeMedalist_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 567
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_annualTemperature_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_annualTemperature_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27051;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_annualTemperature_delta_old" ON "dbrdf_annualTemperature_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_annualTemperature_delta_old" ON "dbrdf_annualTemperature_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_annualTemperature_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://dbpedia.org/ontology/annualTemperature$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/annualTemperature$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_annualTemperature_delta_new"(s, o) SELECT t1.o, t0.o FROM "dbrdf_annualTemperature_delta_old" t0, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 27051 AND ex.o = t0.o);


        -- <http://dbpedia.org/ontology/annualTemperature$delta_new>(?X0,?Y) :- <http://dbpedia.org/ontology/annualTemperature$delta_old>(?X0,?X1), owl:sameAs(?X1,?Y) .
        INSERT INTO "dbrdf_annualTemperature_delta_new"(s, o) SELECT t0.s, t1.o FROM "dbrdf_annualTemperature_delta_old" t0, "__triples" t1 WHERE t0.o = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 27051 AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 27051, t0.o FROM "dbrdf_annualTemperature_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_annualTemperature_delta_old";
        INSERT INTO "dbrdf_annualTemperature_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_annualTemperature_delta_new" t0;
        TRUNCATE TABLE "dbrdf_annualTemperature_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 568
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_individualisedPnd_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_individualisedPnd_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27052;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_individualisedPnd_delta_old" ON "dbrdf_individualisedPnd_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_individualisedPnd_delta_old" ON "dbrdf_individualisedPnd_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_individualisedPnd_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://dbpedia.org/ontology/individualisedPnd$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/individualisedPnd$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_individualisedPnd_delta_new"(s, o) SELECT t1.o, t0.o FROM "dbrdf_individualisedPnd_delta_old" t0, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 27052 AND ex.o = t0.o);


        -- <http://dbpedia.org/ontology/individualisedPnd$delta_new>(?X0,?Y) :- <http://dbpedia.org/ontology/individualisedPnd$delta_old>(?X0,?X1), owl:sameAs(?X1,?Y) .
        INSERT INTO "dbrdf_individualisedPnd_delta_new"(s, o) SELECT t0.s, t1.o FROM "dbrdf_individualisedPnd_delta_old" t0, "__triples" t1 WHERE t0.o = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 27052 AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 27052, t0.o FROM "dbrdf_individualisedPnd_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_individualisedPnd_delta_old";
        INSERT INTO "dbrdf_individualisedPnd_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_individualisedPnd_delta_new" t0;
        TRUNCATE TABLE "dbrdf_individualisedPnd_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 569
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_secondPopularVote_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_secondPopularVote_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27053;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_secondPopularVote_delta_old" ON "dbrdf_secondPopularVote_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_secondPopularVote_delta_old" ON "dbrdf_secondPopularVote_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_secondPopularVote_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://dbpedia.org/ontology/secondPopularVote$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/secondPopularVote$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_secondPopularVote_delta_new"(s, o) SELECT t1.o, t0.o FROM "dbrdf_secondPopularVote_delta_old" t0, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 27053 AND ex.o = t0.o);


        -- <http://dbpedia.org/ontology/secondPopularVote$delta_new>(?X0,?Y) :- <http://dbpedia.org/ontology/secondPopularVote$delta_old>(?X0,?X1), owl:sameAs(?X1,?Y) .
        INSERT INTO "dbrdf_secondPopularVote_delta_new"(s, o) SELECT t0.s, t1.o FROM "dbrdf_secondPopularVote_delta_old" t0, "__triples" t1 WHERE t0.o = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 27053 AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 27053, t0.o FROM "dbrdf_secondPopularVote_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_secondPopularVote_delta_old";
        INSERT INTO "dbrdf_secondPopularVote_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_secondPopularVote_delta_new" t0;
        TRUNCATE TABLE "dbrdf_secondPopularVote_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 570
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_education_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_education_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27054;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_education_delta_old" ON "dbrdf_education_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_education_delta_old" ON "dbrdf_education_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_education_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://dbpedia.org/ontology/education$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/education$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_education_delta_new"(s, o) SELECT t1.o, t0.o FROM "dbrdf_education_delta_old" t0, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 27054 AND ex.o = t0.o);


        -- <http://dbpedia.org/ontology/education$delta_new>(?X0,?Y) :- <http://dbpedia.org/ontology/education$delta_old>(?X0,?X1), owl:sameAs(?X1,?Y) .
        INSERT INTO "dbrdf_education_delta_new"(s, o) SELECT t0.s, t1.o FROM "dbrdf_education_delta_old" t0, "__triples" t1 WHERE t0.o = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 27054 AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 27054, t0.o FROM "dbrdf_education_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_education_delta_old";
        INSERT INTO "dbrdf_education_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_education_delta_new" t0;
        TRUNCATE TABLE "dbrdf_education_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 571
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_buildingStartDate_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_buildingStartDate_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27055;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_buildingStartDate_delta_old" ON "dbrdf_buildingStartDate_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_buildingStartDate_delta_old" ON "dbrdf_buildingStartDate_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_buildingStartDate_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://dbpedia.org/ontology/buildingStartDate$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/buildingStartDate$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_buildingStartDate_delta_new"(s, o) SELECT t1.o, t0.o FROM "dbrdf_buildingStartDate_delta_old" t0, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 27055 AND ex.o = t0.o);


        -- <http://dbpedia.org/ontology/buildingStartDate$delta_new>(?X0,?Y) :- <http://dbpedia.org/ontology/buildingStartDate$delta_old>(?X0,?X1), owl:sameAs(?X1,?Y) .
        INSERT INTO "dbrdf_buildingStartDate_delta_new"(s, o) SELECT t0.s, t1.o FROM "dbrdf_buildingStartDate_delta_old" t0, "__triples" t1 WHERE t0.o = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 27055 AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 27055, t0.o FROM "dbrdf_buildingStartDate_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_buildingStartDate_delta_old";
        INSERT INTO "dbrdf_buildingStartDate_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_buildingStartDate_delta_new" t0;
        TRUNCATE TABLE "dbrdf_buildingStartDate_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 572
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_length_delta_old2"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_length_delta_old2"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27056;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_length_delta_old2" ON "dbrdf_length_delta_old2"(s, o); CREATE INDEX "IDX_1_dbrdf_length_delta_old2" ON "dbrdf_length_delta_old2"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_length_delta_new2"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://dbpedia.org/ontology/Infrastructure/length$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/Infrastructure/length$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_length_delta_new2"(s, o) SELECT t1.o, t0.o FROM "dbrdf_length_delta_old2" t0, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 27056 AND ex.o = t0.o);


        -- <http://dbpedia.org/ontology/Infrastructure/length$delta_new>(?X0,?Y) :- <http://dbpedia.org/ontology/Infrastructure/length$delta_old>(?X0,?X1), owl:sameAs(?X1,?Y) .
        INSERT INTO "dbrdf_length_delta_new2"(s, o) SELECT t0.s, t1.o FROM "dbrdf_length_delta_old2" t0, "__triples" t1 WHERE t0.o = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 27056 AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 27056, t0.o FROM "dbrdf_length_delta_new2" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_length_delta_old2";
        INSERT INTO "dbrdf_length_delta_old2"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_length_delta_new2" t0;
        TRUNCATE TABLE "dbrdf_length_delta_new2";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 573
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_facultySize_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_facultySize_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27057;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_facultySize_delta_old" ON "dbrdf_facultySize_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_facultySize_delta_old" ON "dbrdf_facultySize_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_facultySize_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://dbpedia.org/ontology/facultySize$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/facultySize$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_facultySize_delta_new"(s, o) SELECT t1.o, t0.o FROM "dbrdf_facultySize_delta_old" t0, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 27057 AND ex.o = t0.o);


        -- <http://dbpedia.org/ontology/facultySize$delta_new>(?X0,?Y) :- <http://dbpedia.org/ontology/facultySize$delta_old>(?X0,?X1), owl:sameAs(?X1,?Y) .
        INSERT INTO "dbrdf_facultySize_delta_new"(s, o) SELECT t0.s, t1.o FROM "dbrdf_facultySize_delta_old" t0, "__triples" t1 WHERE t0.o = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 27057 AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 27057, t0.o FROM "dbrdf_facultySize_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_facultySize_delta_old";
        INSERT INTO "dbrdf_facultySize_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_facultySize_delta_new" t0;
        TRUNCATE TABLE "dbrdf_facultySize_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 574
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_routeStartDirection_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_routeStartDirection_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27058;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_routeStartDirection_delta_old" ON "dbrdf_routeStartDirection_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_routeStartDirection_delta_old" ON "dbrdf_routeStartDirection_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_routeStartDirection_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://dbpedia.org/ontology/routeStartDirection$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/routeStartDirection$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_routeStartDirection_delta_new"(s, o) SELECT t1.o, t0.o FROM "dbrdf_routeStartDirection_delta_old" t0, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 27058 AND ex.o = t0.o);


        -- <http://dbpedia.org/ontology/routeStartDirection$delta_new>(?X0,?Y) :- <http://dbpedia.org/ontology/routeStartDirection$delta_old>(?X0,?X1), owl:sameAs(?X1,?Y) .
        INSERT INTO "dbrdf_routeStartDirection_delta_new"(s, o) SELECT t0.s, t1.o FROM "dbrdf_routeStartDirection_delta_old" t0, "__triples" t1 WHERE t0.o = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 27058 AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 27058, t0.o FROM "dbrdf_routeStartDirection_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_routeStartDirection_delta_old";
        INSERT INTO "dbrdf_routeStartDirection_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_routeStartDirection_delta_new" t0;
        TRUNCATE TABLE "dbrdf_routeStartDirection_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 575
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_mass_delta_old1"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_mass_delta_old1"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27059;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_mass_delta_old1" ON "dbrdf_mass_delta_old1"(s, o); CREATE INDEX "IDX_1_dbrdf_mass_delta_old1" ON "dbrdf_mass_delta_old1"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_mass_delta_new1"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://dbpedia.org/ontology/Rocket/mass$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/Rocket/mass$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_mass_delta_new1"(s, o) SELECT t1.o, t0.o FROM "dbrdf_mass_delta_old1" t0, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 27059 AND ex.o = t0.o);


        -- <http://dbpedia.org/ontology/Rocket/mass$delta_new>(?X0,?Y) :- <http://dbpedia.org/ontology/Rocket/mass$delta_old>(?X0,?X1), owl:sameAs(?X1,?Y) .
        INSERT INTO "dbrdf_mass_delta_new1"(s, o) SELECT t0.s, t1.o FROM "dbrdf_mass_delta_old1" t0, "__triples" t1 WHERE t0.o = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 27059 AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 27059, t0.o FROM "dbrdf_mass_delta_new1" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_mass_delta_old1";
        INSERT INTO "dbrdf_mass_delta_old1"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_mass_delta_new1" t0;
        TRUNCATE TABLE "dbrdf_mass_delta_new1";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 576
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_populationTotalRanking_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_populationTotalRanking_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27060;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_populationTotalRanking_delta_old" ON "dbrdf_populationTotalRanking_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_populationTotalRanking_delta_old" ON "dbrdf_populationTotalRanking_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_populationTotalRanking_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://dbpedia.org/ontology/populationTotalRanking$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/populationTotalRanking$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_populationTotalRanking_delta_new"(s, o) SELECT t1.o, t0.o FROM "dbrdf_populationTotalRanking_delta_old" t0, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 27060 AND ex.o = t0.o);


        -- <http://dbpedia.org/ontology/populationTotalRanking$delta_new>(?X0,?Y) :- <http://dbpedia.org/ontology/populationTotalRanking$delta_old>(?X0,?X1), owl:sameAs(?X1,?Y) .
        INSERT INTO "dbrdf_populationTotalRanking_delta_new"(s, o) SELECT t0.s, t1.o FROM "dbrdf_populationTotalRanking_delta_old" t0, "__triples" t1 WHERE t0.o = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 27060 AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 27060, t0.o FROM "dbrdf_populationTotalRanking_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_populationTotalRanking_delta_old";
        INSERT INTO "dbrdf_populationTotalRanking_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_populationTotalRanking_delta_new" t0;
        TRUNCATE TABLE "dbrdf_populationTotalRanking_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 577
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_numberOfLawyers_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_numberOfLawyers_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27061;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_numberOfLawyers_delta_old" ON "dbrdf_numberOfLawyers_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_numberOfLawyers_delta_old" ON "dbrdf_numberOfLawyers_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_numberOfLawyers_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://dbpedia.org/ontology/numberOfLawyers$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/numberOfLawyers$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_numberOfLawyers_delta_new"(s, o) SELECT t1.o, t0.o FROM "dbrdf_numberOfLawyers_delta_old" t0, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 27061 AND ex.o = t0.o);


        -- <http://dbpedia.org/ontology/numberOfLawyers$delta_new>(?X0,?Y) :- <http://dbpedia.org/ontology/numberOfLawyers$delta_old>(?X0,?X1), owl:sameAs(?X1,?Y) .
        INSERT INTO "dbrdf_numberOfLawyers_delta_new"(s, o) SELECT t0.s, t1.o FROM "dbrdf_numberOfLawyers_delta_old" t0, "__triples" t1 WHERE t0.o = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 27061 AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 27061, t0.o FROM "dbrdf_numberOfLawyers_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_numberOfLawyers_delta_old";
        INSERT INTO "dbrdf_numberOfLawyers_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_numberOfLawyers_delta_new" t0;
        TRUNCATE TABLE "dbrdf_numberOfLawyers_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 578
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_crosses_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_crosses_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27062;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_crosses_delta_old" ON "dbrdf_crosses_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_crosses_delta_old" ON "dbrdf_crosses_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_crosses_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://dbpedia.org/ontology/crosses$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/crosses$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_crosses_delta_new"(s, o) SELECT t1.o, t0.o FROM "dbrdf_crosses_delta_old" t0, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 27062 AND ex.o = t0.o);


        -- <http://dbpedia.org/ontology/crosses$delta_new>(?X0,?Y) :- <http://dbpedia.org/ontology/crosses$delta_old>(?X0,?X1), owl:sameAs(?X1,?Y) .
        INSERT INTO "dbrdf_crosses_delta_new"(s, o) SELECT t0.s, t1.o FROM "dbrdf_crosses_delta_old" t0, "__triples" t1 WHERE t0.o = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 27062 AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 27062, t0.o FROM "dbrdf_crosses_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_crosses_delta_old";
        INSERT INTO "dbrdf_crosses_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_crosses_delta_new" t0;
        TRUNCATE TABLE "dbrdf_crosses_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 579
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_usingCountry_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_usingCountry_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27063;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_usingCountry_delta_old" ON "dbrdf_usingCountry_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_usingCountry_delta_old" ON "dbrdf_usingCountry_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_usingCountry_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://dbpedia.org/ontology/usingCountry$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/usingCountry$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_usingCountry_delta_new"(s, o) SELECT t1.o, t0.o FROM "dbrdf_usingCountry_delta_old" t0, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 27063 AND ex.o = t0.o);


        -- <http://dbpedia.org/ontology/usingCountry$delta_new>(?X0,?Y) :- <http://dbpedia.org/ontology/usingCountry$delta_old>(?X0,?X1), owl:sameAs(?X1,?Y) .
        INSERT INTO "dbrdf_usingCountry_delta_new"(s, o) SELECT t0.s, t1.o FROM "dbrdf_usingCountry_delta_old" t0, "__triples" t1 WHERE t0.o = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 27063 AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 27063, t0.o FROM "dbrdf_usingCountry_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_usingCountry_delta_old";
        INSERT INTO "dbrdf_usingCountry_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_usingCountry_delta_new" t0;
        TRUNCATE TABLE "dbrdf_usingCountry_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 580
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_undraftedYear_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_undraftedYear_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27064;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_undraftedYear_delta_old" ON "dbrdf_undraftedYear_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_undraftedYear_delta_old" ON "dbrdf_undraftedYear_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_undraftedYear_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://dbpedia.org/ontology/undraftedYear$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/undraftedYear$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_undraftedYear_delta_new"(s, o) SELECT t1.o, t0.o FROM "dbrdf_undraftedYear_delta_old" t0, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 27064 AND ex.o = t0.o);


        -- <http://dbpedia.org/ontology/undraftedYear$delta_new>(?X0,?Y) :- <http://dbpedia.org/ontology/undraftedYear$delta_old>(?X0,?X1), owl:sameAs(?X1,?Y) .
        INSERT INTO "dbrdf_undraftedYear_delta_new"(s, o) SELECT t0.s, t1.o FROM "dbrdf_undraftedYear_delta_old" t0, "__triples" t1 WHERE t0.o = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 27064 AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 27064, t0.o FROM "dbrdf_undraftedYear_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_undraftedYear_delta_old";
        INSERT INTO "dbrdf_undraftedYear_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_undraftedYear_delta_new" t0;
        TRUNCATE TABLE "dbrdf_undraftedYear_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 581
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_territory_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_territory_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27065;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_territory_delta_old" ON "dbrdf_territory_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_territory_delta_old" ON "dbrdf_territory_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_territory_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://dbpedia.org/ontology/territory$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/territory$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_territory_delta_new"(s, o) SELECT t1.o, t0.o FROM "dbrdf_territory_delta_old" t0, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 27065 AND ex.o = t0.o);


        -- <http://dbpedia.org/ontology/territory$delta_new>(?X0,?Y) :- <http://dbpedia.org/ontology/territory$delta_old>(?X0,?X1), owl:sameAs(?X1,?Y) .
        INSERT INTO "dbrdf_territory_delta_new"(s, o) SELECT t0.s, t1.o FROM "dbrdf_territory_delta_old" t0, "__triples" t1 WHERE t0.o = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 27065 AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 27065, t0.o FROM "dbrdf_territory_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_territory_delta_old";
        INSERT INTO "dbrdf_territory_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_territory_delta_new" t0;
        TRUNCATE TABLE "dbrdf_territory_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 582
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_governor_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_governor_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27066;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_governor_delta_old" ON "dbrdf_governor_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_governor_delta_old" ON "dbrdf_governor_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_governor_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://dbpedia.org/ontology/governor$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/governor$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_governor_delta_new"(s, o) SELECT t1.o, t0.o FROM "dbrdf_governor_delta_old" t0, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 27066 AND ex.o = t0.o);


        -- <http://dbpedia.org/ontology/governor$delta_new>(?X0,?Y) :- <http://dbpedia.org/ontology/governor$delta_old>(?X0,?X1), owl:sameAs(?X1,?Y) .
        INSERT INTO "dbrdf_governor_delta_new"(s, o) SELECT t0.s, t1.o FROM "dbrdf_governor_delta_old" t0, "__triples" t1 WHERE t0.o = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 27066 AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 27066, t0.o FROM "dbrdf_governor_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_governor_delta_old";
        INSERT INTO "dbrdf_governor_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_governor_delta_new" t0;
        TRUNCATE TABLE "dbrdf_governor_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 583
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_discoverer_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_discoverer_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27067;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_discoverer_delta_old" ON "dbrdf_discoverer_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_discoverer_delta_old" ON "dbrdf_discoverer_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_discoverer_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://dbpedia.org/ontology/discoverer$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/discoverer$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_discoverer_delta_new"(s, o) SELECT t1.o, t0.o FROM "dbrdf_discoverer_delta_old" t0, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 27067 AND ex.o = t0.o);


        -- <http://dbpedia.org/ontology/discoverer$delta_new>(?X0,?Y) :- <http://dbpedia.org/ontology/discoverer$delta_old>(?X0,?X1), owl:sameAs(?X1,?Y) .
        INSERT INTO "dbrdf_discoverer_delta_new"(s, o) SELECT t0.s, t1.o FROM "dbrdf_discoverer_delta_old" t0, "__triples" t1 WHERE t0.o = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 27067 AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 27067, t0.o FROM "dbrdf_discoverer_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_discoverer_delta_old";
        INSERT INTO "dbrdf_discoverer_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_discoverer_delta_new" t0;
        TRUNCATE TABLE "dbrdf_discoverer_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 584
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_icd9_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_icd9_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27068;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_icd9_delta_old" ON "dbrdf_icd9_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_icd9_delta_old" ON "dbrdf_icd9_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_icd9_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://dbpedia.org/ontology/icd9$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/icd9$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_icd9_delta_new"(s, o) SELECT t1.o, t0.o FROM "dbrdf_icd9_delta_old" t0, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 27068 AND ex.o = t0.o);


        -- <http://dbpedia.org/ontology/icd9$delta_new>(?X0,?Y) :- <http://dbpedia.org/ontology/icd9$delta_old>(?X0,?X1), owl:sameAs(?X1,?Y) .
        INSERT INTO "dbrdf_icd9_delta_new"(s, o) SELECT t0.s, t1.o FROM "dbrdf_icd9_delta_old" t0, "__triples" t1 WHERE t0.o = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 27068 AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 27068, t0.o FROM "dbrdf_icd9_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_icd9_delta_old";
        INSERT INTO "dbrdf_icd9_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_icd9_delta_new" t0;
        TRUNCATE TABLE "dbrdf_icd9_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 585
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_doctoralAdvisor_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_doctoralAdvisor_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27069;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_doctoralAdvisor_delta_old" ON "dbrdf_doctoralAdvisor_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_doctoralAdvisor_delta_old" ON "dbrdf_doctoralAdvisor_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_doctoralAdvisor_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://dbpedia.org/ontology/doctoralAdvisor$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/doctoralAdvisor$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_doctoralAdvisor_delta_new"(s, o) SELECT t1.o, t0.o FROM "dbrdf_doctoralAdvisor_delta_old" t0, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 27069 AND ex.o = t0.o);


        -- <http://dbpedia.org/ontology/doctoralAdvisor$delta_new>(?X0,?Y) :- <http://dbpedia.org/ontology/doctoralAdvisor$delta_old>(?X0,?X1), owl:sameAs(?X1,?Y) .
        INSERT INTO "dbrdf_doctoralAdvisor_delta_new"(s, o) SELECT t0.s, t1.o FROM "dbrdf_doctoralAdvisor_delta_old" t0, "__triples" t1 WHERE t0.o = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 27069 AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 27069, t0.o FROM "dbrdf_doctoralAdvisor_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_doctoralAdvisor_delta_old";
        INSERT INTO "dbrdf_doctoralAdvisor_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_doctoralAdvisor_delta_new" t0;
        TRUNCATE TABLE "dbrdf_doctoralAdvisor_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 586
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_rebuildDate_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_rebuildDate_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27070;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_rebuildDate_delta_old" ON "dbrdf_rebuildDate_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_rebuildDate_delta_old" ON "dbrdf_rebuildDate_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_rebuildDate_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://dbpedia.org/ontology/rebuildDate$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/rebuildDate$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_rebuildDate_delta_new"(s, o) SELECT t1.o, t0.o FROM "dbrdf_rebuildDate_delta_old" t0, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 27070 AND ex.o = t0.o);


        -- <http://dbpedia.org/ontology/rebuildDate$delta_new>(?X0,?Y) :- <http://dbpedia.org/ontology/rebuildDate$delta_old>(?X0,?X1), owl:sameAs(?X1,?Y) .
        INSERT INTO "dbrdf_rebuildDate_delta_new"(s, o) SELECT t0.s, t1.o FROM "dbrdf_rebuildDate_delta_old" t0, "__triples" t1 WHERE t0.o = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 27070 AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 27070, t0.o FROM "dbrdf_rebuildDate_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_rebuildDate_delta_old";
        INSERT INTO "dbrdf_rebuildDate_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_rebuildDate_delta_new" t0;
        TRUNCATE TABLE "dbrdf_rebuildDate_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 587
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_government_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_government_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27071;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_government_delta_old" ON "dbrdf_government_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_government_delta_old" ON "dbrdf_government_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_government_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://dbpedia.org/ontology/government$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/government$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_government_delta_new"(s, o) SELECT t1.o, t0.o FROM "dbrdf_government_delta_old" t0, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 27071 AND ex.o = t0.o);


        -- <http://dbpedia.org/ontology/government$delta_new>(?X0,?Y) :- <http://dbpedia.org/ontology/government$delta_old>(?X0,?X1), owl:sameAs(?X1,?Y) .
        INSERT INTO "dbrdf_government_delta_new"(s, o) SELECT t0.s, t1.o FROM "dbrdf_government_delta_old" t0, "__triples" t1 WHERE t0.o = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 27071 AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 27071, t0.o FROM "dbrdf_government_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_government_delta_old";
        INSERT INTO "dbrdf_government_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_government_delta_new" t0;
        TRUNCATE TABLE "dbrdf_government_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 588
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_goldenGlobeAward_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_goldenGlobeAward_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27072;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_goldenGlobeAward_delta_old" ON "dbrdf_goldenGlobeAward_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_goldenGlobeAward_delta_old" ON "dbrdf_goldenGlobeAward_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_goldenGlobeAward_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://dbpedia.org/ontology/goldenGlobeAward$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/goldenGlobeAward$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_goldenGlobeAward_delta_new"(s, o) SELECT t1.o, t0.o FROM "dbrdf_goldenGlobeAward_delta_old" t0, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 27072 AND ex.o = t0.o);


        -- <http://dbpedia.org/ontology/goldenGlobeAward$delta_new>(?X0,?Y) :- <http://dbpedia.org/ontology/goldenGlobeAward$delta_old>(?X0,?X1), owl:sameAs(?X1,?Y) .
        INSERT INTO "dbrdf_goldenGlobeAward_delta_new"(s, o) SELECT t0.s, t1.o FROM "dbrdf_goldenGlobeAward_delta_old" t0, "__triples" t1 WHERE t0.o = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 27072 AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 27072, t0.o FROM "dbrdf_goldenGlobeAward_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_goldenGlobeAward_delta_old";
        INSERT INTO "dbrdf_goldenGlobeAward_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_goldenGlobeAward_delta_new" t0;
        TRUNCATE TABLE "dbrdf_goldenGlobeAward_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 589
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_BaseballTeam_delta_old"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_BaseballTeam_delta_old"(s) SELECT t0.s FROM "__triples" t0 WHERE t0.p = 2 AND t0.o = 27073;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_BaseballTeam_delta_old" ON "dbrdf_BaseballTeam_delta_old"(s);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_BaseballTeam_delta_new"(s integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://dbpedia.org/ontology/BaseballTeam$delta_new>(?Y) :- <http://dbpedia.org/ontology/BaseballTeam$delta_old>(?X0), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_BaseballTeam_delta_new"(s) SELECT t1.o FROM "dbrdf_BaseballTeam_delta_old" t0, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 2 AND ex.o = 27073);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 2, 27073 FROM "dbrdf_BaseballTeam_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_BaseballTeam_delta_old";
        INSERT INTO "dbrdf_BaseballTeam_delta_old"(s) SELECT DISTINCT t0.s FROM "dbrdf_BaseballTeam_delta_new" t0;
        TRUNCATE TABLE "dbrdf_BaseballTeam_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 590
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_imageSize_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_imageSize_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27074;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_imageSize_delta_old" ON "dbrdf_imageSize_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_imageSize_delta_old" ON "dbrdf_imageSize_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_imageSize_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://dbpedia.org/ontology/imageSize$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/imageSize$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_imageSize_delta_new"(s, o) SELECT t1.o, t0.o FROM "dbrdf_imageSize_delta_old" t0, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 27074 AND ex.o = t0.o);


        -- <http://dbpedia.org/ontology/imageSize$delta_new>(?X0,?Y) :- <http://dbpedia.org/ontology/imageSize$delta_old>(?X0,?X1), owl:sameAs(?X1,?Y) .
        INSERT INTO "dbrdf_imageSize_delta_new"(s, o) SELECT t0.s, t1.o FROM "dbrdf_imageSize_delta_old" t0, "__triples" t1 WHERE t0.o = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 27074 AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 27074, t0.o FROM "dbrdf_imageSize_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_imageSize_delta_old";
        INSERT INTO "dbrdf_imageSize_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_imageSize_delta_new" t0;
        TRUNCATE TABLE "dbrdf_imageSize_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 591
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_numberOfGoldMedalsWon_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_numberOfGoldMedalsWon_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27075;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_numberOfGoldMedalsWon_delta_old" ON "dbrdf_numberOfGoldMedalsWon_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_numberOfGoldMedalsWon_delta_old" ON "dbrdf_numberOfGoldMedalsWon_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_numberOfGoldMedalsWon_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://dbpedia.org/ontology/numberOfGoldMedalsWon$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/numberOfGoldMedalsWon$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_numberOfGoldMedalsWon_delta_new"(s, o) SELECT t1.o, t0.o FROM "dbrdf_numberOfGoldMedalsWon_delta_old" t0, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 27075 AND ex.o = t0.o);


        -- <http://dbpedia.org/ontology/numberOfGoldMedalsWon$delta_new>(?X0,?Y) :- <http://dbpedia.org/ontology/numberOfGoldMedalsWon$delta_old>(?X0,?X1), owl:sameAs(?X1,?Y) .
        INSERT INTO "dbrdf_numberOfGoldMedalsWon_delta_new"(s, o) SELECT t0.s, t1.o FROM "dbrdf_numberOfGoldMedalsWon_delta_old" t0, "__triples" t1 WHERE t0.o = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 27075 AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 27075, t0.o FROM "dbrdf_numberOfGoldMedalsWon_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_numberOfGoldMedalsWon_delta_old";
        INSERT INTO "dbrdf_numberOfGoldMedalsWon_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_numberOfGoldMedalsWon_delta_new" t0;
        TRUNCATE TABLE "dbrdf_numberOfGoldMedalsWon_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 592
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_militaryBranch_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_militaryBranch_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27076;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_militaryBranch_delta_old" ON "dbrdf_militaryBranch_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_militaryBranch_delta_old" ON "dbrdf_militaryBranch_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_militaryBranch_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://dbpedia.org/ontology/militaryBranch$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/militaryBranch$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_militaryBranch_delta_new"(s, o) SELECT t1.o, t0.o FROM "dbrdf_militaryBranch_delta_old" t0, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 27076 AND ex.o = t0.o);


        -- <http://dbpedia.org/ontology/militaryBranch$delta_new>(?X0,?Y) :- <http://dbpedia.org/ontology/militaryBranch$delta_old>(?X0,?X1), owl:sameAs(?X1,?Y) .
        INSERT INTO "dbrdf_militaryBranch_delta_new"(s, o) SELECT t0.s, t1.o FROM "dbrdf_militaryBranch_delta_old" t0, "__triples" t1 WHERE t0.o = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 27076 AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 27076, t0.o FROM "dbrdf_militaryBranch_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_militaryBranch_delta_old";
        INSERT INTO "dbrdf_militaryBranch_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_militaryBranch_delta_new" t0;
        TRUNCATE TABLE "dbrdf_militaryBranch_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 593
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_Non_ProfitOrganisation_delta_old"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_Non_ProfitOrganisation_delta_old"(s) SELECT t0.s FROM "__triples" t0 WHERE t0.p = 2 AND t0.o = 27077;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_Non_ProfitOrganisation_delta_old" ON "dbrdf_Non_ProfitOrganisation_delta_old"(s);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_Non_ProfitOrganisation_delta_new"(s integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://dbpedia.org/ontology/Non-ProfitOrganisation$delta_new>(?Y) :- <http://dbpedia.org/ontology/Non-ProfitOrganisation$delta_old>(?X0), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_Non_ProfitOrganisation_delta_new"(s) SELECT t1.o FROM "dbrdf_Non_ProfitOrganisation_delta_old" t0, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 2 AND ex.o = 27077);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 2, 27077 FROM "dbrdf_Non_ProfitOrganisation_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_Non_ProfitOrganisation_delta_old";
        INSERT INTO "dbrdf_Non_ProfitOrganisation_delta_old"(s) SELECT DISTINCT t0.s FROM "dbrdf_Non_ProfitOrganisation_delta_new" t0;
        TRUNCATE TABLE "dbrdf_Non_ProfitOrganisation_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 594
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_meshNumber_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_meshNumber_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27078;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_meshNumber_delta_old" ON "dbrdf_meshNumber_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_meshNumber_delta_old" ON "dbrdf_meshNumber_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_meshNumber_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://dbpedia.org/ontology/meshNumber$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/meshNumber$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_meshNumber_delta_new"(s, o) SELECT t1.o, t0.o FROM "dbrdf_meshNumber_delta_old" t0, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 27078 AND ex.o = t0.o);


        -- <http://dbpedia.org/ontology/meshNumber$delta_new>(?X0,?Y) :- <http://dbpedia.org/ontology/meshNumber$delta_old>(?X0,?X1), owl:sameAs(?X1,?Y) .
        INSERT INTO "dbrdf_meshNumber_delta_new"(s, o) SELECT t0.s, t1.o FROM "dbrdf_meshNumber_delta_old" t0, "__triples" t1 WHERE t0.o = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 27078 AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 27078, t0.o FROM "dbrdf_meshNumber_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_meshNumber_delta_old";
        INSERT INTO "dbrdf_meshNumber_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_meshNumber_delta_new" t0;
        TRUNCATE TABLE "dbrdf_meshNumber_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 595
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_emedicineTopic_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_emedicineTopic_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27079;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_emedicineTopic_delta_old" ON "dbrdf_emedicineTopic_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_emedicineTopic_delta_old" ON "dbrdf_emedicineTopic_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_emedicineTopic_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://dbpedia.org/ontology/emedicineTopic$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/emedicineTopic$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_emedicineTopic_delta_new"(s, o) SELECT t1.o, t0.o FROM "dbrdf_emedicineTopic_delta_old" t0, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 27079 AND ex.o = t0.o);


        -- <http://dbpedia.org/ontology/emedicineTopic$delta_new>(?X0,?Y) :- <http://dbpedia.org/ontology/emedicineTopic$delta_old>(?X0,?X1), owl:sameAs(?X1,?Y) .
        INSERT INTO "dbrdf_emedicineTopic_delta_new"(s, o) SELECT t0.s, t1.o FROM "dbrdf_emedicineTopic_delta_old" t0, "__triples" t1 WHERE t0.o = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 27079 AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 27079, t0.o FROM "dbrdf_emedicineTopic_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_emedicineTopic_delta_old";
        INSERT INTO "dbrdf_emedicineTopic_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_emedicineTopic_delta_new" t0;
        TRUNCATE TABLE "dbrdf_emedicineTopic_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 596
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_commissioningDate_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_commissioningDate_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27080;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_commissioningDate_delta_old" ON "dbrdf_commissioningDate_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_commissioningDate_delta_old" ON "dbrdf_commissioningDate_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_commissioningDate_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://dbpedia.org/ontology/commissioningDate$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/commissioningDate$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_commissioningDate_delta_new"(s, o) SELECT t1.o, t0.o FROM "dbrdf_commissioningDate_delta_old" t0, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 27080 AND ex.o = t0.o);


        -- <http://dbpedia.org/ontology/commissioningDate$delta_new>(?X0,?Y) :- <http://dbpedia.org/ontology/commissioningDate$delta_old>(?X0,?X1), owl:sameAs(?X1,?Y) .
        INSERT INTO "dbrdf_commissioningDate_delta_new"(s, o) SELECT t0.s, t1.o FROM "dbrdf_commissioningDate_delta_old" t0, "__triples" t1 WHERE t0.o = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 27080 AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 27080, t0.o FROM "dbrdf_commissioningDate_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_commissioningDate_delta_old";
        INSERT INTO "dbrdf_commissioningDate_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_commissioningDate_delta_new" t0;
        TRUNCATE TABLE "dbrdf_commissioningDate_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 597
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_geology_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_geology_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27081;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_geology_delta_old" ON "dbrdf_geology_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_geology_delta_old" ON "dbrdf_geology_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_geology_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://dbpedia.org/ontology/geology$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/geology$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_geology_delta_new"(s, o) SELECT t1.o, t0.o FROM "dbrdf_geology_delta_old" t0, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 27081 AND ex.o = t0.o);


        -- <http://dbpedia.org/ontology/geology$delta_new>(?X0,?Y) :- <http://dbpedia.org/ontology/geology$delta_old>(?X0,?X1), owl:sameAs(?X1,?Y) .
        INSERT INTO "dbrdf_geology_delta_new"(s, o) SELECT t0.s, t1.o FROM "dbrdf_geology_delta_old" t0, "__triples" t1 WHERE t0.o = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 27081 AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 27081, t0.o FROM "dbrdf_geology_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_geology_delta_old";
        INSERT INTO "dbrdf_geology_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_geology_delta_new" t0;
        TRUNCATE TABLE "dbrdf_geology_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 598
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_drainsFrom_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_drainsFrom_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27082;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_drainsFrom_delta_old" ON "dbrdf_drainsFrom_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_drainsFrom_delta_old" ON "dbrdf_drainsFrom_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_drainsFrom_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://dbpedia.org/ontology/drainsFrom$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/drainsFrom$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_drainsFrom_delta_new"(s, o) SELECT t1.o, t0.o FROM "dbrdf_drainsFrom_delta_old" t0, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 27082 AND ex.o = t0.o);


        -- <http://dbpedia.org/ontology/drainsFrom$delta_new>(?X0,?Y) :- <http://dbpedia.org/ontology/drainsFrom$delta_old>(?X0,?X1), owl:sameAs(?X1,?Y) .
        INSERT INTO "dbrdf_drainsFrom_delta_new"(s, o) SELECT t0.s, t1.o FROM "dbrdf_drainsFrom_delta_old" t0, "__triples" t1 WHERE t0.o = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 27082 AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 27082, t0.o FROM "dbrdf_drainsFrom_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_drainsFrom_delta_old";
        INSERT INTO "dbrdf_drainsFrom_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_drainsFrom_delta_new" t0;
        TRUNCATE TABLE "dbrdf_drainsFrom_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 599
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_previousInfrastructure_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_previousInfrastructure_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27083;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_previousInfrastructure_delta_old" ON "dbrdf_previousInfrastructure_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_previousInfrastructure_delta_old" ON "dbrdf_previousInfrastructure_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_previousInfrastructure_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://dbpedia.org/ontology/previousInfrastructure$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/previousInfrastructure$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_previousInfrastructure_delta_new"(s, o) SELECT t1.o, t0.o FROM "dbrdf_previousInfrastructure_delta_old" t0, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 27083 AND ex.o = t0.o);


        -- <http://dbpedia.org/ontology/previousInfrastructure$delta_new>(?X0,?Y) :- <http://dbpedia.org/ontology/previousInfrastructure$delta_old>(?X0,?X1), owl:sameAs(?X1,?Y) .
        INSERT INTO "dbrdf_previousInfrastructure_delta_new"(s, o) SELECT t0.s, t1.o FROM "dbrdf_previousInfrastructure_delta_old" t0, "__triples" t1 WHERE t0.o = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 27083 AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 27083, t0.o FROM "dbrdf_previousInfrastructure_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_previousInfrastructure_delta_old";
        INSERT INTO "dbrdf_previousInfrastructure_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_previousInfrastructure_delta_new" t0;
        TRUNCATE TABLE "dbrdf_previousInfrastructure_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 600
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_distributingCompany_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_distributingCompany_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27084;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_distributingCompany_delta_old" ON "dbrdf_distributingCompany_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_distributingCompany_delta_old" ON "dbrdf_distributingCompany_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_distributingCompany_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://dbpedia.org/ontology/distributingCompany$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/distributingCompany$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_distributingCompany_delta_new"(s, o) SELECT t1.o, t0.o FROM "dbrdf_distributingCompany_delta_old" t0, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 27084 AND ex.o = t0.o);


        -- <http://dbpedia.org/ontology/distributingCompany$delta_new>(?X0,?Y) :- <http://dbpedia.org/ontology/distributingCompany$delta_old>(?X0,?X1), owl:sameAs(?X1,?Y) .
        INSERT INTO "dbrdf_distributingCompany_delta_new"(s, o) SELECT t0.s, t1.o FROM "dbrdf_distributingCompany_delta_old" t0, "__triples" t1 WHERE t0.o = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 27084 AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 27084, t0.o FROM "dbrdf_distributingCompany_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_distributingCompany_delta_old";
        INSERT INTO "dbrdf_distributingCompany_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_distributingCompany_delta_new" t0;
        TRUNCATE TABLE "dbrdf_distributingCompany_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 601
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_aircraftHelicopterAttack_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_aircraftHelicopterAttack_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27085;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_aircraftHelicopterAttack_delta_old" ON "dbrdf_aircraftHelicopterAttack_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_aircraftHelicopterAttack_delta_old" ON "dbrdf_aircraftHelicopterAttack_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_aircraftHelicopterAttack_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://dbpedia.org/ontology/aircraftHelicopterAttack$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/aircraftHelicopterAttack$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_aircraftHelicopterAttack_delta_new"(s, o) SELECT t1.o, t0.o FROM "dbrdf_aircraftHelicopterAttack_delta_old" t0, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 27085 AND ex.o = t0.o);


        -- <http://dbpedia.org/ontology/aircraftHelicopterAttack$delta_new>(?X0,?Y) :- <http://dbpedia.org/ontology/aircraftHelicopterAttack$delta_old>(?X0,?X1), owl:sameAs(?X1,?Y) .
        INSERT INTO "dbrdf_aircraftHelicopterAttack_delta_new"(s, o) SELECT t0.s, t1.o FROM "dbrdf_aircraftHelicopterAttack_delta_old" t0, "__triples" t1 WHERE t0.o = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 27085 AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 27085, t0.o FROM "dbrdf_aircraftHelicopterAttack_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_aircraftHelicopterAttack_delta_old";
        INSERT INTO "dbrdf_aircraftHelicopterAttack_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_aircraftHelicopterAttack_delta_new" t0;
        TRUNCATE TABLE "dbrdf_aircraftHelicopterAttack_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 602
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_politicGovernmentDepartment_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_politicGovernmentDepartment_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27086;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_politicGovernmentDepartment_delta_old" ON "dbrdf_politicGovernmentDepartment_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_politicGovernmentDepartment_delta_old" ON "dbrdf_politicGovernmentDepartment_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_politicGovernmentDepartment_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://dbpedia.org/ontology/politicGovernmentDepartment$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/politicGovernmentDepartment$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_politicGovernmentDepartment_delta_new"(s, o) SELECT t1.o, t0.o FROM "dbrdf_politicGovernmentDepartment_delta_old" t0, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 27086 AND ex.o = t0.o);


        -- <http://dbpedia.org/ontology/politicGovernmentDepartment$delta_new>(?X0,?Y) :- <http://dbpedia.org/ontology/politicGovernmentDepartment$delta_old>(?X0,?X1), owl:sameAs(?X1,?Y) .
        INSERT INTO "dbrdf_politicGovernmentDepartment_delta_new"(s, o) SELECT t0.s, t1.o FROM "dbrdf_politicGovernmentDepartment_delta_old" t0, "__triples" t1 WHERE t0.o = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 27086 AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 27086, t0.o FROM "dbrdf_politicGovernmentDepartment_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_politicGovernmentDepartment_delta_old";
        INSERT INTO "dbrdf_politicGovernmentDepartment_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_politicGovernmentDepartment_delta_new" t0;
        TRUNCATE TABLE "dbrdf_politicGovernmentDepartment_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 603
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_currentProduction_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_currentProduction_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27087;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_currentProduction_delta_old" ON "dbrdf_currentProduction_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_currentProduction_delta_old" ON "dbrdf_currentProduction_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_currentProduction_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://dbpedia.org/ontology/currentProduction$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/currentProduction$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_currentProduction_delta_new"(s, o) SELECT t1.o, t0.o FROM "dbrdf_currentProduction_delta_old" t0, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 27087 AND ex.o = t0.o);


        -- <http://dbpedia.org/ontology/currentProduction$delta_new>(?X0,?Y) :- <http://dbpedia.org/ontology/currentProduction$delta_old>(?X0,?X1), owl:sameAs(?X1,?Y) .
        INSERT INTO "dbrdf_currentProduction_delta_new"(s, o) SELECT t0.s, t1.o FROM "dbrdf_currentProduction_delta_old" t0, "__triples" t1 WHERE t0.o = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 27087 AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 27087, t0.o FROM "dbrdf_currentProduction_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_currentProduction_delta_old";
        INSERT INTO "dbrdf_currentProduction_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_currentProduction_delta_new" t0;
        TRUNCATE TABLE "dbrdf_currentProduction_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 604
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_meetingBuilding_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_meetingBuilding_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27088;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_meetingBuilding_delta_old" ON "dbrdf_meetingBuilding_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_meetingBuilding_delta_old" ON "dbrdf_meetingBuilding_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_meetingBuilding_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://dbpedia.org/ontology/meetingBuilding$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/meetingBuilding$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_meetingBuilding_delta_new"(s, o) SELECT t1.o, t0.o FROM "dbrdf_meetingBuilding_delta_old" t0, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 27088 AND ex.o = t0.o);


        -- <http://dbpedia.org/ontology/meetingBuilding$delta_new>(?X0,?Y) :- <http://dbpedia.org/ontology/meetingBuilding$delta_old>(?X0,?X1), owl:sameAs(?X1,?Y) .
        INSERT INTO "dbrdf_meetingBuilding_delta_new"(s, o) SELECT t0.s, t1.o FROM "dbrdf_meetingBuilding_delta_old" t0, "__triples" t1 WHERE t0.o = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 27088 AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 27088, t0.o FROM "dbrdf_meetingBuilding_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_meetingBuilding_delta_old";
        INSERT INTO "dbrdf_meetingBuilding_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_meetingBuilding_delta_new" t0;
        TRUNCATE TABLE "dbrdf_meetingBuilding_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 605
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_assistantPrincipal_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_assistantPrincipal_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27089;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_assistantPrincipal_delta_old" ON "dbrdf_assistantPrincipal_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_assistantPrincipal_delta_old" ON "dbrdf_assistantPrincipal_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_assistantPrincipal_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://dbpedia.org/ontology/assistantPrincipal$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/assistantPrincipal$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_assistantPrincipal_delta_new"(s, o) SELECT t1.o, t0.o FROM "dbrdf_assistantPrincipal_delta_old" t0, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 27089 AND ex.o = t0.o);


        -- <http://dbpedia.org/ontology/assistantPrincipal$delta_new>(?X0,?Y) :- <http://dbpedia.org/ontology/assistantPrincipal$delta_old>(?X0,?X1), owl:sameAs(?X1,?Y) .
        INSERT INTO "dbrdf_assistantPrincipal_delta_new"(s, o) SELECT t0.s, t1.o FROM "dbrdf_assistantPrincipal_delta_old" t0, "__triples" t1 WHERE t0.o = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 27089 AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 27089, t0.o FROM "dbrdf_assistantPrincipal_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_assistantPrincipal_delta_old";
        INSERT INTO "dbrdf_assistantPrincipal_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_assistantPrincipal_delta_new" t0;
        TRUNCATE TABLE "dbrdf_assistantPrincipal_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 606
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_numberOfLines_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_numberOfLines_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27090;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_numberOfLines_delta_old" ON "dbrdf_numberOfLines_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_numberOfLines_delta_old" ON "dbrdf_numberOfLines_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_numberOfLines_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://dbpedia.org/ontology/numberOfLines$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/numberOfLines$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_numberOfLines_delta_new"(s, o) SELECT t1.o, t0.o FROM "dbrdf_numberOfLines_delta_old" t0, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 27090 AND ex.o = t0.o);


        -- <http://dbpedia.org/ontology/numberOfLines$delta_new>(?X0,?Y) :- <http://dbpedia.org/ontology/numberOfLines$delta_old>(?X0,?X1), owl:sameAs(?X1,?Y) .
        INSERT INTO "dbrdf_numberOfLines_delta_new"(s, o) SELECT t0.s, t1.o FROM "dbrdf_numberOfLines_delta_old" t0, "__triples" t1 WHERE t0.o = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 27090 AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 27090, t0.o FROM "dbrdf_numberOfLines_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_numberOfLines_delta_old";
        INSERT INTO "dbrdf_numberOfLines_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_numberOfLines_delta_new" t0;
        TRUNCATE TABLE "dbrdf_numberOfLines_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 607
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_acquirementDate_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_acquirementDate_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27091;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_acquirementDate_delta_old" ON "dbrdf_acquirementDate_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_acquirementDate_delta_old" ON "dbrdf_acquirementDate_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_acquirementDate_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://dbpedia.org/ontology/acquirementDate$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/acquirementDate$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_acquirementDate_delta_new"(s, o) SELECT t1.o, t0.o FROM "dbrdf_acquirementDate_delta_old" t0, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 27091 AND ex.o = t0.o);


        -- <http://dbpedia.org/ontology/acquirementDate$delta_new>(?X0,?Y) :- <http://dbpedia.org/ontology/acquirementDate$delta_old>(?X0,?X1), owl:sameAs(?X1,?Y) .
        INSERT INTO "dbrdf_acquirementDate_delta_new"(s, o) SELECT t0.s, t1.o FROM "dbrdf_acquirementDate_delta_old" t0, "__triples" t1 WHERE t0.o = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 27091 AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 27091, t0.o FROM "dbrdf_acquirementDate_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_acquirementDate_delta_old";
        INSERT INTO "dbrdf_acquirementDate_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_acquirementDate_delta_new" t0;
        TRUNCATE TABLE "dbrdf_acquirementDate_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 608
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_namedAfter_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_namedAfter_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27092;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_namedAfter_delta_old" ON "dbrdf_namedAfter_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_namedAfter_delta_old" ON "dbrdf_namedAfter_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_namedAfter_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://dbpedia.org/ontology/namedAfter$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/namedAfter$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_namedAfter_delta_new"(s, o) SELECT t1.o, t0.o FROM "dbrdf_namedAfter_delta_old" t0, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 27092 AND ex.o = t0.o);


        -- <http://dbpedia.org/ontology/namedAfter$delta_new>(?X0,?Y) :- <http://dbpedia.org/ontology/namedAfter$delta_old>(?X0,?X1), owl:sameAs(?X1,?Y) .
        INSERT INTO "dbrdf_namedAfter_delta_new"(s, o) SELECT t0.s, t1.o FROM "dbrdf_namedAfter_delta_old" t0, "__triples" t1 WHERE t0.o = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 27092 AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 27092, t0.o FROM "dbrdf_namedAfter_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_namedAfter_delta_old";
        INSERT INTO "dbrdf_namedAfter_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_namedAfter_delta_new" t0;
        TRUNCATE TABLE "dbrdf_namedAfter_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 609
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_railwayLineUsingTunnel_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_railwayLineUsingTunnel_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27093;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_railwayLineUsingTunnel_delta_old" ON "dbrdf_railwayLineUsingTunnel_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_railwayLineUsingTunnel_delta_old" ON "dbrdf_railwayLineUsingTunnel_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_railwayLineUsingTunnel_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://dbpedia.org/ontology/railwayLineUsingTunnel$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/railwayLineUsingTunnel$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_railwayLineUsingTunnel_delta_new"(s, o) SELECT t1.o, t0.o FROM "dbrdf_railwayLineUsingTunnel_delta_old" t0, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 27093 AND ex.o = t0.o);


        -- <http://dbpedia.org/ontology/railwayLineUsingTunnel$delta_new>(?X0,?Y) :- <http://dbpedia.org/ontology/railwayLineUsingTunnel$delta_old>(?X0,?X1), owl:sameAs(?X1,?Y) .
        INSERT INTO "dbrdf_railwayLineUsingTunnel_delta_new"(s, o) SELECT t0.s, t1.o FROM "dbrdf_railwayLineUsingTunnel_delta_old" t0, "__triples" t1 WHERE t0.o = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 27093 AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 27093, t0.o FROM "dbrdf_railwayLineUsingTunnel_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_railwayLineUsingTunnel_delta_old";
        INSERT INTO "dbrdf_railwayLineUsingTunnel_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_railwayLineUsingTunnel_delta_new" t0;
        TRUNCATE TABLE "dbrdf_railwayLineUsingTunnel_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 610
    ---- DEPENDS ON: 609, 0
    ----------------------------------------

    -- Nonrecursive rules

    -- [Rule] <http://dbpedia.org/ontology/RailwayTunnel>(?X) :- <http://dbpedia.org/ontology/railwayLineUsingTunnel>(?X,?X1) .
    INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 2, 27094 FROM "__triples" t0 WHERE t0.p = 27093 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 2 AND ex.o = 27094);
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    total_tuples := total_tuples + rows_nr;

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_RailwayTunnel_delta_old"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_RailwayTunnel_delta_old"(s) SELECT t0.s FROM "__triples" t0 WHERE t0.p = 2 AND t0.o = 27094;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_RailwayTunnel_delta_old" ON "dbrdf_RailwayTunnel_delta_old"(s);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_RailwayTunnel_delta_new"(s integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://dbpedia.org/ontology/RailwayTunnel$delta_new>(?Y) :- <http://dbpedia.org/ontology/RailwayTunnel$delta_old>(?X0), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_RailwayTunnel_delta_new"(s) SELECT t1.o FROM "dbrdf_RailwayTunnel_delta_old" t0, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 2 AND ex.o = 27094);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 2, 27094 FROM "dbrdf_RailwayTunnel_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_RailwayTunnel_delta_old";
        INSERT INTO "dbrdf_RailwayTunnel_delta_old"(s) SELECT DISTINCT t0.s FROM "dbrdf_RailwayTunnel_delta_new" t0;
        TRUNCATE TABLE "dbrdf_RailwayTunnel_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 611
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_rgbCoordinateRed_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_rgbCoordinateRed_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27095;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_rgbCoordinateRed_delta_old" ON "dbrdf_rgbCoordinateRed_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_rgbCoordinateRed_delta_old" ON "dbrdf_rgbCoordinateRed_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_rgbCoordinateRed_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://dbpedia.org/ontology/rgbCoordinateRed$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/rgbCoordinateRed$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_rgbCoordinateRed_delta_new"(s, o) SELECT t1.o, t0.o FROM "dbrdf_rgbCoordinateRed_delta_old" t0, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 27095 AND ex.o = t0.o);


        -- <http://dbpedia.org/ontology/rgbCoordinateRed$delta_new>(?X0,?Y) :- <http://dbpedia.org/ontology/rgbCoordinateRed$delta_old>(?X0,?X1), owl:sameAs(?X1,?Y) .
        INSERT INTO "dbrdf_rgbCoordinateRed_delta_new"(s, o) SELECT t0.s, t1.o FROM "dbrdf_rgbCoordinateRed_delta_old" t0, "__triples" t1 WHERE t0.o = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 27095 AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 27095, t0.o FROM "dbrdf_rgbCoordinateRed_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_rgbCoordinateRed_delta_old";
        INSERT INTO "dbrdf_rgbCoordinateRed_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_rgbCoordinateRed_delta_new" t0;
        TRUNCATE TABLE "dbrdf_rgbCoordinateRed_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 612
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_Fern_delta_old"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_Fern_delta_old"(s) SELECT t0.s FROM "__triples" t0 WHERE t0.p = 2 AND t0.o = 27096;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_Fern_delta_old" ON "dbrdf_Fern_delta_old"(s);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_Fern_delta_new"(s integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://dbpedia.org/ontology/Fern$delta_new>(?Y) :- <http://dbpedia.org/ontology/Fern$delta_old>(?X0), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_Fern_delta_new"(s) SELECT t1.o FROM "dbrdf_Fern_delta_old" t0, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 2 AND ex.o = 27096);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 2, 27096 FROM "dbrdf_Fern_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_Fern_delta_old";
        INSERT INTO "dbrdf_Fern_delta_old"(s) SELECT DISTINCT t0.s FROM "dbrdf_Fern_delta_new" t0;
        TRUNCATE TABLE "dbrdf_Fern_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 613
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_populationAsOf_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_populationAsOf_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27097;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_populationAsOf_delta_old" ON "dbrdf_populationAsOf_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_populationAsOf_delta_old" ON "dbrdf_populationAsOf_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_populationAsOf_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://dbpedia.org/ontology/populationAsOf$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/populationAsOf$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_populationAsOf_delta_new"(s, o) SELECT t1.o, t0.o FROM "dbrdf_populationAsOf_delta_old" t0, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 27097 AND ex.o = t0.o);


        -- <http://dbpedia.org/ontology/populationAsOf$delta_new>(?X0,?Y) :- <http://dbpedia.org/ontology/populationAsOf$delta_old>(?X0,?X1), owl:sameAs(?X1,?Y) .
        INSERT INTO "dbrdf_populationAsOf_delta_new"(s, o) SELECT t0.s, t1.o FROM "dbrdf_populationAsOf_delta_old" t0, "__triples" t1 WHERE t0.o = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 27097 AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 27097, t0.o FROM "dbrdf_populationAsOf_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_populationAsOf_delta_old";
        INSERT INTO "dbrdf_populationAsOf_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_populationAsOf_delta_new" t0;
        TRUNCATE TABLE "dbrdf_populationAsOf_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 614
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_reservations_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_reservations_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27098;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_reservations_delta_old" ON "dbrdf_reservations_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_reservations_delta_old" ON "dbrdf_reservations_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_reservations_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://dbpedia.org/ontology/reservations$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/reservations$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_reservations_delta_new"(s, o) SELECT t1.o, t0.o FROM "dbrdf_reservations_delta_old" t0, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 27098 AND ex.o = t0.o);


        -- <http://dbpedia.org/ontology/reservations$delta_new>(?X0,?Y) :- <http://dbpedia.org/ontology/reservations$delta_old>(?X0,?X1), owl:sameAs(?X1,?Y) .
        INSERT INTO "dbrdf_reservations_delta_new"(s, o) SELECT t0.s, t1.o FROM "dbrdf_reservations_delta_old" t0, "__triples" t1 WHERE t0.o = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 27098 AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 27098, t0.o FROM "dbrdf_reservations_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_reservations_delta_old";
        INSERT INTO "dbrdf_reservations_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_reservations_delta_new" t0;
        TRUNCATE TABLE "dbrdf_reservations_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 615
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_currentTeamMember_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_currentTeamMember_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27099;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_currentTeamMember_delta_old" ON "dbrdf_currentTeamMember_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_currentTeamMember_delta_old" ON "dbrdf_currentTeamMember_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_currentTeamMember_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://dbpedia.org/ontology/currentTeamMember$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/currentTeamMember$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_currentTeamMember_delta_new"(s, o) SELECT t1.o, t0.o FROM "dbrdf_currentTeamMember_delta_old" t0, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 27099 AND ex.o = t0.o);


        -- <http://dbpedia.org/ontology/currentTeamMember$delta_new>(?X0,?Y) :- <http://dbpedia.org/ontology/currentTeamMember$delta_old>(?X0,?X1), owl:sameAs(?X1,?Y) .
        INSERT INTO "dbrdf_currentTeamMember_delta_new"(s, o) SELECT t0.s, t1.o FROM "dbrdf_currentTeamMember_delta_old" t0, "__triples" t1 WHERE t0.o = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 27099 AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 27099, t0.o FROM "dbrdf_currentTeamMember_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_currentTeamMember_delta_old";
        INSERT INTO "dbrdf_currentTeamMember_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_currentTeamMember_delta_new" t0;
        TRUNCATE TABLE "dbrdf_currentTeamMember_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 616
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_principalArea_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_principalArea_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27100;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_principalArea_delta_old" ON "dbrdf_principalArea_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_principalArea_delta_old" ON "dbrdf_principalArea_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_principalArea_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://dbpedia.org/ontology/principalArea$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/principalArea$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_principalArea_delta_new"(s, o) SELECT t1.o, t0.o FROM "dbrdf_principalArea_delta_old" t0, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 27100 AND ex.o = t0.o);


        -- <http://dbpedia.org/ontology/principalArea$delta_new>(?X0,?Y) :- <http://dbpedia.org/ontology/principalArea$delta_old>(?X0,?X1), owl:sameAs(?X1,?Y) .
        INSERT INTO "dbrdf_principalArea_delta_new"(s, o) SELECT t0.s, t1.o FROM "dbrdf_principalArea_delta_old" t0, "__triples" t1 WHERE t0.o = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 27100 AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 27100, t0.o FROM "dbrdf_principalArea_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_principalArea_delta_old";
        INSERT INTO "dbrdf_principalArea_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_principalArea_delta_new" t0;
        TRUNCATE TABLE "dbrdf_principalArea_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 617
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_legislativePeriodName_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_legislativePeriodName_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27101;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_legislativePeriodName_delta_old" ON "dbrdf_legislativePeriodName_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_legislativePeriodName_delta_old" ON "dbrdf_legislativePeriodName_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_legislativePeriodName_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://dbpedia.org/ontology/legislativePeriodName$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/legislativePeriodName$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_legislativePeriodName_delta_new"(s, o) SELECT t1.o, t0.o FROM "dbrdf_legislativePeriodName_delta_old" t0, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 27101 AND ex.o = t0.o);


        -- <http://dbpedia.org/ontology/legislativePeriodName$delta_new>(?X0,?Y) :- <http://dbpedia.org/ontology/legislativePeriodName$delta_old>(?X0,?X1), owl:sameAs(?X1,?Y) .
        INSERT INTO "dbrdf_legislativePeriodName_delta_new"(s, o) SELECT t0.s, t1.o FROM "dbrdf_legislativePeriodName_delta_old" t0, "__triples" t1 WHERE t0.o = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 27101 AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 27101, t0.o FROM "dbrdf_legislativePeriodName_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_legislativePeriodName_delta_old";
        INSERT INTO "dbrdf_legislativePeriodName_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_legislativePeriodName_delta_new" t0;
        TRUNCATE TABLE "dbrdf_legislativePeriodName_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 618
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_religiousHeadLabel_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_religiousHeadLabel_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27102;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_religiousHeadLabel_delta_old" ON "dbrdf_religiousHeadLabel_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_religiousHeadLabel_delta_old" ON "dbrdf_religiousHeadLabel_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_religiousHeadLabel_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://dbpedia.org/ontology/religiousHeadLabel$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/religiousHeadLabel$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_religiousHeadLabel_delta_new"(s, o) SELECT t1.o, t0.o FROM "dbrdf_religiousHeadLabel_delta_old" t0, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 27102 AND ex.o = t0.o);


        -- <http://dbpedia.org/ontology/religiousHeadLabel$delta_new>(?X0,?Y) :- <http://dbpedia.org/ontology/religiousHeadLabel$delta_old>(?X0,?X1), owl:sameAs(?X1,?Y) .
        INSERT INTO "dbrdf_religiousHeadLabel_delta_new"(s, o) SELECT t0.s, t1.o FROM "dbrdf_religiousHeadLabel_delta_old" t0, "__triples" t1 WHERE t0.o = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 27102 AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 27102, t0.o FROM "dbrdf_religiousHeadLabel_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_religiousHeadLabel_delta_old";
        INSERT INTO "dbrdf_religiousHeadLabel_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_religiousHeadLabel_delta_new" t0;
        TRUNCATE TABLE "dbrdf_religiousHeadLabel_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 619
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_mouthPlace_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_mouthPlace_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27103;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_mouthPlace_delta_old" ON "dbrdf_mouthPlace_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_mouthPlace_delta_old" ON "dbrdf_mouthPlace_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_mouthPlace_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://dbpedia.org/ontology/mouthPlace$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/mouthPlace$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_mouthPlace_delta_new"(s, o) SELECT t1.o, t0.o FROM "dbrdf_mouthPlace_delta_old" t0, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 27103 AND ex.o = t0.o);


        -- <http://dbpedia.org/ontology/mouthPlace$delta_new>(?X0,?Y) :- <http://dbpedia.org/ontology/mouthPlace$delta_old>(?X0,?X1), owl:sameAs(?X1,?Y) .
        INSERT INTO "dbrdf_mouthPlace_delta_new"(s, o) SELECT t0.s, t1.o FROM "dbrdf_mouthPlace_delta_old" t0, "__triples" t1 WHERE t0.o = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 27103 AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 27103, t0.o FROM "dbrdf_mouthPlace_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_mouthPlace_delta_old";
        INSERT INTO "dbrdf_mouthPlace_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_mouthPlace_delta_new" t0;
        TRUNCATE TABLE "dbrdf_mouthPlace_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 620
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_aircraftFighter_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_aircraftFighter_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27104;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_aircraftFighter_delta_old" ON "dbrdf_aircraftFighter_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_aircraftFighter_delta_old" ON "dbrdf_aircraftFighter_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_aircraftFighter_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://dbpedia.org/ontology/aircraftFighter$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/aircraftFighter$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_aircraftFighter_delta_new"(s, o) SELECT t1.o, t0.o FROM "dbrdf_aircraftFighter_delta_old" t0, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 27104 AND ex.o = t0.o);


        -- <http://dbpedia.org/ontology/aircraftFighter$delta_new>(?X0,?Y) :- <http://dbpedia.org/ontology/aircraftFighter$delta_old>(?X0,?X1), owl:sameAs(?X1,?Y) .
        INSERT INTO "dbrdf_aircraftFighter_delta_new"(s, o) SELECT t0.s, t1.o FROM "dbrdf_aircraftFighter_delta_old" t0, "__triples" t1 WHERE t0.o = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 27104 AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 27104, t0.o FROM "dbrdf_aircraftFighter_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_aircraftFighter_delta_old";
        INSERT INTO "dbrdf_aircraftFighter_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_aircraftFighter_delta_new" t0;
        TRUNCATE TABLE "dbrdf_aircraftFighter_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 621
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_railwayPlatforms_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_railwayPlatforms_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27105;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_railwayPlatforms_delta_old" ON "dbrdf_railwayPlatforms_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_railwayPlatforms_delta_old" ON "dbrdf_railwayPlatforms_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_railwayPlatforms_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://dbpedia.org/ontology/railwayPlatforms$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/railwayPlatforms$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_railwayPlatforms_delta_new"(s, o) SELECT t1.o, t0.o FROM "dbrdf_railwayPlatforms_delta_old" t0, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 27105 AND ex.o = t0.o);


        -- <http://dbpedia.org/ontology/railwayPlatforms$delta_new>(?X0,?Y) :- <http://dbpedia.org/ontology/railwayPlatforms$delta_old>(?X0,?X1), owl:sameAs(?X1,?Y) .
        INSERT INTO "dbrdf_railwayPlatforms_delta_new"(s, o) SELECT t0.s, t1.o FROM "dbrdf_railwayPlatforms_delta_old" t0, "__triples" t1 WHERE t0.o = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 27105 AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 27105, t0.o FROM "dbrdf_railwayPlatforms_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_railwayPlatforms_delta_old";
        INSERT INTO "dbrdf_railwayPlatforms_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_railwayPlatforms_delta_new" t0;
        TRUNCATE TABLE "dbrdf_railwayPlatforms_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 622
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_torqueOutput_delta_old0"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_torqueOutput_delta_old0"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27106;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_torqueOutput_delta_old0" ON "dbrdf_torqueOutput_delta_old0"(s, o); CREATE INDEX "IDX_1_dbrdf_torqueOutput_delta_old0" ON "dbrdf_torqueOutput_delta_old0"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_torqueOutput_delta_new0"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://dbpedia.org/ontology/AutomobileEngine/torqueOutput$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/AutomobileEngine/torqueOutput$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_torqueOutput_delta_new0"(s, o) SELECT t1.o, t0.o FROM "dbrdf_torqueOutput_delta_old0" t0, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 27106 AND ex.o = t0.o);


        -- <http://dbpedia.org/ontology/AutomobileEngine/torqueOutput$delta_new>(?X0,?Y) :- <http://dbpedia.org/ontology/AutomobileEngine/torqueOutput$delta_old>(?X0,?X1), owl:sameAs(?X1,?Y) .
        INSERT INTO "dbrdf_torqueOutput_delta_new0"(s, o) SELECT t0.s, t1.o FROM "dbrdf_torqueOutput_delta_old0" t0, "__triples" t1 WHERE t0.o = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 27106 AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 27106, t0.o FROM "dbrdf_torqueOutput_delta_new0" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_torqueOutput_delta_old0";
        INSERT INTO "dbrdf_torqueOutput_delta_old0"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_torqueOutput_delta_new0" t0;
        TRUNCATE TABLE "dbrdf_torqueOutput_delta_new0";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 623
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_orbits_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_orbits_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27107;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_orbits_delta_old" ON "dbrdf_orbits_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_orbits_delta_old" ON "dbrdf_orbits_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_orbits_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://dbpedia.org/ontology/orbits$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/orbits$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_orbits_delta_new"(s, o) SELECT t1.o, t0.o FROM "dbrdf_orbits_delta_old" t0, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 27107 AND ex.o = t0.o);


        -- <http://dbpedia.org/ontology/orbits$delta_new>(?X0,?Y) :- <http://dbpedia.org/ontology/orbits$delta_old>(?X0,?X1), owl:sameAs(?X1,?Y) .
        INSERT INTO "dbrdf_orbits_delta_new"(s, o) SELECT t0.s, t1.o FROM "dbrdf_orbits_delta_old" t0, "__triples" t1 WHERE t0.o = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 27107 AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 27107, t0.o FROM "dbrdf_orbits_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_orbits_delta_old";
        INSERT INTO "dbrdf_orbits_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_orbits_delta_new" t0;
        TRUNCATE TABLE "dbrdf_orbits_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 624
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_Valley_delta_old"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_Valley_delta_old"(s) SELECT t0.s FROM "__triples" t0 WHERE t0.p = 2 AND t0.o = 27108;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_Valley_delta_old" ON "dbrdf_Valley_delta_old"(s);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_Valley_delta_new"(s integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://dbpedia.org/ontology/Valley$delta_new>(?Y) :- <http://dbpedia.org/ontology/Valley$delta_old>(?X0), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_Valley_delta_new"(s) SELECT t1.o FROM "dbrdf_Valley_delta_old" t0, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 2 AND ex.o = 27108);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 2, 27108 FROM "dbrdf_Valley_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_Valley_delta_old";
        INSERT INTO "dbrdf_Valley_delta_old"(s) SELECT DISTINCT t0.s FROM "dbrdf_Valley_delta_new" t0;
        TRUNCATE TABLE "dbrdf_Valley_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 625
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_populationPlace_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_populationPlace_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27109;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_populationPlace_delta_old" ON "dbrdf_populationPlace_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_populationPlace_delta_old" ON "dbrdf_populationPlace_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_populationPlace_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://dbpedia.org/ontology/populationPlace$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/populationPlace$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_populationPlace_delta_new"(s, o) SELECT t1.o, t0.o FROM "dbrdf_populationPlace_delta_old" t0, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 27109 AND ex.o = t0.o);


        -- <http://dbpedia.org/ontology/populationPlace$delta_new>(?X0,?Y) :- <http://dbpedia.org/ontology/populationPlace$delta_old>(?X0,?X1), owl:sameAs(?X1,?Y) .
        INSERT INTO "dbrdf_populationPlace_delta_new"(s, o) SELECT t0.s, t1.o FROM "dbrdf_populationPlace_delta_old" t0, "__triples" t1 WHERE t0.o = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 27109 AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 27109, t0.o FROM "dbrdf_populationPlace_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_populationPlace_delta_old";
        INSERT INTO "dbrdf_populationPlace_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_populationPlace_delta_new" t0;
        TRUNCATE TABLE "dbrdf_populationPlace_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 626
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_aircraftHelicopterUtility_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_aircraftHelicopterUtility_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27110;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_aircraftHelicopterUtility_delta_old" ON "dbrdf_aircraftHelicopterUtility_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_aircraftHelicopterUtility_delta_old" ON "dbrdf_aircraftHelicopterUtility_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_aircraftHelicopterUtility_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://dbpedia.org/ontology/aircraftHelicopterUtility$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/aircraftHelicopterUtility$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_aircraftHelicopterUtility_delta_new"(s, o) SELECT t1.o, t0.o FROM "dbrdf_aircraftHelicopterUtility_delta_old" t0, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 27110 AND ex.o = t0.o);


        -- <http://dbpedia.org/ontology/aircraftHelicopterUtility$delta_new>(?X0,?Y) :- <http://dbpedia.org/ontology/aircraftHelicopterUtility$delta_old>(?X0,?X1), owl:sameAs(?X1,?Y) .
        INSERT INTO "dbrdf_aircraftHelicopterUtility_delta_new"(s, o) SELECT t0.s, t1.o FROM "dbrdf_aircraftHelicopterUtility_delta_old" t0, "__triples" t1 WHERE t0.o = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 27110 AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 27110, t0.o FROM "dbrdf_aircraftHelicopterUtility_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_aircraftHelicopterUtility_delta_old";
        INSERT INTO "dbrdf_aircraftHelicopterUtility_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_aircraftHelicopterUtility_delta_new" t0;
        TRUNCATE TABLE "dbrdf_aircraftHelicopterUtility_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 627
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_prospectLeague_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_prospectLeague_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27111;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_prospectLeague_delta_old" ON "dbrdf_prospectLeague_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_prospectLeague_delta_old" ON "dbrdf_prospectLeague_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_prospectLeague_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://dbpedia.org/ontology/prospectLeague$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/prospectLeague$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_prospectLeague_delta_new"(s, o) SELECT t1.o, t0.o FROM "dbrdf_prospectLeague_delta_old" t0, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 27111 AND ex.o = t0.o);


        -- <http://dbpedia.org/ontology/prospectLeague$delta_new>(?X0,?Y) :- <http://dbpedia.org/ontology/prospectLeague$delta_old>(?X0,?X1), owl:sameAs(?X1,?Y) .
        INSERT INTO "dbrdf_prospectLeague_delta_new"(s, o) SELECT t0.s, t1.o FROM "dbrdf_prospectLeague_delta_old" t0, "__triples" t1 WHERE t0.o = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 27111 AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 27111, t0.o FROM "dbrdf_prospectLeague_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_prospectLeague_delta_old";
        INSERT INTO "dbrdf_prospectLeague_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_prospectLeague_delta_new" t0;
        TRUNCATE TABLE "dbrdf_prospectLeague_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 628
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_grammyAward_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_grammyAward_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27112;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_grammyAward_delta_old" ON "dbrdf_grammyAward_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_grammyAward_delta_old" ON "dbrdf_grammyAward_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_grammyAward_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://dbpedia.org/ontology/grammyAward$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/grammyAward$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_grammyAward_delta_new"(s, o) SELECT t1.o, t0.o FROM "dbrdf_grammyAward_delta_old" t0, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 27112 AND ex.o = t0.o);


        -- <http://dbpedia.org/ontology/grammyAward$delta_new>(?X0,?Y) :- <http://dbpedia.org/ontology/grammyAward$delta_old>(?X0,?X1), owl:sameAs(?X1,?Y) .
        INSERT INTO "dbrdf_grammyAward_delta_new"(s, o) SELECT t0.s, t1.o FROM "dbrdf_grammyAward_delta_old" t0, "__triples" t1 WHERE t0.o = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 27112 AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 27112, t0.o FROM "dbrdf_grammyAward_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_grammyAward_delta_old";
        INSERT INTO "dbrdf_grammyAward_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_grammyAward_delta_new" t0;
        TRUNCATE TABLE "dbrdf_grammyAward_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 629
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_vehiclesPerDay_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_vehiclesPerDay_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27113;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_vehiclesPerDay_delta_old" ON "dbrdf_vehiclesPerDay_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_vehiclesPerDay_delta_old" ON "dbrdf_vehiclesPerDay_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_vehiclesPerDay_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://dbpedia.org/ontology/vehiclesPerDay$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/vehiclesPerDay$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_vehiclesPerDay_delta_new"(s, o) SELECT t1.o, t0.o FROM "dbrdf_vehiclesPerDay_delta_old" t0, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 27113 AND ex.o = t0.o);


        -- <http://dbpedia.org/ontology/vehiclesPerDay$delta_new>(?X0,?Y) :- <http://dbpedia.org/ontology/vehiclesPerDay$delta_old>(?X0,?X1), owl:sameAs(?X1,?Y) .
        INSERT INTO "dbrdf_vehiclesPerDay_delta_new"(s, o) SELECT t0.s, t1.o FROM "dbrdf_vehiclesPerDay_delta_old" t0, "__triples" t1 WHERE t0.o = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 27113 AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 27113, t0.o FROM "dbrdf_vehiclesPerDay_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_vehiclesPerDay_delta_old";
        INSERT INTO "dbrdf_vehiclesPerDay_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_vehiclesPerDay_delta_new" t0;
        TRUNCATE TABLE "dbrdf_vehiclesPerDay_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 630
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_restingPlace_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_restingPlace_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27114;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_restingPlace_delta_old" ON "dbrdf_restingPlace_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_restingPlace_delta_old" ON "dbrdf_restingPlace_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_restingPlace_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://dbpedia.org/ontology/restingPlace$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/restingPlace$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_restingPlace_delta_new"(s, o) SELECT t1.o, t0.o FROM "dbrdf_restingPlace_delta_old" t0, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 27114 AND ex.o = t0.o);


        -- <http://dbpedia.org/ontology/restingPlace$delta_new>(?X0,?Y) :- <http://dbpedia.org/ontology/restingPlace$delta_old>(?X0,?X1), owl:sameAs(?X1,?Y) .
        INSERT INTO "dbrdf_restingPlace_delta_new"(s, o) SELECT t0.s, t1.o FROM "dbrdf_restingPlace_delta_old" t0, "__triples" t1 WHERE t0.o = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 27114 AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 27114, t0.o FROM "dbrdf_restingPlace_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_restingPlace_delta_old";
        INSERT INTO "dbrdf_restingPlace_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_restingPlace_delta_new" t0;
        TRUNCATE TABLE "dbrdf_restingPlace_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 631
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_numberOfTerritories_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_numberOfTerritories_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27115;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_numberOfTerritories_delta_old" ON "dbrdf_numberOfTerritories_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_numberOfTerritories_delta_old" ON "dbrdf_numberOfTerritories_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_numberOfTerritories_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://dbpedia.org/ontology/numberOfTerritories$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/numberOfTerritories$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_numberOfTerritories_delta_new"(s, o) SELECT t1.o, t0.o FROM "dbrdf_numberOfTerritories_delta_old" t0, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 27115 AND ex.o = t0.o);


        -- <http://dbpedia.org/ontology/numberOfTerritories$delta_new>(?X0,?Y) :- <http://dbpedia.org/ontology/numberOfTerritories$delta_old>(?X0,?X1), owl:sameAs(?X1,?Y) .
        INSERT INTO "dbrdf_numberOfTerritories_delta_new"(s, o) SELECT t0.s, t1.o FROM "dbrdf_numberOfTerritories_delta_old" t0, "__triples" t1 WHERE t0.o = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 27115 AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 27115, t0.o FROM "dbrdf_numberOfTerritories_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_numberOfTerritories_delta_old";
        INSERT INTO "dbrdf_numberOfTerritories_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_numberOfTerritories_delta_new" t0;
        TRUNCATE TABLE "dbrdf_numberOfTerritories_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 632
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_taoiseach_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_taoiseach_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27116;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_taoiseach_delta_old" ON "dbrdf_taoiseach_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_taoiseach_delta_old" ON "dbrdf_taoiseach_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_taoiseach_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://dbpedia.org/ontology/taoiseach$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/taoiseach$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_taoiseach_delta_new"(s, o) SELECT t1.o, t0.o FROM "dbrdf_taoiseach_delta_old" t0, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 27116 AND ex.o = t0.o);


        -- <http://dbpedia.org/ontology/taoiseach$delta_new>(?X0,?Y) :- <http://dbpedia.org/ontology/taoiseach$delta_old>(?X0,?X1), owl:sameAs(?X1,?Y) .
        INSERT INTO "dbrdf_taoiseach_delta_new"(s, o) SELECT t0.s, t1.o FROM "dbrdf_taoiseach_delta_old" t0, "__triples" t1 WHERE t0.o = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 27116 AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 27116, t0.o FROM "dbrdf_taoiseach_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_taoiseach_delta_old";
        INSERT INTO "dbrdf_taoiseach_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_taoiseach_delta_new" t0;
        TRUNCATE TABLE "dbrdf_taoiseach_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 633
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_routeEnd_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_routeEnd_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27117;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_routeEnd_delta_old" ON "dbrdf_routeEnd_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_routeEnd_delta_old" ON "dbrdf_routeEnd_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_routeEnd_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://dbpedia.org/ontology/routeEnd$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/routeEnd$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_routeEnd_delta_new"(s, o) SELECT t1.o, t0.o FROM "dbrdf_routeEnd_delta_old" t0, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 27117 AND ex.o = t0.o);


        -- <http://dbpedia.org/ontology/routeEnd$delta_new>(?X0,?Y) :- <http://dbpedia.org/ontology/routeEnd$delta_old>(?X0,?X1), owl:sameAs(?X1,?Y) .
        INSERT INTO "dbrdf_routeEnd_delta_new"(s, o) SELECT t0.s, t1.o FROM "dbrdf_routeEnd_delta_old" t0, "__triples" t1 WHERE t0.o = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 27117 AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 27117, t0.o FROM "dbrdf_routeEnd_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_routeEnd_delta_old";
        INSERT INTO "dbrdf_routeEnd_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_routeEnd_delta_new" t0;
        TRUNCATE TABLE "dbrdf_routeEnd_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 634
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_geneLocationStart_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_geneLocationStart_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27118;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_geneLocationStart_delta_old" ON "dbrdf_geneLocationStart_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_geneLocationStart_delta_old" ON "dbrdf_geneLocationStart_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_geneLocationStart_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://dbpedia.org/ontology/geneLocationStart$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/geneLocationStart$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_geneLocationStart_delta_new"(s, o) SELECT t1.o, t0.o FROM "dbrdf_geneLocationStart_delta_old" t0, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 27118 AND ex.o = t0.o);


        -- <http://dbpedia.org/ontology/geneLocationStart$delta_new>(?X0,?Y) :- <http://dbpedia.org/ontology/geneLocationStart$delta_old>(?X0,?X1), owl:sameAs(?X1,?Y) .
        INSERT INTO "dbrdf_geneLocationStart_delta_new"(s, o) SELECT t0.s, t1.o FROM "dbrdf_geneLocationStart_delta_old" t0, "__triples" t1 WHERE t0.o = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 27118 AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 27118, t0.o FROM "dbrdf_geneLocationStart_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_geneLocationStart_delta_old";
        INSERT INTO "dbrdf_geneLocationStart_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_geneLocationStart_delta_new" t0;
        TRUNCATE TABLE "dbrdf_geneLocationStart_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 635
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_aspectRatio_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_aspectRatio_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27119;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_aspectRatio_delta_old" ON "dbrdf_aspectRatio_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_aspectRatio_delta_old" ON "dbrdf_aspectRatio_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_aspectRatio_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://dbpedia.org/ontology/aspectRatio$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/aspectRatio$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_aspectRatio_delta_new"(s, o) SELECT t1.o, t0.o FROM "dbrdf_aspectRatio_delta_old" t0, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 27119 AND ex.o = t0.o);


        -- <http://dbpedia.org/ontology/aspectRatio$delta_new>(?X0,?Y) :- <http://dbpedia.org/ontology/aspectRatio$delta_old>(?X0,?X1), owl:sameAs(?X1,?Y) .
        INSERT INTO "dbrdf_aspectRatio_delta_new"(s, o) SELECT t0.s, t1.o FROM "dbrdf_aspectRatio_delta_old" t0, "__triples" t1 WHERE t0.o = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 27119 AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 27119, t0.o FROM "dbrdf_aspectRatio_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_aspectRatio_delta_old";
        INSERT INTO "dbrdf_aspectRatio_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_aspectRatio_delta_new" t0;
        TRUNCATE TABLE "dbrdf_aspectRatio_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 636
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_BasketballTeam_delta_old"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_BasketballTeam_delta_old"(s) SELECT t0.s FROM "__triples" t0 WHERE t0.p = 2 AND t0.o = 27120;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_BasketballTeam_delta_old" ON "dbrdf_BasketballTeam_delta_old"(s);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_BasketballTeam_delta_new"(s integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://dbpedia.org/ontology/BasketballTeam$delta_new>(?Y) :- <http://dbpedia.org/ontology/BasketballTeam$delta_old>(?X0), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_BasketballTeam_delta_new"(s) SELECT t1.o FROM "dbrdf_BasketballTeam_delta_old" t0, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 2 AND ex.o = 27120);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 2, 27120 FROM "dbrdf_BasketballTeam_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_BasketballTeam_delta_old";
        INSERT INTO "dbrdf_BasketballTeam_delta_old"(s) SELECT DISTINCT t0.s FROM "dbrdf_BasketballTeam_delta_new" t0;
        TRUNCATE TABLE "dbrdf_BasketballTeam_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 637
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_map_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_map_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27121;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_map_delta_old" ON "dbrdf_map_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_map_delta_old" ON "dbrdf_map_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_map_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://dbpedia.org/ontology/map$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/map$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_map_delta_new"(s, o) SELECT t1.o, t0.o FROM "dbrdf_map_delta_old" t0, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 27121 AND ex.o = t0.o);


        -- <http://dbpedia.org/ontology/map$delta_new>(?X0,?Y) :- <http://dbpedia.org/ontology/map$delta_old>(?X0,?X1), owl:sameAs(?X1,?Y) .
        INSERT INTO "dbrdf_map_delta_new"(s, o) SELECT t0.s, t1.o FROM "dbrdf_map_delta_old" t0, "__triples" t1 WHERE t0.o = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 27121 AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 27121, t0.o FROM "dbrdf_map_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_map_delta_old";
        INSERT INTO "dbrdf_map_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_map_delta_new" t0;
        TRUNCATE TABLE "dbrdf_map_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 638
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_europeanAffiliation_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_europeanAffiliation_delta_old"(s, o) SELECT t0.s, t0.o FROM "__triples" t0 WHERE t0.p = 27122;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_europeanAffiliation_delta_old" ON "dbrdf_europeanAffiliation_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_europeanAffiliation_delta_old" ON "dbrdf_europeanAffiliation_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_europeanAffiliation_delta_new"(s integer, o integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://dbpedia.org/ontology/europeanAffiliation$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/europeanAffiliation$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_europeanAffiliation_delta_new"(s, o) SELECT t1.o, t0.o FROM "dbrdf_europeanAffiliation_delta_old" t0, "__triples" t1 WHERE t0.s = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t1.o AND ex.p = 27122 AND ex.o = t0.o);


        -- <http://dbpedia.org/ontology/europeanAffiliation$delta_new>(?X0,?Y) :- <http://dbpedia.org/ontology/europeanAffiliation$delta_old>(?X0,?X1), owl:sameAs(?X1,?Y) .
        INSERT INTO "dbrdf_europeanAffiliation_delta_new"(s, o) SELECT t0.s, t1.o FROM "dbrdf_europeanAffiliation_delta_old" t0, "__triples" t1 WHERE t0.o = t1.s AND t1.p = 26459 AND NOT EXISTS (SELECT 1 FROM "__triples" ex WHERE ex.s = t0.s AND ex.p = 27122 AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "__triples"(s, p, o) SELECT DISTINCT t0.s, 27122, t0.o FROM "dbrdf_europeanAffiliation_delta_new" t0;
        GET DIAGNOSTICS rows_nr = ROW_COUNT;
        total_tuples := total_tuples + rows_nr;
        delta_old_size := delta_old_size + rows_nr;
        TRUNCATE TABLE "dbrdf_europeanAffiliation_delta_old";
        INSERT INTO "dbrdf_europeanAffiliation_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_europeanAffiliation_delta_new" t0;
        TRUNCATE TABLE "dbrdf_europeanAffiliation_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 639
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_schoolBoard_delta_old"(s integer, o integer) ON COMMIT DROP;
