    CREATE LOCAL TEMPORARY TABLE "dbrdf_debut_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_debut_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_debut" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_debut_delta_old" ON "dbrdf_debut_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_debut_delta_old" ON "dbrdf_debut_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_debut_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/debut$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/debut$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_debut_delta_new"(s, o) SELECT t1.o, t0.o FROM "dbrdf_debut_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.s = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_debut" ex WHERE ex.s = t1.o AND ex.o = t0.o);


        -- <http://dbpedia.org/ontology/debut$delta_new>(?X0,?Y) :- <http://dbpedia.org/ontology/debut$delta_old>(?X0,?X1), owl:sameAs(?X1,?Y) .
        INSERT INTO "dbrdf_debut_delta_new"(s, o) SELECT t0.s, t1.o FROM "dbrdf_debut_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.o = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_debut" ex WHERE ex.s = t0.s AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "dbrdf_debut"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_debut_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_debut_delta_old";
        INSERT INTO "dbrdf_debut_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_debut_delta_new" t0;
        TRUNCATE TABLE "dbrdf_debut_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1004
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_winsAtAsia_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_winsAtAsia_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_winsAtAsia" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_winsAtAsia_delta_old" ON "dbrdf_winsAtAsia_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_winsAtAsia_delta_old" ON "dbrdf_winsAtAsia_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_winsAtAsia_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/winsAtAsia$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/winsAtAsia$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_winsAtAsia_delta_new"(s, o) SELECT t1.o, t0.o FROM "dbrdf_winsAtAsia_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.s = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_winsAtAsia" ex WHERE ex.s = t1.o AND ex.o = t0.o);


        -- <http://dbpedia.org/ontology/winsAtAsia$delta_new>(?X0,?Y) :- <http://dbpedia.org/ontology/winsAtAsia$delta_old>(?X0,?X1), owl:sameAs(?X1,?Y) .
        INSERT INTO "dbrdf_winsAtAsia_delta_new"(s, o) SELECT t0.s, t1.o FROM "dbrdf_winsAtAsia_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.o = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_winsAtAsia" ex WHERE ex.s = t0.s AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "dbrdf_winsAtAsia"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_winsAtAsia_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_winsAtAsia_delta_old";
        INSERT INTO "dbrdf_winsAtAsia_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_winsAtAsia_delta_new" t0;
        TRUNCATE TABLE "dbrdf_winsAtAsia_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1005
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_soccerTournamentMostSuccesfull_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_soccerTournamentMostSuccesfull_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_soccerTournamentMostSuccesfull" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_soccerTournamentMostSuccesfull_delta_old" ON "dbrdf_soccerTournamentMostSuccesfull_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_soccerTournamentMostSuccesfull_delta_old" ON "dbrdf_soccerTournamentMostSuccesfull_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_soccerTournamentMostSuccesfull_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/soccerTournamentMostSuccesfull$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/soccerTournamentMostSuccesfull$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_soccerTournamentMostSuccesfull_delta_new"(s, o) SELECT t1.o, t0.o FROM "dbrdf_soccerTournamentMostSuccesfull_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.s = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_soccerTournamentMostSuccesfull" ex WHERE ex.s = t1.o AND ex.o = t0.o);


        -- <http://dbpedia.org/ontology/soccerTournamentMostSuccesfull$delta_new>(?X0,?Y) :- <http://dbpedia.org/ontology/soccerTournamentMostSuccesfull$delta_old>(?X0,?X1), owl:sameAs(?X1,?Y) .
        INSERT INTO "dbrdf_soccerTournamentMostSuccesfull_delta_new"(s, o) SELECT t0.s, t1.o FROM "dbrdf_soccerTournamentMostSuccesfull_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.o = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_soccerTournamentMostSuccesfull" ex WHERE ex.s = t0.s AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "dbrdf_soccerTournamentMostSuccesfull"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_soccerTournamentMostSuccesfull_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_soccerTournamentMostSuccesfull_delta_old";
        INSERT INTO "dbrdf_soccerTournamentMostSuccesfull_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_soccerTournamentMostSuccesfull_delta_new" t0;
        TRUNCATE TABLE "dbrdf_soccerTournamentMostSuccesfull_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1006
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_GaelicGamesPlayer_delta_old"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_GaelicGamesPlayer_delta_old"(s) SELECT t0.s FROM "dbrdf_GaelicGamesPlayer" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_GaelicGamesPlayer_delta_old" ON "dbrdf_GaelicGamesPlayer_delta_old"(s);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_GaelicGamesPlayer_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/GaelicGamesPlayer$delta_new>(?Y) :- <http://dbpedia.org/ontology/GaelicGamesPlayer$delta_old>(?X0), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_GaelicGamesPlayer_delta_new"(s) SELECT t1.o FROM "dbrdf_GaelicGamesPlayer_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.s = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_GaelicGamesPlayer" ex WHERE ex.s = t1.o);


        -- Propagate $delta_new

        INSERT INTO "dbrdf_GaelicGamesPlayer"(s) SELECT DISTINCT t0.s FROM "dbrdf_GaelicGamesPlayer_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_GaelicGamesPlayer_delta_old";
        INSERT INTO "dbrdf_GaelicGamesPlayer_delta_old"(s) SELECT DISTINCT t0.s FROM "dbrdf_GaelicGamesPlayer_delta_new" t0;
        TRUNCATE TABLE "dbrdf_GaelicGamesPlayer_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1007
    ---- DEPENDS ON: 18, 0
    ----------------------------------------

    -- Nonrecursive rules

    -- [Rule] <http://dbpedia.org/ontology/Priest>(?X) :- <http://dbpedia.org/ontology/ordination>(?X,?X1) .
    INSERT INTO "dbrdf_Priest"(s) SELECT DISTINCT t0.s FROM "dbrdf_ordination" t0 WHERE NOT EXISTS (SELECT 1 FROM "dbrdf_Priest" ex WHERE ex.s = t0.s);
    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_Priest_delta_old"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_Priest_delta_old"(s) SELECT t0.s FROM "dbrdf_Priest" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_Priest_delta_old" ON "dbrdf_Priest_delta_old"(s);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_Priest_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/Priest$delta_new>(?Y) :- <http://dbpedia.org/ontology/Priest$delta_old>(?X0), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_Priest_delta_new"(s) SELECT t1.o FROM "dbrdf_Priest_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.s = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_Priest" ex WHERE ex.s = t1.o);


        -- Propagate $delta_new

        INSERT INTO "dbrdf_Priest"(s) SELECT DISTINCT t0.s FROM "dbrdf_Priest_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_Priest_delta_old";
        INSERT INTO "dbrdf_Priest_delta_old"(s) SELECT DISTINCT t0.s FROM "dbrdf_Priest_delta_new" t0;
        TRUNCATE TABLE "dbrdf_Priest_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1008
    ---- 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 "dbrdf_canton" t0;
    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, "dbrdf_sameAs" t1 WHERE t0.s = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_canton" ex WHERE ex.s = t1.o 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, "dbrdf_sameAs" t1 WHERE t0.o = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_canton" ex WHERE ex.s = t0.s AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "dbrdf_canton"(s, o) SELECT DISTINCT t0.s, 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 1009
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_background_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_background_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_background" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_background_delta_old" ON "dbrdf_background_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_background_delta_old" ON "dbrdf_background_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_background_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/background$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/background$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_background_delta_new"(s, o) SELECT t1.o, t0.o FROM "dbrdf_background_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.s = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_background" ex WHERE ex.s = t1.o AND ex.o = t0.o);


        -- <http://dbpedia.org/ontology/background$delta_new>(?X0,?Y) :- <http://dbpedia.org/ontology/background$delta_old>(?X0,?X1), owl:sameAs(?X1,?Y) .
        INSERT INTO "dbrdf_background_delta_new"(s, o) SELECT t0.s, t1.o FROM "dbrdf_background_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.o = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_background" ex WHERE ex.s = t0.s AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "dbrdf_background"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_background_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_background_delta_old";
        INSERT INTO "dbrdf_background_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_background_delta_new" t0;
        TRUNCATE TABLE "dbrdf_background_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1010
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_relatedMeanOfTransportation_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_relatedMeanOfTransportation_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_relatedMeanOfTransportation" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_relatedMeanOfTransportation_delta_old" ON "dbrdf_relatedMeanOfTransportation_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_relatedMeanOfTransportation_delta_old" ON "dbrdf_relatedMeanOfTransportation_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_relatedMeanOfTransportation_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/relatedMeanOfTransportation$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/relatedMeanOfTransportation$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_relatedMeanOfTransportation_delta_new"(s, o) SELECT t1.o, t0.o FROM "dbrdf_relatedMeanOfTransportation_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.s = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_relatedMeanOfTransportation" ex WHERE ex.s = t1.o AND ex.o = t0.o);


        -- <http://dbpedia.org/ontology/relatedMeanOfTransportation$delta_new>(?X0,?Y) :- <http://dbpedia.org/ontology/relatedMeanOfTransportation$delta_old>(?X0,?X1), owl:sameAs(?X1,?Y) .
        INSERT INTO "dbrdf_relatedMeanOfTransportation_delta_new"(s, o) SELECT t0.s, t1.o FROM "dbrdf_relatedMeanOfTransportation_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.o = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_relatedMeanOfTransportation" ex WHERE ex.s = t0.s AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "dbrdf_relatedMeanOfTransportation"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_relatedMeanOfTransportation_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_relatedMeanOfTransportation_delta_old";
        INSERT INTO "dbrdf_relatedMeanOfTransportation_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_relatedMeanOfTransportation_delta_new" t0;
        TRUNCATE TABLE "dbrdf_relatedMeanOfTransportation_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1011
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_river_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_river_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_river" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_river_delta_old" ON "dbrdf_river_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_river_delta_old" ON "dbrdf_river_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_river_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/river$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/river$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_river_delta_new"(s, o) SELECT t1.o, t0.o FROM "dbrdf_river_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.s = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_river" ex WHERE ex.s = t1.o AND ex.o = t0.o);


        -- <http://dbpedia.org/ontology/river$delta_new>(?X0,?Y) :- <http://dbpedia.org/ontology/river$delta_old>(?X0,?X1), owl:sameAs(?X1,?Y) .
        INSERT INTO "dbrdf_river_delta_new"(s, o) SELECT t0.s, t1.o FROM "dbrdf_river_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.o = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_river" ex WHERE ex.s = t0.s AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "dbrdf_river"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_river_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_river_delta_old";
        INSERT INTO "dbrdf_river_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_river_delta_new" t0;
        TRUNCATE TABLE "dbrdf_river_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1012
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_issDockings_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_issDockings_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_issDockings" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_issDockings_delta_old" ON "dbrdf_issDockings_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_issDockings_delta_old" ON "dbrdf_issDockings_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_issDockings_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/issDockings$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/issDockings$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_issDockings_delta_new"(s, o) SELECT t1.o, t0.o FROM "dbrdf_issDockings_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.s = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_issDockings" ex WHERE ex.s = t1.o AND ex.o = t0.o);


        -- <http://dbpedia.org/ontology/issDockings$delta_new>(?X0,?Y) :- <http://dbpedia.org/ontology/issDockings$delta_old>(?X0,?X1), owl:sameAs(?X1,?Y) .
        INSERT INTO "dbrdf_issDockings_delta_new"(s, o) SELECT t0.s, t1.o FROM "dbrdf_issDockings_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.o = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_issDockings" ex WHERE ex.s = t0.s AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "dbrdf_issDockings"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_issDockings_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_issDockings_delta_old";
        INSERT INTO "dbrdf_issDockings_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_issDockings_delta_new" t0;
        TRUNCATE TABLE "dbrdf_issDockings_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1013
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_PaintballLeague_delta_old"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_PaintballLeague_delta_old"(s) SELECT t0.s FROM "dbrdf_PaintballLeague" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_PaintballLeague_delta_old" ON "dbrdf_PaintballLeague_delta_old"(s);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_PaintballLeague_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/PaintballLeague$delta_new>(?Y) :- <http://dbpedia.org/ontology/PaintballLeague$delta_old>(?X0), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_PaintballLeague_delta_new"(s) SELECT t1.o FROM "dbrdf_PaintballLeague_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.s = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_PaintballLeague" ex WHERE ex.s = t1.o);


        -- Propagate $delta_new

        INSERT INTO "dbrdf_PaintballLeague"(s) SELECT DISTINCT t0.s FROM "dbrdf_PaintballLeague_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_PaintballLeague_delta_old";
        INSERT INTO "dbrdf_PaintballLeague_delta_old"(s) SELECT DISTINCT t0.s FROM "dbrdf_PaintballLeague_delta_new" t0;
        TRUNCATE TABLE "dbrdf_PaintballLeague_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1014
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_citizenship_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_citizenship_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_citizenship" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_citizenship_delta_old" ON "dbrdf_citizenship_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_citizenship_delta_old" ON "dbrdf_citizenship_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_citizenship_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/citizenship$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/citizenship$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_citizenship_delta_new"(s, o) SELECT t1.o, t0.o FROM "dbrdf_citizenship_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.s = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_citizenship" ex WHERE ex.s = t1.o AND ex.o = t0.o);


        -- <http://dbpedia.org/ontology/citizenship$delta_new>(?X0,?Y) :- <http://dbpedia.org/ontology/citizenship$delta_old>(?X0,?X1), owl:sameAs(?X1,?Y) .
        INSERT INTO "dbrdf_citizenship_delta_new"(s, o) SELECT t0.s, t1.o FROM "dbrdf_citizenship_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.o = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_citizenship" ex WHERE ex.s = t0.s AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "dbrdf_citizenship"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_citizenship_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_citizenship_delta_old";
        INSERT INTO "dbrdf_citizenship_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_citizenship_delta_new" t0;
        TRUNCATE TABLE "dbrdf_citizenship_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1015
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_yearOfConstruction_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_yearOfConstruction_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_yearOfConstruction" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_yearOfConstruction_delta_old" ON "dbrdf_yearOfConstruction_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_yearOfConstruction_delta_old" ON "dbrdf_yearOfConstruction_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_yearOfConstruction_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/yearOfConstruction$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/yearOfConstruction$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_yearOfConstruction_delta_new"(s, o) SELECT t1.o, t0.o FROM "dbrdf_yearOfConstruction_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.s = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_yearOfConstruction" ex WHERE ex.s = t1.o AND ex.o = t0.o);


        -- <http://dbpedia.org/ontology/yearOfConstruction$delta_new>(?X0,?Y) :- <http://dbpedia.org/ontology/yearOfConstruction$delta_old>(?X0,?X1), owl:sameAs(?X1,?Y) .
        INSERT INTO "dbrdf_yearOfConstruction_delta_new"(s, o) SELECT t0.s, t1.o FROM "dbrdf_yearOfConstruction_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.o = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_yearOfConstruction" ex WHERE ex.s = t0.s AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "dbrdf_yearOfConstruction"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_yearOfConstruction_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_yearOfConstruction_delta_old";
        INSERT INTO "dbrdf_yearOfConstruction_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_yearOfConstruction_delta_new" t0;
        TRUNCATE TABLE "dbrdf_yearOfConstruction_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1016
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_metropolitanBorough_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_metropolitanBorough_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_metropolitanBorough" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_metropolitanBorough_delta_old" ON "dbrdf_metropolitanBorough_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_metropolitanBorough_delta_old" ON "dbrdf_metropolitanBorough_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_metropolitanBorough_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/metropolitanBorough$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/metropolitanBorough$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_metropolitanBorough_delta_new"(s, o) SELECT t1.o, t0.o FROM "dbrdf_metropolitanBorough_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.s = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_metropolitanBorough" ex WHERE ex.s = t1.o AND ex.o = t0.o);


        -- <http://dbpedia.org/ontology/metropolitanBorough$delta_new>(?X0,?Y) :- <http://dbpedia.org/ontology/metropolitanBorough$delta_old>(?X0,?X1), owl:sameAs(?X1,?Y) .
        INSERT INTO "dbrdf_metropolitanBorough_delta_new"(s, o) SELECT t0.s, t1.o FROM "dbrdf_metropolitanBorough_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.o = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_metropolitanBorough" ex WHERE ex.s = t0.s AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "dbrdf_metropolitanBorough"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_metropolitanBorough_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_metropolitanBorough_delta_old";
        INSERT INTO "dbrdf_metropolitanBorough_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_metropolitanBorough_delta_new" t0;
        TRUNCATE TABLE "dbrdf_metropolitanBorough_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1017
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_atcSuffix_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_atcSuffix_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_atcSuffix" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_atcSuffix_delta_old" ON "dbrdf_atcSuffix_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_atcSuffix_delta_old" ON "dbrdf_atcSuffix_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_atcSuffix_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/atcSuffix$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/atcSuffix$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_atcSuffix_delta_new"(s, o) SELECT t1.o, t0.o FROM "dbrdf_atcSuffix_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.s = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_atcSuffix" ex WHERE ex.s = t1.o AND ex.o = t0.o);


        -- <http://dbpedia.org/ontology/atcSuffix$delta_new>(?X0,?Y) :- <http://dbpedia.org/ontology/atcSuffix$delta_old>(?X0,?X1), owl:sameAs(?X1,?Y) .
        INSERT INTO "dbrdf_atcSuffix_delta_new"(s, o) SELECT t0.s, t1.o FROM "dbrdf_atcSuffix_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.o = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_atcSuffix" ex WHERE ex.s = t0.s AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "dbrdf_atcSuffix"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_atcSuffix_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_atcSuffix_delta_old";
        INSERT INTO "dbrdf_atcSuffix_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_atcSuffix_delta_new" t0;
        TRUNCATE TABLE "dbrdf_atcSuffix_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1018
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_mouthState_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_mouthState_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_mouthState" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_mouthState_delta_old" ON "dbrdf_mouthState_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_mouthState_delta_old" ON "dbrdf_mouthState_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_mouthState_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/mouthState$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/mouthState$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_mouthState_delta_new"(s, o) SELECT t1.o, t0.o FROM "dbrdf_mouthState_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.s = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_mouthState" ex WHERE ex.s = t1.o AND ex.o = t0.o);


        -- <http://dbpedia.org/ontology/mouthState$delta_new>(?X0,?Y) :- <http://dbpedia.org/ontology/mouthState$delta_old>(?X0,?X1), owl:sameAs(?X1,?Y) .
        INSERT INTO "dbrdf_mouthState_delta_new"(s, o) SELECT t0.s, t1.o FROM "dbrdf_mouthState_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.o = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_mouthState" ex WHERE ex.s = t0.s AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "dbrdf_mouthState"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_mouthState_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_mouthState_delta_old";
        INSERT INTO "dbrdf_mouthState_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_mouthState_delta_new" t0;
        TRUNCATE TABLE "dbrdf_mouthState_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1019
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_shipLaunch_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_shipLaunch_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_shipLaunch" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_shipLaunch_delta_old" ON "dbrdf_shipLaunch_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_shipLaunch_delta_old" ON "dbrdf_shipLaunch_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_shipLaunch_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/shipLaunch$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/shipLaunch$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_shipLaunch_delta_new"(s, o) SELECT t1.o, t0.o FROM "dbrdf_shipLaunch_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.s = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_shipLaunch" ex WHERE ex.s = t1.o AND ex.o = t0.o);


        -- <http://dbpedia.org/ontology/shipLaunch$delta_new>(?X0,?Y) :- <http://dbpedia.org/ontology/shipLaunch$delta_old>(?X0,?X1), owl:sameAs(?X1,?Y) .
        INSERT INTO "dbrdf_shipLaunch_delta_new"(s, o) SELECT t0.s, t1.o FROM "dbrdf_shipLaunch_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.o = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_shipLaunch" ex WHERE ex.s = t0.s AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "dbrdf_shipLaunch"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_shipLaunch_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_shipLaunch_delta_old";
        INSERT INTO "dbrdf_shipLaunch_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_shipLaunch_delta_new" t0;
        TRUNCATE TABLE "dbrdf_shipLaunch_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1020
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_epoch_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_epoch_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_epoch" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_epoch_delta_old" ON "dbrdf_epoch_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_epoch_delta_old" ON "dbrdf_epoch_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_epoch_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/epoch$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/epoch$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_epoch_delta_new"(s, o) SELECT t1.o, t0.o FROM "dbrdf_epoch_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.s = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_epoch" ex WHERE ex.s = t1.o AND ex.o = t0.o);


        -- <http://dbpedia.org/ontology/epoch$delta_new>(?X0,?Y) :- <http://dbpedia.org/ontology/epoch$delta_old>(?X0,?X1), owl:sameAs(?X1,?Y) .
        INSERT INTO "dbrdf_epoch_delta_new"(s, o) SELECT t0.s, t1.o FROM "dbrdf_epoch_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.o = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_epoch" ex WHERE ex.s = t0.s AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "dbrdf_epoch"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_epoch_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_epoch_delta_old";
        INSERT INTO "dbrdf_epoch_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_epoch_delta_new" t0;
        TRUNCATE TABLE "dbrdf_epoch_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1021
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_doctoralStudent_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_doctoralStudent_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_doctoralStudent" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_doctoralStudent_delta_old" ON "dbrdf_doctoralStudent_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_doctoralStudent_delta_old" ON "dbrdf_doctoralStudent_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_doctoralStudent_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/doctoralStudent$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/doctoralStudent$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_doctoralStudent_delta_new"(s, o) SELECT t1.o, t0.o FROM "dbrdf_doctoralStudent_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.s = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_doctoralStudent" ex WHERE ex.s = t1.o AND ex.o = t0.o);


        -- <http://dbpedia.org/ontology/doctoralStudent$delta_new>(?X0,?Y) :- <http://dbpedia.org/ontology/doctoralStudent$delta_old>(?X0,?X1), owl:sameAs(?X1,?Y) .
        INSERT INTO "dbrdf_doctoralStudent_delta_new"(s, o) SELECT t0.s, t1.o FROM "dbrdf_doctoralStudent_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.o = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_doctoralStudent" ex WHERE ex.s = t0.s AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "dbrdf_doctoralStudent"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_doctoralStudent_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_doctoralStudent_delta_old";
        INSERT INTO "dbrdf_doctoralStudent_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_doctoralStudent_delta_new" t0;
        TRUNCATE TABLE "dbrdf_doctoralStudent_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1022
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_committee_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_committee_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_committee" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_committee_delta_old" ON "dbrdf_committee_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_committee_delta_old" ON "dbrdf_committee_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_committee_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/committee$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/committee$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_committee_delta_new"(s, o) SELECT t1.o, t0.o FROM "dbrdf_committee_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.s = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_committee" ex WHERE ex.s = t1.o AND ex.o = t0.o);


        -- <http://dbpedia.org/ontology/committee$delta_new>(?X0,?Y) :- <http://dbpedia.org/ontology/committee$delta_old>(?X0,?X1), owl:sameAs(?X1,?Y) .
        INSERT INTO "dbrdf_committee_delta_new"(s, o) SELECT t0.s, t1.o FROM "dbrdf_committee_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.o = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_committee" ex WHERE ex.s = t0.s AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "dbrdf_committee"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_committee_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_committee_delta_old";
        INSERT INTO "dbrdf_committee_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_committee_delta_new" t0;
        TRUNCATE TABLE "dbrdf_committee_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1023
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_numberOfOffices_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_numberOfOffices_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_numberOfOffices" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_numberOfOffices_delta_old" ON "dbrdf_numberOfOffices_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_numberOfOffices_delta_old" ON "dbrdf_numberOfOffices_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_numberOfOffices_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/numberOfOffices$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/numberOfOffices$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_numberOfOffices_delta_new"(s, o) SELECT t1.o, t0.o FROM "dbrdf_numberOfOffices_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.s = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_numberOfOffices" ex WHERE ex.s = t1.o AND ex.o = t0.o);


        -- <http://dbpedia.org/ontology/numberOfOffices$delta_new>(?X0,?Y) :- <http://dbpedia.org/ontology/numberOfOffices$delta_old>(?X0,?X1), owl:sameAs(?X1,?Y) .
        INSERT INTO "dbrdf_numberOfOffices_delta_new"(s, o) SELECT t0.s, t1.o FROM "dbrdf_numberOfOffices_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.o = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_numberOfOffices" ex WHERE ex.s = t0.s AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "dbrdf_numberOfOffices"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_numberOfOffices_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_numberOfOffices_delta_old";
        INSERT INTO "dbrdf_numberOfOffices_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_numberOfOffices_delta_new" t0;
        TRUNCATE TABLE "dbrdf_numberOfOffices_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1024
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_appearancesInLeague_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_appearancesInLeague_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_appearancesInLeague" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_appearancesInLeague_delta_old" ON "dbrdf_appearancesInLeague_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_appearancesInLeague_delta_old" ON "dbrdf_appearancesInLeague_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_appearancesInLeague_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/appearancesInLeague$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/appearancesInLeague$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_appearancesInLeague_delta_new"(s, o) SELECT t1.o, t0.o FROM "dbrdf_appearancesInLeague_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.s = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_appearancesInLeague" ex WHERE ex.s = t1.o AND ex.o = t0.o);


        -- <http://dbpedia.org/ontology/appearancesInLeague$delta_new>(?X0,?Y) :- <http://dbpedia.org/ontology/appearancesInLeague$delta_old>(?X0,?X1), owl:sameAs(?X1,?Y) .
        INSERT INTO "dbrdf_appearancesInLeague_delta_new"(s, o) SELECT t0.s, t1.o FROM "dbrdf_appearancesInLeague_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.o = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_appearancesInLeague" ex WHERE ex.s = t0.s AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "dbrdf_appearancesInLeague"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_appearancesInLeague_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_appearancesInLeague_delta_old";
        INSERT INTO "dbrdf_appearancesInLeague_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_appearancesInLeague_delta_new" t0;
        TRUNCATE TABLE "dbrdf_appearancesInLeague_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1025
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_dean_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_dean_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_dean" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_dean_delta_old" ON "dbrdf_dean_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_dean_delta_old" ON "dbrdf_dean_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_dean_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/dean$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/dean$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_dean_delta_new"(s, o) SELECT t1.o, t0.o FROM "dbrdf_dean_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.s = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_dean" ex WHERE ex.s = t1.o AND ex.o = t0.o);


        -- <http://dbpedia.org/ontology/dean$delta_new>(?X0,?Y) :- <http://dbpedia.org/ontology/dean$delta_old>(?X0,?X1), owl:sameAs(?X1,?Y) .
        INSERT INTO "dbrdf_dean_delta_new"(s, o) SELECT t0.s, t1.o FROM "dbrdf_dean_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.o = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_dean" ex WHERE ex.s = t0.s AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "dbrdf_dean"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_dean_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_dean_delta_old";
        INSERT INTO "dbrdf_dean_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_dean_delta_new" t0;
        TRUNCATE TABLE "dbrdf_dean_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1026
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_firstFlight_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_firstFlight_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_firstFlight" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_firstFlight_delta_old" ON "dbrdf_firstFlight_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_firstFlight_delta_old" ON "dbrdf_firstFlight_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_firstFlight_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/firstFlight$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/firstFlight$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_firstFlight_delta_new"(s, o) SELECT t1.o, t0.o FROM "dbrdf_firstFlight_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.s = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_firstFlight" ex WHERE ex.s = t1.o AND ex.o = t0.o);


        -- <http://dbpedia.org/ontology/firstFlight$delta_new>(?X0,?Y) :- <http://dbpedia.org/ontology/firstFlight$delta_old>(?X0,?X1), owl:sameAs(?X1,?Y) .
        INSERT INTO "dbrdf_firstFlight_delta_new"(s, o) SELECT t0.s, t1.o FROM "dbrdf_firstFlight_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.o = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_firstFlight" ex WHERE ex.s = t0.s AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "dbrdf_firstFlight"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_firstFlight_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_firstFlight_delta_old";
        INSERT INTO "dbrdf_firstFlight_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_firstFlight_delta_new" t0;
        TRUNCATE TABLE "dbrdf_firstFlight_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1027
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_cinematography_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_cinematography_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_cinematography" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_cinematography_delta_old" ON "dbrdf_cinematography_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_cinematography_delta_old" ON "dbrdf_cinematography_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_cinematography_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/cinematography$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/cinematography$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_cinematography_delta_new"(s, o) SELECT t1.o, t0.o FROM "dbrdf_cinematography_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.s = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_cinematography" ex WHERE ex.s = t1.o AND ex.o = t0.o);


        -- <http://dbpedia.org/ontology/cinematography$delta_new>(?X0,?Y) :- <http://dbpedia.org/ontology/cinematography$delta_old>(?X0,?X1), owl:sameAs(?X1,?Y) .
        INSERT INTO "dbrdf_cinematography_delta_new"(s, o) SELECT t0.s, t1.o FROM "dbrdf_cinematography_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.o = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_cinematography" ex WHERE ex.s = t0.s AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "dbrdf_cinematography"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_cinematography_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_cinematography_delta_old";
        INSERT INTO "dbrdf_cinematography_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_cinematography_delta_new" t0;
        TRUNCATE TABLE "dbrdf_cinematography_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1028
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_numberOfSilverMedalsWon_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_numberOfSilverMedalsWon_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_numberOfSilverMedalsWon" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_numberOfSilverMedalsWon_delta_old" ON "dbrdf_numberOfSilverMedalsWon_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_numberOfSilverMedalsWon_delta_old" ON "dbrdf_numberOfSilverMedalsWon_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_numberOfSilverMedalsWon_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/numberOfSilverMedalsWon$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/numberOfSilverMedalsWon$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_numberOfSilverMedalsWon_delta_new"(s, o) SELECT t1.o, t0.o FROM "dbrdf_numberOfSilverMedalsWon_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.s = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_numberOfSilverMedalsWon" ex WHERE ex.s = t1.o AND ex.o = t0.o);


        -- <http://dbpedia.org/ontology/numberOfSilverMedalsWon$delta_new>(?X0,?Y) :- <http://dbpedia.org/ontology/numberOfSilverMedalsWon$delta_old>(?X0,?X1), owl:sameAs(?X1,?Y) .
        INSERT INTO "dbrdf_numberOfSilverMedalsWon_delta_new"(s, o) SELECT t0.s, t1.o FROM "dbrdf_numberOfSilverMedalsWon_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.o = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_numberOfSilverMedalsWon" ex WHERE ex.s = t0.s AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "dbrdf_numberOfSilverMedalsWon"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_numberOfSilverMedalsWon_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_numberOfSilverMedalsWon_delta_old";
        INSERT INTO "dbrdf_numberOfSilverMedalsWon_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_numberOfSilverMedalsWon_delta_new" t0;
        TRUNCATE TABLE "dbrdf_numberOfSilverMedalsWon_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1029
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_powerType_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_powerType_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_powerType" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_powerType_delta_old" ON "dbrdf_powerType_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_powerType_delta_old" ON "dbrdf_powerType_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_powerType_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/powerType$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/powerType$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_powerType_delta_new"(s, o) SELECT t1.o, t0.o FROM "dbrdf_powerType_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.s = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_powerType" ex WHERE ex.s = t1.o AND ex.o = t0.o);


        -- <http://dbpedia.org/ontology/powerType$delta_new>(?X0,?Y) :- <http://dbpedia.org/ontology/powerType$delta_old>(?X0,?X1), owl:sameAs(?X1,?Y) .
        INSERT INTO "dbrdf_powerType_delta_new"(s, o) SELECT t0.s, t1.o FROM "dbrdf_powerType_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.o = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_powerType" ex WHERE ex.s = t0.s AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "dbrdf_powerType"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_powerType_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_powerType_delta_old";
        INSERT INTO "dbrdf_powerType_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_powerType_delta_new" t0;
        TRUNCATE TABLE "dbrdf_powerType_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1030
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_SoccerManager_delta_old"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_SoccerManager_delta_old"(s) SELECT t0.s FROM "dbrdf_SoccerManager" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_SoccerManager_delta_old" ON "dbrdf_SoccerManager_delta_old"(s);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_SoccerManager_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/SoccerManager$delta_new>(?Y) :- <http://dbpedia.org/ontology/SoccerManager$delta_old>(?X0), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_SoccerManager_delta_new"(s) SELECT t1.o FROM "dbrdf_SoccerManager_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.s = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_SoccerManager" ex WHERE ex.s = t1.o);


        -- Propagate $delta_new

        INSERT INTO "dbrdf_SoccerManager"(s) SELECT DISTINCT t0.s FROM "dbrdf_SoccerManager_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_SoccerManager_delta_old";
        INSERT INTO "dbrdf_SoccerManager_delta_old"(s) SELECT DISTINCT t0.s FROM "dbrdf_SoccerManager_delta_new" t0;
        TRUNCATE TABLE "dbrdf_SoccerManager_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1031
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_municipalityCode_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_municipalityCode_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_municipalityCode" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_municipalityCode_delta_old" ON "dbrdf_municipalityCode_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_municipalityCode_delta_old" ON "dbrdf_municipalityCode_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_municipalityCode_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/municipalityCode$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/municipalityCode$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_municipalityCode_delta_new"(s, o) SELECT t1.o, t0.o FROM "dbrdf_municipalityCode_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.s = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_municipalityCode" ex WHERE ex.s = t1.o AND ex.o = t0.o);


        -- <http://dbpedia.org/ontology/municipalityCode$delta_new>(?X0,?Y) :- <http://dbpedia.org/ontology/municipalityCode$delta_old>(?X0,?X1), owl:sameAs(?X1,?Y) .
        INSERT INTO "dbrdf_municipalityCode_delta_new"(s, o) SELECT t0.s, t1.o FROM "dbrdf_municipalityCode_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.o = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_municipalityCode" ex WHERE ex.s = t0.s AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "dbrdf_municipalityCode"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_municipalityCode_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_municipalityCode_delta_old";
        INSERT INTO "dbrdf_municipalityCode_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_municipalityCode_delta_new" t0;
        TRUNCATE TABLE "dbrdf_municipalityCode_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1032
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_openAccessContent_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_openAccessContent_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_openAccessContent" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_openAccessContent_delta_old" ON "dbrdf_openAccessContent_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_openAccessContent_delta_old" ON "dbrdf_openAccessContent_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_openAccessContent_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/openAccessContent$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/openAccessContent$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_openAccessContent_delta_new"(s, o) SELECT t1.o, t0.o FROM "dbrdf_openAccessContent_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.s = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_openAccessContent" ex WHERE ex.s = t1.o AND ex.o = t0.o);


        -- <http://dbpedia.org/ontology/openAccessContent$delta_new>(?X0,?Y) :- <http://dbpedia.org/ontology/openAccessContent$delta_old>(?X0,?X1), owl:sameAs(?X1,?Y) .
        INSERT INTO "dbrdf_openAccessContent_delta_new"(s, o) SELECT t0.s, t1.o FROM "dbrdf_openAccessContent_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.o = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_openAccessContent" ex WHERE ex.s = t0.s AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "dbrdf_openAccessContent"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_openAccessContent_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_openAccessContent_delta_old";
        INSERT INTO "dbrdf_openAccessContent_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_openAccessContent_delta_new" t0;
        TRUNCATE TABLE "dbrdf_openAccessContent_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1033
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_countryWithFirstSatelliteLaunched_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_countryWithFirstSatelliteLaunched_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_countryWithFirstSatelliteLaunched" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_countryWithFirstSatelliteLaunched_delta_old" ON "dbrdf_countryWithFirstSatelliteLaunched_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_countryWithFirstSatelliteLaunched_delta_old" ON "dbrdf_countryWithFirstSatelliteLaunched_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_countryWithFirstSatelliteLaunched_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/countryWithFirstSatelliteLaunched$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/countryWithFirstSatelliteLaunched$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_countryWithFirstSatelliteLaunched_delta_new"(s, o) SELECT t1.o, t0.o FROM "dbrdf_countryWithFirstSatelliteLaunched_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.s = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_countryWithFirstSatelliteLaunched" ex WHERE ex.s = t1.o AND ex.o = t0.o);


        -- <http://dbpedia.org/ontology/countryWithFirstSatelliteLaunched$delta_new>(?X0,?Y) :- <http://dbpedia.org/ontology/countryWithFirstSatelliteLaunched$delta_old>(?X0,?X1), owl:sameAs(?X1,?Y) .
        INSERT INTO "dbrdf_countryWithFirstSatelliteLaunched_delta_new"(s, o) SELECT t0.s, t1.o FROM "dbrdf_countryWithFirstSatelliteLaunched_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.o = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_countryWithFirstSatelliteLaunched" ex WHERE ex.s = t0.s AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "dbrdf_countryWithFirstSatelliteLaunched"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_countryWithFirstSatelliteLaunched_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_countryWithFirstSatelliteLaunched_delta_old";
        INSERT INTO "dbrdf_countryWithFirstSatelliteLaunched_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_countryWithFirstSatelliteLaunched_delta_new" t0;
        TRUNCATE TABLE "dbrdf_countryWithFirstSatelliteLaunched_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1034
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_productionStartDate_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_productionStartDate_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_productionStartDate" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_productionStartDate_delta_old" ON "dbrdf_productionStartDate_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_productionStartDate_delta_old" ON "dbrdf_productionStartDate_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_productionStartDate_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/productionStartDate$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/productionStartDate$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_productionStartDate_delta_new"(s, o) SELECT t1.o, t0.o FROM "dbrdf_productionStartDate_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.s = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_productionStartDate" ex WHERE ex.s = t1.o AND ex.o = t0.o);


        -- <http://dbpedia.org/ontology/productionStartDate$delta_new>(?X0,?Y) :- <http://dbpedia.org/ontology/productionStartDate$delta_old>(?X0,?X1), owl:sameAs(?X1,?Y) .
        INSERT INTO "dbrdf_productionStartDate_delta_new"(s, o) SELECT t0.s, t1.o FROM "dbrdf_productionStartDate_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.o = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_productionStartDate" ex WHERE ex.s = t0.s AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "dbrdf_productionStartDate"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_productionStartDate_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_productionStartDate_delta_old";
        INSERT INTO "dbrdf_productionStartDate_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_productionStartDate_delta_new" t0;
        TRUNCATE TABLE "dbrdf_productionStartDate_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1035
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_service_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_service_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_service" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_service_delta_old" ON "dbrdf_service_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_service_delta_old" ON "dbrdf_service_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_service_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/service$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/service$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_service_delta_new"(s, o) SELECT t1.o, t0.o FROM "dbrdf_service_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.s = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_service" ex WHERE ex.s = t1.o AND ex.o = t0.o);


        -- <http://dbpedia.org/ontology/service$delta_new>(?X0,?Y) :- <http://dbpedia.org/ontology/service$delta_old>(?X0,?X1), owl:sameAs(?X1,?Y) .
        INSERT INTO "dbrdf_service_delta_new"(s, o) SELECT t0.s, t1.o FROM "dbrdf_service_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.o = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_service" ex WHERE ex.s = t0.s AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "dbrdf_service"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_service_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_service_delta_old";
        INSERT INTO "dbrdf_service_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_service_delta_new" t0;
        TRUNCATE TABLE "dbrdf_service_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1036
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_shipCrew_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_shipCrew_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_shipCrew" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_shipCrew_delta_old" ON "dbrdf_shipCrew_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_shipCrew_delta_old" ON "dbrdf_shipCrew_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_shipCrew_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/shipCrew$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/shipCrew$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_shipCrew_delta_new"(s, o) SELECT t1.o, t0.o FROM "dbrdf_shipCrew_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.s = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_shipCrew" ex WHERE ex.s = t1.o AND ex.o = t0.o);


        -- <http://dbpedia.org/ontology/shipCrew$delta_new>(?X0,?Y) :- <http://dbpedia.org/ontology/shipCrew$delta_old>(?X0,?X1), owl:sameAs(?X1,?Y) .
        INSERT INTO "dbrdf_shipCrew_delta_new"(s, o) SELECT t0.s, t1.o FROM "dbrdf_shipCrew_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.o = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_shipCrew" ex WHERE ex.s = t0.s AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "dbrdf_shipCrew"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_shipCrew_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_shipCrew_delta_old";
        INSERT INTO "dbrdf_shipCrew_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_shipCrew_delta_new" t0;
        TRUNCATE TABLE "dbrdf_shipCrew_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1037
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_numberOfPiersInWater_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_numberOfPiersInWater_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_numberOfPiersInWater" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_numberOfPiersInWater_delta_old" ON "dbrdf_numberOfPiersInWater_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_numberOfPiersInWater_delta_old" ON "dbrdf_numberOfPiersInWater_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_numberOfPiersInWater_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/numberOfPiersInWater$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/numberOfPiersInWater$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_numberOfPiersInWater_delta_new"(s, o) SELECT t1.o, t0.o FROM "dbrdf_numberOfPiersInWater_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.s = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_numberOfPiersInWater" ex WHERE ex.s = t1.o AND ex.o = t0.o);


        -- <http://dbpedia.org/ontology/numberOfPiersInWater$delta_new>(?X0,?Y) :- <http://dbpedia.org/ontology/numberOfPiersInWater$delta_old>(?X0,?X1), owl:sameAs(?X1,?Y) .
        INSERT INTO "dbrdf_numberOfPiersInWater_delta_new"(s, o) SELECT t0.s, t1.o FROM "dbrdf_numberOfPiersInWater_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.o = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_numberOfPiersInWater" ex WHERE ex.s = t0.s AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "dbrdf_numberOfPiersInWater"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_numberOfPiersInWater_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_numberOfPiersInWater_delta_old";
        INSERT INTO "dbrdf_numberOfPiersInWater_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_numberOfPiersInWater_delta_new" t0;
        TRUNCATE TABLE "dbrdf_numberOfPiersInWater_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1038
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_state_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_state_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_state" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_state_delta_old" ON "dbrdf_state_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_state_delta_old" ON "dbrdf_state_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_state_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/state$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/state$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_state_delta_new"(s, o) SELECT t1.o, t0.o FROM "dbrdf_state_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.s = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_state" ex WHERE ex.s = t1.o AND ex.o = t0.o);


        -- <http://dbpedia.org/ontology/state$delta_new>(?X0,?Y) :- <http://dbpedia.org/ontology/state$delta_old>(?X0,?X1), owl:sameAs(?X1,?Y) .
        INSERT INTO "dbrdf_state_delta_new"(s, o) SELECT t0.s, t1.o FROM "dbrdf_state_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.o = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_state" ex WHERE ex.s = t0.s AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "dbrdf_state"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_state_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_state_delta_old";
        INSERT INTO "dbrdf_state_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_state_delta_new" t0;
        TRUNCATE TABLE "dbrdf_state_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1039
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_hallOfFame_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_hallOfFame_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_hallOfFame" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_hallOfFame_delta_old" ON "dbrdf_hallOfFame_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_hallOfFame_delta_old" ON "dbrdf_hallOfFame_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_hallOfFame_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/hallOfFame$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/hallOfFame$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_hallOfFame_delta_new"(s, o) SELECT t1.o, t0.o FROM "dbrdf_hallOfFame_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.s = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_hallOfFame" ex WHERE ex.s = t1.o AND ex.o = t0.o);


        -- <http://dbpedia.org/ontology/hallOfFame$delta_new>(?X0,?Y) :- <http://dbpedia.org/ontology/hallOfFame$delta_old>(?X0,?X1), owl:sameAs(?X1,?Y) .
        INSERT INTO "dbrdf_hallOfFame_delta_new"(s, o) SELECT t0.s, t1.o FROM "dbrdf_hallOfFame_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.o = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_hallOfFame" ex WHERE ex.s = t0.s AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "dbrdf_hallOfFame"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_hallOfFame_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_hallOfFame_delta_old";
        INSERT INTO "dbrdf_hallOfFame_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_hallOfFame_delta_new" t0;
        TRUNCATE TABLE "dbrdf_hallOfFame_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1040
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_fileSize_delta_old0"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_fileSize_delta_old0"(s, o) SELECT t0.s, t0.o FROM "dbrdf_fileSize0" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_fileSize_delta_old0" ON "dbrdf_fileSize_delta_old0"(s, o); CREATE INDEX "IDX_1_dbrdf_fileSize_delta_old0" ON "dbrdf_fileSize_delta_old0"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_fileSize_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/fileSize$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/fileSize$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_fileSize_delta_new0"(s, o) SELECT t1.o, t0.o FROM "dbrdf_fileSize_delta_old0" t0, "dbrdf_sameAs" t1 WHERE t0.s = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_fileSize0" ex WHERE ex.s = t1.o AND ex.o = t0.o);


        -- <http://dbpedia.org/ontology/fileSize$delta_new>(?X0,?Y) :- <http://dbpedia.org/ontology/fileSize$delta_old>(?X0,?X1), owl:sameAs(?X1,?Y) .
        INSERT INTO "dbrdf_fileSize_delta_new0"(s, o) SELECT t0.s, t1.o FROM "dbrdf_fileSize_delta_old0" t0, "dbrdf_sameAs" t1 WHERE t0.o = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_fileSize0" ex WHERE ex.s = t0.s AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "dbrdf_fileSize0"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_fileSize_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_fileSize_delta_old0";
        INSERT INTO "dbrdf_fileSize_delta_old0"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_fileSize_delta_new0" t0;
        TRUNCATE TABLE "dbrdf_fileSize_delta_new0";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1041
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_mouthRegion_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_mouthRegion_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_mouthRegion" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_mouthRegion_delta_old" ON "dbrdf_mouthRegion_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_mouthRegion_delta_old" ON "dbrdf_mouthRegion_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_mouthRegion_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/mouthRegion$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/mouthRegion$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_mouthRegion_delta_new"(s, o) SELECT t1.o, t0.o FROM "dbrdf_mouthRegion_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.s = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_mouthRegion" ex WHERE ex.s = t1.o AND ex.o = t0.o);


        -- <http://dbpedia.org/ontology/mouthRegion$delta_new>(?X0,?Y) :- <http://dbpedia.org/ontology/mouthRegion$delta_old>(?X0,?X1), owl:sameAs(?X1,?Y) .
        INSERT INTO "dbrdf_mouthRegion_delta_new"(s, o) SELECT t0.s, t1.o FROM "dbrdf_mouthRegion_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.o = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_mouthRegion" ex WHERE ex.s = t0.s AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "dbrdf_mouthRegion"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_mouthRegion_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_mouthRegion_delta_old";
        INSERT INTO "dbrdf_mouthRegion_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_mouthRegion_delta_new" t0;
        TRUNCATE TABLE "dbrdf_mouthRegion_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1042
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_lengthReference_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_lengthReference_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_lengthReference" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_lengthReference_delta_old" ON "dbrdf_lengthReference_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_lengthReference_delta_old" ON "dbrdf_lengthReference_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_lengthReference_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/lengthReference$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/lengthReference$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_lengthReference_delta_new"(s, o) SELECT t1.o, t0.o FROM "dbrdf_lengthReference_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.s = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_lengthReference" ex WHERE ex.s = t1.o AND ex.o = t0.o);


        -- <http://dbpedia.org/ontology/lengthReference$delta_new>(?X0,?Y) :- <http://dbpedia.org/ontology/lengthReference$delta_old>(?X0,?X1), owl:sameAs(?X1,?Y) .
        INSERT INTO "dbrdf_lengthReference_delta_new"(s, o) SELECT t0.s, t1.o FROM "dbrdf_lengthReference_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.o = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_lengthReference" ex WHERE ex.s = t0.s AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "dbrdf_lengthReference"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_lengthReference_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_lengthReference_delta_old";
        INSERT INTO "dbrdf_lengthReference_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_lengthReference_delta_new" t0;
        TRUNCATE TABLE "dbrdf_lengthReference_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1043
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_icd10_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_icd10_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_icd10" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_icd10_delta_old" ON "dbrdf_icd10_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_icd10_delta_old" ON "dbrdf_icd10_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_icd10_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/icd10$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/icd10$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_icd10_delta_new"(s, o) SELECT t1.o, t0.o FROM "dbrdf_icd10_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.s = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_icd10" ex WHERE ex.s = t1.o AND ex.o = t0.o);


        -- <http://dbpedia.org/ontology/icd10$delta_new>(?X0,?Y) :- <http://dbpedia.org/ontology/icd10$delta_old>(?X0,?X1), owl:sameAs(?X1,?Y) .
        INSERT INTO "dbrdf_icd10_delta_new"(s, o) SELECT t0.s, t1.o FROM "dbrdf_icd10_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.o = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_icd10" ex WHERE ex.s = t0.s AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "dbrdf_icd10"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_icd10_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_icd10_delta_old";
        INSERT INTO "dbrdf_icd10_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_icd10_delta_new" t0;
        TRUNCATE TABLE "dbrdf_icd10_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1044
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_teachingStaff_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_teachingStaff_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_teachingStaff" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_teachingStaff_delta_old" ON "dbrdf_teachingStaff_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_teachingStaff_delta_old" ON "dbrdf_teachingStaff_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_teachingStaff_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/teachingStaff$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/teachingStaff$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_teachingStaff_delta_new"(s, o) SELECT t1.o, t0.o FROM "dbrdf_teachingStaff_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.s = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_teachingStaff" ex WHERE ex.s = t1.o AND ex.o = t0.o);


        -- <http://dbpedia.org/ontology/teachingStaff$delta_new>(?X0,?Y) :- <http://dbpedia.org/ontology/teachingStaff$delta_old>(?X0,?X1), owl:sameAs(?X1,?Y) .
        INSERT INTO "dbrdf_teachingStaff_delta_new"(s, o) SELECT t0.s, t1.o FROM "dbrdf_teachingStaff_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.o = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_teachingStaff" ex WHERE ex.s = t0.s AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "dbrdf_teachingStaff"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_teachingStaff_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_teachingStaff_delta_old";
        INSERT INTO "dbrdf_teachingStaff_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_teachingStaff_delta_new" t0;
        TRUNCATE TABLE "dbrdf_teachingStaff_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1045
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_federalState_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_federalState_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_federalState" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_federalState_delta_old" ON "dbrdf_federalState_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_federalState_delta_old" ON "dbrdf_federalState_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_federalState_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/federalState$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/federalState$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_federalState_delta_new"(s, o) SELECT t1.o, t0.o FROM "dbrdf_federalState_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.s = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_federalState" ex WHERE ex.s = t1.o AND ex.o = t0.o);


        -- <http://dbpedia.org/ontology/federalState$delta_new>(?X0,?Y) :- <http://dbpedia.org/ontology/federalState$delta_old>(?X0,?X1), owl:sameAs(?X1,?Y) .
        INSERT INTO "dbrdf_federalState_delta_new"(s, o) SELECT t0.s, t1.o FROM "dbrdf_federalState_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.o = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_federalState" ex WHERE ex.s = t0.s AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "dbrdf_federalState"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_federalState_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_federalState_delta_old";
        INSERT INTO "dbrdf_federalState_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_federalState_delta_new" t0;
        TRUNCATE TABLE "dbrdf_federalState_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1046
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_rotationPeriod_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_rotationPeriod_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_rotationPeriod" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_rotationPeriod_delta_old" ON "dbrdf_rotationPeriod_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_rotationPeriod_delta_old" ON "dbrdf_rotationPeriod_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_rotationPeriod_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/rotationPeriod$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/rotationPeriod$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_rotationPeriod_delta_new"(s, o) SELECT t1.o, t0.o FROM "dbrdf_rotationPeriod_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.s = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_rotationPeriod" ex WHERE ex.s = t1.o AND ex.o = t0.o);


        -- <http://dbpedia.org/ontology/rotationPeriod$delta_new>(?X0,?Y) :- <http://dbpedia.org/ontology/rotationPeriod$delta_old>(?X0,?X1), owl:sameAs(?X1,?Y) .
        INSERT INTO "dbrdf_rotationPeriod_delta_new"(s, o) SELECT t0.s, t1.o FROM "dbrdf_rotationPeriod_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.o = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_rotationPeriod" ex WHERE ex.s = t0.s AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "dbrdf_rotationPeriod"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_rotationPeriod_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_rotationPeriod_delta_old";
        INSERT INTO "dbrdf_rotationPeriod_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_rotationPeriod_delta_new" t0;
        TRUNCATE TABLE "dbrdf_rotationPeriod_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1047
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_coach_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_coach_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_coach" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_coach_delta_old" ON "dbrdf_coach_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_coach_delta_old" ON "dbrdf_coach_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_coach_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/coach$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/coach$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_coach_delta_new"(s, o) SELECT t1.o, t0.o FROM "dbrdf_coach_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.s = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_coach" ex WHERE ex.s = t1.o AND ex.o = t0.o);


        -- <http://dbpedia.org/ontology/coach$delta_new>(?X0,?Y) :- <http://dbpedia.org/ontology/coach$delta_old>(?X0,?X1), owl:sameAs(?X1,?Y) .
        INSERT INTO "dbrdf_coach_delta_new"(s, o) SELECT t0.s, t1.o FROM "dbrdf_coach_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.o = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_coach" ex WHERE ex.s = t0.s AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "dbrdf_coach"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_coach_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_coach_delta_old";
        INSERT INTO "dbrdf_coach_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_coach_delta_new" t0;
        TRUNCATE TABLE "dbrdf_coach_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1048
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_meltingPoint_delta_old0"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_meltingPoint_delta_old0"(s, o) SELECT t0.s, t0.o FROM "dbrdf_meltingPoint0" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_meltingPoint_delta_old0" ON "dbrdf_meltingPoint_delta_old0"(s, o); CREATE INDEX "IDX_1_dbrdf_meltingPoint_delta_old0" ON "dbrdf_meltingPoint_delta_old0"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_meltingPoint_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/meltingPoint$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/meltingPoint$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_meltingPoint_delta_new0"(s, o) SELECT t1.o, t0.o FROM "dbrdf_meltingPoint_delta_old0" t0, "dbrdf_sameAs" t1 WHERE t0.s = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_meltingPoint0" ex WHERE ex.s = t1.o AND ex.o = t0.o);


        -- <http://dbpedia.org/ontology/meltingPoint$delta_new>(?X0,?Y) :- <http://dbpedia.org/ontology/meltingPoint$delta_old>(?X0,?X1), owl:sameAs(?X1,?Y) .
        INSERT INTO "dbrdf_meltingPoint_delta_new0"(s, o) SELECT t0.s, t1.o FROM "dbrdf_meltingPoint_delta_old0" t0, "dbrdf_sameAs" t1 WHERE t0.o = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_meltingPoint0" ex WHERE ex.s = t0.s AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "dbrdf_meltingPoint0"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_meltingPoint_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_meltingPoint_delta_old0";
        INSERT INTO "dbrdf_meltingPoint_delta_old0"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_meltingPoint_delta_new0" t0;
        TRUNCATE TABLE "dbrdf_meltingPoint_delta_new0";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1049
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_shareDate_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_shareDate_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_shareDate" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_shareDate_delta_old" ON "dbrdf_shareDate_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_shareDate_delta_old" ON "dbrdf_shareDate_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_shareDate_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/shareDate$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/shareDate$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_shareDate_delta_new"(s, o) SELECT t1.o, t0.o FROM "dbrdf_shareDate_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.s = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_shareDate" ex WHERE ex.s = t1.o AND ex.o = t0.o);


        -- <http://dbpedia.org/ontology/shareDate$delta_new>(?X0,?Y) :- <http://dbpedia.org/ontology/shareDate$delta_old>(?X0,?X1), owl:sameAs(?X1,?Y) .
        INSERT INTO "dbrdf_shareDate_delta_new"(s, o) SELECT t0.s, t1.o FROM "dbrdf_shareDate_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.o = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_shareDate" ex WHERE ex.s = t0.s AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "dbrdf_shareDate"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_shareDate_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_shareDate_delta_old";
        INSERT INTO "dbrdf_shareDate_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_shareDate_delta_new" t0;
        TRUNCATE TABLE "dbrdf_shareDate_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1050
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_firstLeader_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_firstLeader_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_firstLeader" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_firstLeader_delta_old" ON "dbrdf_firstLeader_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_firstLeader_delta_old" ON "dbrdf_firstLeader_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_firstLeader_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/firstLeader$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/firstLeader$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_firstLeader_delta_new"(s, o) SELECT t1.o, t0.o FROM "dbrdf_firstLeader_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.s = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_firstLeader" ex WHERE ex.s = t1.o AND ex.o = t0.o);


        -- <http://dbpedia.org/ontology/firstLeader$delta_new>(?X0,?Y) :- <http://dbpedia.org/ontology/firstLeader$delta_old>(?X0,?X1), owl:sameAs(?X1,?Y) .
        INSERT INTO "dbrdf_firstLeader_delta_new"(s, o) SELECT t0.s, t1.o FROM "dbrdf_firstLeader_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.o = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_firstLeader" ex WHERE ex.s = t0.s AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "dbrdf_firstLeader"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_firstLeader_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_firstLeader_delta_old";
        INSERT INTO "dbrdf_firstLeader_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_firstLeader_delta_new" t0;
        TRUNCATE TABLE "dbrdf_firstLeader_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1051
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_other_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_other_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_other" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_other_delta_old" ON "dbrdf_other_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_other_delta_old" ON "dbrdf_other_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_other_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/other$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/other$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_other_delta_new"(s, o) SELECT t1.o, t0.o FROM "dbrdf_other_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.s = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_other" ex WHERE ex.s = t1.o AND ex.o = t0.o);


        -- <http://dbpedia.org/ontology/other$delta_new>(?X0,?Y) :- <http://dbpedia.org/ontology/other$delta_old>(?X0,?X1), owl:sameAs(?X1,?Y) .
        INSERT INTO "dbrdf_other_delta_new"(s, o) SELECT t0.s, t1.o FROM "dbrdf_other_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.o = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_other" ex WHERE ex.s = t0.s AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "dbrdf_other"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_other_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_other_delta_old";
        INSERT INTO "dbrdf_other_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_other_delta_new" t0;
        TRUNCATE TABLE "dbrdf_other_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1052
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_volume_delta_old1"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_volume_delta_old1"(s, o) SELECT t0.s, t0.o FROM "dbrdf_volume1" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_volume_delta_old1" ON "dbrdf_volume_delta_old1"(s, o); CREATE INDEX "IDX_1_dbrdf_volume_delta_old1" ON "dbrdf_volume_delta_old1"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_volume_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/Planet/volume$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/Planet/volume$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_volume_delta_new1"(s, o) SELECT t1.o, t0.o FROM "dbrdf_volume_delta_old1" t0, "dbrdf_sameAs" t1 WHERE t0.s = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_volume1" ex WHERE ex.s = t1.o AND ex.o = t0.o);


        -- <http://dbpedia.org/ontology/Planet/volume$delta_new>(?X0,?Y) :- <http://dbpedia.org/ontology/Planet/volume$delta_old>(?X0,?X1), owl:sameAs(?X1,?Y) .
        INSERT INTO "dbrdf_volume_delta_new1"(s, o) SELECT t0.s, t1.o FROM "dbrdf_volume_delta_old1" t0, "dbrdf_sameAs" t1 WHERE t0.o = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_volume1" ex WHERE ex.s = t0.s AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "dbrdf_volume1"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_volume_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_volume_delta_old1";
        INSERT INTO "dbrdf_volume_delta_old1"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_volume_delta_new1" t0;
        TRUNCATE TABLE "dbrdf_volume_delta_new1";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1053
    ---- 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 "dbrdf_assets" t0;
    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, "dbrdf_sameAs" t1 WHERE t0.s = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_assets" ex WHERE ex.s = t1.o 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, "dbrdf_sameAs" t1 WHERE t0.o = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_assets" ex WHERE ex.s = t0.s AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "dbrdf_assets"(s, o) SELECT DISTINCT t0.s, 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 1054
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_serviceStartYear_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_serviceStartYear_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_serviceStartYear" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_serviceStartYear_delta_old" ON "dbrdf_serviceStartYear_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_serviceStartYear_delta_old" ON "dbrdf_serviceStartYear_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_serviceStartYear_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/serviceStartYear$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/serviceStartYear$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_serviceStartYear_delta_new"(s, o) SELECT t1.o, t0.o FROM "dbrdf_serviceStartYear_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.s = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_serviceStartYear" ex WHERE ex.s = t1.o AND ex.o = t0.o);


        -- <http://dbpedia.org/ontology/serviceStartYear$delta_new>(?X0,?Y) :- <http://dbpedia.org/ontology/serviceStartYear$delta_old>(?X0,?X1), owl:sameAs(?X1,?Y) .
        INSERT INTO "dbrdf_serviceStartYear_delta_new"(s, o) SELECT t0.s, t1.o FROM "dbrdf_serviceStartYear_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.o = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_serviceStartYear" ex WHERE ex.s = t0.s AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "dbrdf_serviceStartYear"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_serviceStartYear_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_serviceStartYear_delta_old";
        INSERT INTO "dbrdf_serviceStartYear_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_serviceStartYear_delta_new" t0;
        TRUNCATE TABLE "dbrdf_serviceStartYear_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1055
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_mouthPosition_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_mouthPosition_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_mouthPosition" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_mouthPosition_delta_old" ON "dbrdf_mouthPosition_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_mouthPosition_delta_old" ON "dbrdf_mouthPosition_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_mouthPosition_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/mouthPosition$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/mouthPosition$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_mouthPosition_delta_new"(s, o) SELECT t1.o, t0.o FROM "dbrdf_mouthPosition_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.s = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_mouthPosition" ex WHERE ex.s = t1.o AND ex.o = t0.o);


        -- <http://dbpedia.org/ontology/mouthPosition$delta_new>(?X0,?Y) :- <http://dbpedia.org/ontology/mouthPosition$delta_old>(?X0,?X1), owl:sameAs(?X1,?Y) .
        INSERT INTO "dbrdf_mouthPosition_delta_new"(s, o) SELECT t0.s, t1.o FROM "dbrdf_mouthPosition_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.o = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_mouthPosition" ex WHERE ex.s = t0.s AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "dbrdf_mouthPosition"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_mouthPosition_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_mouthPosition_delta_old";
        INSERT INTO "dbrdf_mouthPosition_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_mouthPosition_delta_new" t0;
        TRUNCATE TABLE "dbrdf_mouthPosition_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1056
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_editorTitle_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_editorTitle_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_editorTitle" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_editorTitle_delta_old" ON "dbrdf_editorTitle_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_editorTitle_delta_old" ON "dbrdf_editorTitle_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_editorTitle_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/editorTitle$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/editorTitle$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_editorTitle_delta_new"(s, o) SELECT t1.o, t0.o FROM "dbrdf_editorTitle_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.s = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_editorTitle" ex WHERE ex.s = t1.o AND ex.o = t0.o);


        -- <http://dbpedia.org/ontology/editorTitle$delta_new>(?X0,?Y) :- <http://dbpedia.org/ontology/editorTitle$delta_old>(?X0,?X1), owl:sameAs(?X1,?Y) .
        INSERT INTO "dbrdf_editorTitle_delta_new"(s, o) SELECT t0.s, t1.o FROM "dbrdf_editorTitle_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.o = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_editorTitle" ex WHERE ex.s = t0.s AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "dbrdf_editorTitle"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_editorTitle_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_editorTitle_delta_old";
        INSERT INTO "dbrdf_editorTitle_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_editorTitle_delta_new" t0;
        TRUNCATE TABLE "dbrdf_editorTitle_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1057
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_valvetrain_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_valvetrain_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_valvetrain" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_valvetrain_delta_old" ON "dbrdf_valvetrain_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_valvetrain_delta_old" ON "dbrdf_valvetrain_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_valvetrain_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/valvetrain$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/valvetrain$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_valvetrain_delta_new"(s, o) SELECT t1.o, t0.o FROM "dbrdf_valvetrain_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.s = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_valvetrain" ex WHERE ex.s = t1.o AND ex.o = t0.o);


        -- <http://dbpedia.org/ontology/valvetrain$delta_new>(?X0,?Y) :- <http://dbpedia.org/ontology/valvetrain$delta_old>(?X0,?X1), owl:sameAs(?X1,?Y) .
        INSERT INTO "dbrdf_valvetrain_delta_new"(s, o) SELECT t0.s, t1.o FROM "dbrdf_valvetrain_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.o = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_valvetrain" ex WHERE ex.s = t0.s AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "dbrdf_valvetrain"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_valvetrain_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_valvetrain_delta_old";
        INSERT INTO "dbrdf_valvetrain_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_valvetrain_delta_new" t0;
        TRUNCATE TABLE "dbrdf_valvetrain_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1058
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_meltingPoint_delta_old1"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_meltingPoint_delta_old1"(s, o) SELECT t0.s, t0.o FROM "dbrdf_meltingPoint1" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_meltingPoint_delta_old1" ON "dbrdf_meltingPoint_delta_old1"(s, o); CREATE INDEX "IDX_1_dbrdf_meltingPoint_delta_old1" ON "dbrdf_meltingPoint_delta_old1"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_meltingPoint_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/ChemicalSubstance/meltingPoint$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/ChemicalSubstance/meltingPoint$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_meltingPoint_delta_new1"(s, o) SELECT t1.o, t0.o FROM "dbrdf_meltingPoint_delta_old1" t0, "dbrdf_sameAs" t1 WHERE t0.s = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_meltingPoint1" ex WHERE ex.s = t1.o AND ex.o = t0.o);


        -- <http://dbpedia.org/ontology/ChemicalSubstance/meltingPoint$delta_new>(?X0,?Y) :- <http://dbpedia.org/ontology/ChemicalSubstance/meltingPoint$delta_old>(?X0,?X1), owl:sameAs(?X1,?Y) .
        INSERT INTO "dbrdf_meltingPoint_delta_new1"(s, o) SELECT t0.s, t1.o FROM "dbrdf_meltingPoint_delta_old1" t0, "dbrdf_sameAs" t1 WHERE t0.o = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_meltingPoint1" ex WHERE ex.s = t0.s AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "dbrdf_meltingPoint1"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_meltingPoint_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_meltingPoint_delta_old1";
        INSERT INTO "dbrdf_meltingPoint_delta_old1"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_meltingPoint_delta_new1" t0;
        TRUNCATE TABLE "dbrdf_meltingPoint_delta_new1";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1059
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_decommissioningDate_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_decommissioningDate_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_decommissioningDate" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_decommissioningDate_delta_old" ON "dbrdf_decommissioningDate_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_decommissioningDate_delta_old" ON "dbrdf_decommissioningDate_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_decommissioningDate_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/decommissioningDate$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/decommissioningDate$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_decommissioningDate_delta_new"(s, o) SELECT t1.o, t0.o FROM "dbrdf_decommissioningDate_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.s = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_decommissioningDate" ex WHERE ex.s = t1.o AND ex.o = t0.o);


        -- <http://dbpedia.org/ontology/decommissioningDate$delta_new>(?X0,?Y) :- <http://dbpedia.org/ontology/decommissioningDate$delta_old>(?X0,?X1), owl:sameAs(?X1,?Y) .
        INSERT INTO "dbrdf_decommissioningDate_delta_new"(s, o) SELECT t0.s, t1.o FROM "dbrdf_decommissioningDate_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.o = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_decommissioningDate" ex WHERE ex.s = t0.s AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "dbrdf_decommissioningDate"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_decommissioningDate_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_decommissioningDate_delta_old";
        INSERT INTO "dbrdf_decommissioningDate_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_decommissioningDate_delta_new" t0;
        TRUNCATE TABLE "dbrdf_decommissioningDate_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1060
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_managementMountain_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_managementMountain_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_managementMountain" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_managementMountain_delta_old" ON "dbrdf_managementMountain_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_managementMountain_delta_old" ON "dbrdf_managementMountain_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_managementMountain_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/managementMountain$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/managementMountain$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_managementMountain_delta_new"(s, o) SELECT t1.o, t0.o FROM "dbrdf_managementMountain_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.s = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_managementMountain" ex WHERE ex.s = t1.o AND ex.o = t0.o);


        -- <http://dbpedia.org/ontology/managementMountain$delta_new>(?X0,?Y) :- <http://dbpedia.org/ontology/managementMountain$delta_old>(?X0,?X1), owl:sameAs(?X1,?Y) .
        INSERT INTO "dbrdf_managementMountain_delta_new"(s, o) SELECT t0.s, t1.o FROM "dbrdf_managementMountain_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.o = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_managementMountain" ex WHERE ex.s = t0.s AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "dbrdf_managementMountain"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_managementMountain_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_managementMountain_delta_old";
        INSERT INTO "dbrdf_managementMountain_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_managementMountain_delta_new" t0;
        TRUNCATE TABLE "dbrdf_managementMountain_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1061
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_RoadTunnel_delta_old"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_RoadTunnel_delta_old"(s) SELECT t0.s FROM "dbrdf_RoadTunnel" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_RoadTunnel_delta_old" ON "dbrdf_RoadTunnel_delta_old"(s);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_RoadTunnel_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/RoadTunnel$delta_new>(?Y) :- <http://dbpedia.org/ontology/RoadTunnel$delta_old>(?X0), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_RoadTunnel_delta_new"(s) SELECT t1.o FROM "dbrdf_RoadTunnel_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.s = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_RoadTunnel" ex WHERE ex.s = t1.o);


        -- Propagate $delta_new

        INSERT INTO "dbrdf_RoadTunnel"(s) SELECT DISTINCT t0.s FROM "dbrdf_RoadTunnel_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_RoadTunnel_delta_old";
        INSERT INTO "dbrdf_RoadTunnel_delta_old"(s) SELECT DISTINCT t0.s FROM "dbrdf_RoadTunnel_delta_new" t0;
        TRUNCATE TABLE "dbrdf_RoadTunnel_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1062
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_fastestDriver_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_fastestDriver_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_fastestDriver" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_fastestDriver_delta_old" ON "dbrdf_fastestDriver_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_fastestDriver_delta_old" ON "dbrdf_fastestDriver_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_fastestDriver_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/fastestDriver$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/fastestDriver$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_fastestDriver_delta_new"(s, o) SELECT t1.o, t0.o FROM "dbrdf_fastestDriver_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.s = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_fastestDriver" ex WHERE ex.s = t1.o AND ex.o = t0.o);


        -- <http://dbpedia.org/ontology/fastestDriver$delta_new>(?X0,?Y) :- <http://dbpedia.org/ontology/fastestDriver$delta_old>(?X0,?X1), owl:sameAs(?X1,?Y) .
        INSERT INTO "dbrdf_fastestDriver_delta_new"(s, o) SELECT t0.s, t1.o FROM "dbrdf_fastestDriver_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.o = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_fastestDriver" ex WHERE ex.s = t0.s AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "dbrdf_fastestDriver"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_fastestDriver_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_fastestDriver_delta_old";
        INSERT INTO "dbrdf_fastestDriver_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_fastestDriver_delta_new" t0;
        TRUNCATE TABLE "dbrdf_fastestDriver_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1063
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_Lighthouse_delta_old"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_Lighthouse_delta_old"(s) SELECT t0.s FROM "dbrdf_Lighthouse" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_Lighthouse_delta_old" ON "dbrdf_Lighthouse_delta_old"(s);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_Lighthouse_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/Lighthouse$delta_new>(?Y) :- <http://dbpedia.org/ontology/Lighthouse$delta_old>(?X0), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_Lighthouse_delta_new"(s) SELECT t1.o FROM "dbrdf_Lighthouse_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.s = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_Lighthouse" ex WHERE ex.s = t1.o);


        -- Propagate $delta_new

        INSERT INTO "dbrdf_Lighthouse"(s) SELECT DISTINCT t0.s FROM "dbrdf_Lighthouse_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_Lighthouse_delta_old";
        INSERT INTO "dbrdf_Lighthouse_delta_old"(s) SELECT DISTINCT t0.s FROM "dbrdf_Lighthouse_delta_new" t0;
        TRUNCATE TABLE "dbrdf_Lighthouse_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1064
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_relative_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_relative_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_relative" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_relative_delta_old" ON "dbrdf_relative_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_relative_delta_old" ON "dbrdf_relative_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_relative_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/relative$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/relative$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_relative_delta_new"(s, o) SELECT t1.o, t0.o FROM "dbrdf_relative_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.s = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_relative" ex WHERE ex.s = t1.o AND ex.o = t0.o);


        -- <http://dbpedia.org/ontology/relative$delta_new>(?X0,?Y) :- <http://dbpedia.org/ontology/relative$delta_old>(?X0,?X1), owl:sameAs(?X1,?Y) .
        INSERT INTO "dbrdf_relative_delta_new"(s, o) SELECT t0.s, t1.o FROM "dbrdf_relative_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.o = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_relative" ex WHERE ex.s = t0.s AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "dbrdf_relative"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_relative_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_relative_delta_old";
        INSERT INTO "dbrdf_relative_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_relative_delta_new" t0;
        TRUNCATE TABLE "dbrdf_relative_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1065
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_aircraftHelicopter_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_aircraftHelicopter_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_aircraftHelicopter" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_aircraftHelicopter_delta_old" ON "dbrdf_aircraftHelicopter_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_aircraftHelicopter_delta_old" ON "dbrdf_aircraftHelicopter_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_aircraftHelicopter_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/aircraftHelicopter$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/aircraftHelicopter$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_aircraftHelicopter_delta_new"(s, o) SELECT t1.o, t0.o FROM "dbrdf_aircraftHelicopter_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.s = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_aircraftHelicopter" ex WHERE ex.s = t1.o AND ex.o = t0.o);


        -- <http://dbpedia.org/ontology/aircraftHelicopter$delta_new>(?X0,?Y) :- <http://dbpedia.org/ontology/aircraftHelicopter$delta_old>(?X0,?X1), owl:sameAs(?X1,?Y) .
        INSERT INTO "dbrdf_aircraftHelicopter_delta_new"(s, o) SELECT t0.s, t1.o FROM "dbrdf_aircraftHelicopter_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.o = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_aircraftHelicopter" ex WHERE ex.s = t0.s AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "dbrdf_aircraftHelicopter"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_aircraftHelicopter_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_aircraftHelicopter_delta_old";
        INSERT INTO "dbrdf_aircraftHelicopter_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_aircraftHelicopter_delta_new" t0;
        TRUNCATE TABLE "dbrdf_aircraftHelicopter_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1066
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_trackLength_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_trackLength_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_trackLength" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_trackLength_delta_old" ON "dbrdf_trackLength_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_trackLength_delta_old" ON "dbrdf_trackLength_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_trackLength_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/trackLength$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/trackLength$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_trackLength_delta_new"(s, o) SELECT t1.o, t0.o FROM "dbrdf_trackLength_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.s = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_trackLength" ex WHERE ex.s = t1.o AND ex.o = t0.o);


        -- <http://dbpedia.org/ontology/trackLength$delta_new>(?X0,?Y) :- <http://dbpedia.org/ontology/trackLength$delta_old>(?X0,?X1), owl:sameAs(?X1,?Y) .
        INSERT INTO "dbrdf_trackLength_delta_new"(s, o) SELECT t0.s, t1.o FROM "dbrdf_trackLength_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.o = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_trackLength" ex WHERE ex.s = t0.s AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "dbrdf_trackLength"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_trackLength_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_trackLength_delta_old";
        INSERT INTO "dbrdf_trackLength_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_trackLength_delta_new" t0;
        TRUNCATE TABLE "dbrdf_trackLength_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1067
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_promotion_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_promotion_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_promotion" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_promotion_delta_old" ON "dbrdf_promotion_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_promotion_delta_old" ON "dbrdf_promotion_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_promotion_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/promotion$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/promotion$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_promotion_delta_new"(s, o) SELECT t1.o, t0.o FROM "dbrdf_promotion_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.s = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_promotion" ex WHERE ex.s = t1.o AND ex.o = t0.o);


        -- <http://dbpedia.org/ontology/promotion$delta_new>(?X0,?Y) :- <http://dbpedia.org/ontology/promotion$delta_old>(?X0,?X1), owl:sameAs(?X1,?Y) .
        INSERT INTO "dbrdf_promotion_delta_new"(s, o) SELECT t0.s, t1.o FROM "dbrdf_promotion_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.o = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_promotion" ex WHERE ex.s = t0.s AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "dbrdf_promotion"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_promotion_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_promotion_delta_old";
        INSERT INTO "dbrdf_promotion_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_promotion_delta_new" t0;
        TRUNCATE TABLE "dbrdf_promotion_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1068
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_band_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_band_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_band" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_band_delta_old" ON "dbrdf_band_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_band_delta_old" ON "dbrdf_band_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_band_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/band$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/band$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_band_delta_new"(s, o) SELECT t1.o, t0.o FROM "dbrdf_band_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.s = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_band" ex WHERE ex.s = t1.o AND ex.o = t0.o);


        -- <http://dbpedia.org/ontology/band$delta_new>(?X0,?Y) :- <http://dbpedia.org/ontology/band$delta_old>(?X0,?X1), owl:sameAs(?X1,?Y) .
        INSERT INTO "dbrdf_band_delta_new"(s, o) SELECT t0.s, t1.o FROM "dbrdf_band_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.o = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_band" ex WHERE ex.s = t0.s AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "dbrdf_band"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_band_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_band_delta_old";
        INSERT INTO "dbrdf_band_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_band_delta_new" t0;
        TRUNCATE TABLE "dbrdf_band_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1069
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_choreographer_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_choreographer_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_choreographer" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_choreographer_delta_old" ON "dbrdf_choreographer_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_choreographer_delta_old" ON "dbrdf_choreographer_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_choreographer_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/choreographer$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/choreographer$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_choreographer_delta_new"(s, o) SELECT t1.o, t0.o FROM "dbrdf_choreographer_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.s = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_choreographer" ex WHERE ex.s = t1.o AND ex.o = t0.o);


        -- <http://dbpedia.org/ontology/choreographer$delta_new>(?X0,?Y) :- <http://dbpedia.org/ontology/choreographer$delta_old>(?X0,?X1), owl:sameAs(?X1,?Y) .
        INSERT INTO "dbrdf_choreographer_delta_new"(s, o) SELECT t0.s, t1.o FROM "dbrdf_choreographer_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.o = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_choreographer" ex WHERE ex.s = t0.s AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "dbrdf_choreographer"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_choreographer_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_choreographer_delta_old";
        INSERT INTO "dbrdf_choreographer_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_choreographer_delta_new" t0;
        TRUNCATE TABLE "dbrdf_choreographer_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1070
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_InlineHockeyLeague_delta_old"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_InlineHockeyLeague_delta_old"(s) SELECT t0.s FROM "dbrdf_InlineHockeyLeague" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_InlineHockeyLeague_delta_old" ON "dbrdf_InlineHockeyLeague_delta_old"(s);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_InlineHockeyLeague_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/InlineHockeyLeague$delta_new>(?Y) :- <http://dbpedia.org/ontology/InlineHockeyLeague$delta_old>(?X0), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_InlineHockeyLeague_delta_new"(s) SELECT t1.o FROM "dbrdf_InlineHockeyLeague_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.s = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_InlineHockeyLeague" ex WHERE ex.s = t1.o);


        -- Propagate $delta_new

        INSERT INTO "dbrdf_InlineHockeyLeague"(s) SELECT DISTINCT t0.s FROM "dbrdf_InlineHockeyLeague_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_InlineHockeyLeague_delta_old";
        INSERT INTO "dbrdf_InlineHockeyLeague_delta_old"(s) SELECT DISTINCT t0.s FROM "dbrdf_InlineHockeyLeague_delta_new" t0;
        TRUNCATE TABLE "dbrdf_InlineHockeyLeague_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1071
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_lunarEvaTime_delta_old0"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_lunarEvaTime_delta_old0"(s, o) SELECT t0.s, t0.o FROM "dbrdf_lunarEvaTime0" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_lunarEvaTime_delta_old0" ON "dbrdf_lunarEvaTime_delta_old0"(s, o); CREATE INDEX "IDX_1_dbrdf_lunarEvaTime_delta_old0" ON "dbrdf_lunarEvaTime_delta_old0"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_lunarEvaTime_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/lunarEvaTime$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/lunarEvaTime$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_lunarEvaTime_delta_new0"(s, o) SELECT t1.o, t0.o FROM "dbrdf_lunarEvaTime_delta_old0" t0, "dbrdf_sameAs" t1 WHERE t0.s = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_lunarEvaTime0" ex WHERE ex.s = t1.o AND ex.o = t0.o);


        -- <http://dbpedia.org/ontology/lunarEvaTime$delta_new>(?X0,?Y) :- <http://dbpedia.org/ontology/lunarEvaTime$delta_old>(?X0,?X1), owl:sameAs(?X1,?Y) .
        INSERT INTO "dbrdf_lunarEvaTime_delta_new0"(s, o) SELECT t0.s, t1.o FROM "dbrdf_lunarEvaTime_delta_old0" t0, "dbrdf_sameAs" t1 WHERE t0.o = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_lunarEvaTime0" ex WHERE ex.s = t0.s AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "dbrdf_lunarEvaTime0"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_lunarEvaTime_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_lunarEvaTime_delta_old0";
        INSERT INTO "dbrdf_lunarEvaTime_delta_old0"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_lunarEvaTime_delta_new0" t0;
        TRUNCATE TABLE "dbrdf_lunarEvaTime_delta_new0";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1072
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_productionStartYear_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_productionStartYear_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_productionStartYear" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_productionStartYear_delta_old" ON "dbrdf_productionStartYear_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_productionStartYear_delta_old" ON "dbrdf_productionStartYear_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_productionStartYear_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/productionStartYear$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/productionStartYear$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_productionStartYear_delta_new"(s, o) SELECT t1.o, t0.o FROM "dbrdf_productionStartYear_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.s = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_productionStartYear" ex WHERE ex.s = t1.o AND ex.o = t0.o);


        -- <http://dbpedia.org/ontology/productionStartYear$delta_new>(?X0,?Y) :- <http://dbpedia.org/ontology/productionStartYear$delta_old>(?X0,?X1), owl:sameAs(?X1,?Y) .
        INSERT INTO "dbrdf_productionStartYear_delta_new"(s, o) SELECT t0.s, t1.o FROM "dbrdf_productionStartYear_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.o = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_productionStartYear" ex WHERE ex.s = t0.s AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "dbrdf_productionStartYear"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_productionStartYear_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_productionStartYear_delta_old";
        INSERT INTO "dbrdf_productionStartYear_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_productionStartYear_delta_new" t0;
        TRUNCATE TABLE "dbrdf_productionStartYear_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1073
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_spokesperson_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_spokesperson_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_spokesperson" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_spokesperson_delta_old" ON "dbrdf_spokesperson_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_spokesperson_delta_old" ON "dbrdf_spokesperson_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_spokesperson_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/spokesperson$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/spokesperson$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_spokesperson_delta_new"(s, o) SELECT t1.o, t0.o FROM "dbrdf_spokesperson_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.s = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_spokesperson" ex WHERE ex.s = t1.o AND ex.o = t0.o);


        -- <http://dbpedia.org/ontology/spokesperson$delta_new>(?X0,?Y) :- <http://dbpedia.org/ontology/spokesperson$delta_old>(?X0,?X1), owl:sameAs(?X1,?Y) .
        INSERT INTO "dbrdf_spokesperson_delta_new"(s, o) SELECT t0.s, t1.o FROM "dbrdf_spokesperson_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.o = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_spokesperson" ex WHERE ex.s = t0.s AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "dbrdf_spokesperson"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_spokesperson_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_spokesperson_delta_old";
        INSERT INTO "dbrdf_spokesperson_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_spokesperson_delta_new" t0;
        TRUNCATE TABLE "dbrdf_spokesperson_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1074
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_governmentRegion_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_governmentRegion_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_governmentRegion" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_governmentRegion_delta_old" ON "dbrdf_governmentRegion_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_governmentRegion_delta_old" ON "dbrdf_governmentRegion_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_governmentRegion_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/governmentRegion$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/governmentRegion$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_governmentRegion_delta_new"(s, o) SELECT t1.o, t0.o FROM "dbrdf_governmentRegion_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.s = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_governmentRegion" ex WHERE ex.s = t1.o AND ex.o = t0.o);


        -- <http://dbpedia.org/ontology/governmentRegion$delta_new>(?X0,?Y) :- <http://dbpedia.org/ontology/governmentRegion$delta_old>(?X0,?X1), owl:sameAs(?X1,?Y) .
        INSERT INTO "dbrdf_governmentRegion_delta_new"(s, o) SELECT t0.s, t1.o FROM "dbrdf_governmentRegion_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.o = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_governmentRegion" ex WHERE ex.s = t0.s AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "dbrdf_governmentRegion"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_governmentRegion_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_governmentRegion_delta_old";
        INSERT INTO "dbrdf_governmentRegion_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_governmentRegion_delta_new" t0;
        TRUNCATE TABLE "dbrdf_governmentRegion_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1075
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_booster_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_booster_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_booster" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_booster_delta_old" ON "dbrdf_booster_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_booster_delta_old" ON "dbrdf_booster_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_booster_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/booster$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/booster$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_booster_delta_new"(s, o) SELECT t1.o, t0.o FROM "dbrdf_booster_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.s = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_booster" ex WHERE ex.s = t1.o AND ex.o = t0.o);


        -- <http://dbpedia.org/ontology/booster$delta_new>(?X0,?Y) :- <http://dbpedia.org/ontology/booster$delta_old>(?X0,?X1), owl:sameAs(?X1,?Y) .
        INSERT INTO "dbrdf_booster_delta_new"(s, o) SELECT t0.s, t1.o FROM "dbrdf_booster_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.o = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_booster" ex WHERE ex.s = t0.s AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "dbrdf_booster"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_booster_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_booster_delta_old";
        INSERT INTO "dbrdf_booster_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_booster_delta_new" t0;
        TRUNCATE TABLE "dbrdf_booster_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1076
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_allegiance_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_allegiance_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_allegiance" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_allegiance_delta_old" ON "dbrdf_allegiance_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_allegiance_delta_old" ON "dbrdf_allegiance_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_allegiance_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/allegiance$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/allegiance$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_allegiance_delta_new"(s, o) SELECT t1.o, t0.o FROM "dbrdf_allegiance_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.s = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_allegiance" ex WHERE ex.s = t1.o AND ex.o = t0.o);


        -- <http://dbpedia.org/ontology/allegiance$delta_new>(?X0,?Y) :- <http://dbpedia.org/ontology/allegiance$delta_old>(?X0,?X1), owl:sameAs(?X1,?Y) .
        INSERT INTO "dbrdf_allegiance_delta_new"(s, o) SELECT t0.s, t1.o FROM "dbrdf_allegiance_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.o = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_allegiance" ex WHERE ex.s = t0.s AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "dbrdf_allegiance"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_allegiance_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_allegiance_delta_old";
        INSERT INTO "dbrdf_allegiance_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_allegiance_delta_new" t0;
        TRUNCATE TABLE "dbrdf_allegiance_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1077
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_isil_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_isil_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_isil" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_isil_delta_old" ON "dbrdf_isil_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_isil_delta_old" ON "dbrdf_isil_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_isil_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/isil$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/isil$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_isil_delta_new"(s, o) SELECT t1.o, t0.o FROM "dbrdf_isil_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.s = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_isil" ex WHERE ex.s = t1.o AND ex.o = t0.o);


        -- <http://dbpedia.org/ontology/isil$delta_new>(?X0,?Y) :- <http://dbpedia.org/ontology/isil$delta_old>(?X0,?X1), owl:sameAs(?X1,?Y) .
        INSERT INTO "dbrdf_isil_delta_new"(s, o) SELECT t0.s, t1.o FROM "dbrdf_isil_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.o = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_isil" ex WHERE ex.s = t0.s AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "dbrdf_isil"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_isil_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_isil_delta_old";
        INSERT INTO "dbrdf_isil_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_isil_delta_new" t0;
        TRUNCATE TABLE "dbrdf_isil_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1078
    ---- DEPENDS ON: 1077, 0
    ----------------------------------------

    -- Nonrecursive rules

    -- [Rule] <http://dbpedia.org/ontology/Library>(?X) :- <http://dbpedia.org/ontology/isil>(?X,?X1) .
    INSERT INTO "dbrdf_Library0"(s) SELECT DISTINCT t0.s FROM "dbrdf_isil" t0 WHERE NOT EXISTS (SELECT 1 FROM "dbrdf_Library0" ex WHERE ex.s = t0.s);
    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_Library_delta_old"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_Library_delta_old"(s) SELECT t0.s FROM "dbrdf_Library" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_Library_delta_old" ON "dbrdf_Library_delta_old"(s);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_Library_delta_new"(s integer) ON COMMIT DROP;
    CREATE LOCAL TEMPORARY TABLE "dbrdf_Library_delta_old0"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_Library_delta_old0"(s) SELECT t0.s FROM "dbrdf_Library0" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_Library_delta_old0" ON "dbrdf_Library_delta_old0"(s);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_Library_delta_new0"(s integer) ON COMMIT DROP;

    -- Iterate recursive rules

    WHILE delta_old_size <> 0 LOOP
        delta_old_size := 0;

        -- Evaluate seminaive rules

        -- <http://schema.org/Library$delta_new>(?X) :- <http://dbpedia.org/ontology/Library$delta_old>(?X) .
        INSERT INTO "dbrdf_Library_delta_new"(s) SELECT t0.s FROM "dbrdf_Library_delta_old0" t0 WHERE NOT EXISTS (SELECT 1 FROM "dbrdf_Library" ex WHERE ex.s = t0.s);


        -- <http://schema.org/Library$delta_new>(?Y) :- <http://schema.org/Library$delta_old>(?X0), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_Library_delta_new"(s) SELECT t1.o FROM "dbrdf_Library_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.s = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_Library" ex WHERE ex.s = t1.o);


        -- <http://dbpedia.org/ontology/Library$delta_new>(?X) :- <http://schema.org/Library$delta_old>(?X) .
        INSERT INTO "dbrdf_Library_delta_new0"(s) SELECT t0.s FROM "dbrdf_Library_delta_old" t0 WHERE NOT EXISTS (SELECT 1 FROM "dbrdf_Library0" ex WHERE ex.s = t0.s);


        -- <http://dbpedia.org/ontology/Library$delta_new>(?Y) :- <http://dbpedia.org/ontology/Library$delta_old>(?X0), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_Library_delta_new0"(s) SELECT t1.o FROM "dbrdf_Library_delta_old0" t0, "dbrdf_sameAs" t1 WHERE t0.s = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_Library0" ex WHERE ex.s = t1.o);


        -- Propagate $delta_new

        INSERT INTO "dbrdf_Library"(s) SELECT DISTINCT t0.s FROM "dbrdf_Library_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_Library_delta_old";
        INSERT INTO "dbrdf_Library_delta_old"(s) SELECT DISTINCT t0.s FROM "dbrdf_Library_delta_new" t0;
        TRUNCATE TABLE "dbrdf_Library_delta_new";

        INSERT INTO "dbrdf_Library0"(s) SELECT DISTINCT t0.s FROM "dbrdf_Library_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_Library_delta_old0";
        INSERT INTO "dbrdf_Library_delta_old0"(s) SELECT DISTINCT t0.s FROM "dbrdf_Library_delta_new0" t0;
        TRUNCATE TABLE "dbrdf_Library_delta_new0";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1079
    ---- 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 "dbrdf_inchi" t0;
    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, "dbrdf_sameAs" t1 WHERE t0.s = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_inchi" ex WHERE ex.s = t1.o 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, "dbrdf_sameAs" t1 WHERE t0.o = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_inchi" ex WHERE ex.s = t0.s AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "dbrdf_inchi"(s, o) SELECT DISTINCT t0.s, 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 1080
    ---- DEPENDS ON: 1079, 414, 149, 0
    ----------------------------------------

    -- Nonrecursive rules

    -- [Rule] <http://dbpedia.org/ontology/ChemicalCompound>(?X) :- <http://dbpedia.org/ontology/inchi>(?X,?X1) .
    INSERT INTO "dbrdf_ChemicalCompound"(s) SELECT DISTINCT t0.s FROM "dbrdf_inchi" t0 WHERE NOT EXISTS (SELECT 1 FROM "dbrdf_ChemicalCompound" ex WHERE ex.s = t0.s);
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    total_tuples := total_tuples + rows_nr;

    -- [Rule] <http://dbpedia.org/ontology/ChemicalCompound>(?X) :- <http://dbpedia.org/ontology/casNumber>(?X,?X1) .
    INSERT INTO "dbrdf_ChemicalCompound"(s) SELECT DISTINCT t0.s FROM "dbrdf_casNumber" t0 WHERE NOT EXISTS (SELECT 1 FROM "dbrdf_ChemicalCompound" ex WHERE ex.s = t0.s);
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    total_tuples := total_tuples + rows_nr;

    -- [Rule] <http://dbpedia.org/ontology/ChemicalCompound>(?X) :- <http://dbpedia.org/ontology/inn>(?X,?X1) .
    INSERT INTO "dbrdf_ChemicalCompound"(s) SELECT DISTINCT t0.s FROM "dbrdf_inn" t0 WHERE NOT EXISTS (SELECT 1 FROM "dbrdf_ChemicalCompound" ex WHERE ex.s = t0.s);
    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_ChemicalCompound_delta_old"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_ChemicalCompound_delta_old"(s) SELECT t0.s FROM "dbrdf_ChemicalCompound" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_ChemicalCompound_delta_old" ON "dbrdf_ChemicalCompound_delta_old"(s);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_ChemicalCompound_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/ChemicalCompound$delta_new>(?Y) :- <http://dbpedia.org/ontology/ChemicalCompound$delta_old>(?X0), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_ChemicalCompound_delta_new"(s) SELECT t1.o FROM "dbrdf_ChemicalCompound_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.s = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_ChemicalCompound" ex WHERE ex.s = t1.o);


        -- Propagate $delta_new

        INSERT INTO "dbrdf_ChemicalCompound"(s) SELECT DISTINCT t0.s FROM "dbrdf_ChemicalCompound_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_ChemicalCompound_delta_old";
        INSERT INTO "dbrdf_ChemicalCompound_delta_old"(s) SELECT DISTINCT t0.s FROM "dbrdf_ChemicalCompound_delta_new" t0;
        TRUNCATE TABLE "dbrdf_ChemicalCompound_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1081
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_architectualBureau_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_architectualBureau_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_architectualBureau" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_architectualBureau_delta_old" ON "dbrdf_architectualBureau_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_architectualBureau_delta_old" ON "dbrdf_architectualBureau_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_architectualBureau_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/architectualBureau$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/architectualBureau$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_architectualBureau_delta_new"(s, o) SELECT t1.o, t0.o FROM "dbrdf_architectualBureau_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.s = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_architectualBureau" ex WHERE ex.s = t1.o AND ex.o = t0.o);


        -- <http://dbpedia.org/ontology/architectualBureau$delta_new>(?X0,?Y) :- <http://dbpedia.org/ontology/architectualBureau$delta_old>(?X0,?X1), owl:sameAs(?X1,?Y) .
        INSERT INTO "dbrdf_architectualBureau_delta_new"(s, o) SELECT t0.s, t1.o FROM "dbrdf_architectualBureau_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.o = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_architectualBureau" ex WHERE ex.s = t0.s AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "dbrdf_architectualBureau"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_architectualBureau_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_architectualBureau_delta_old";
        INSERT INTO "dbrdf_architectualBureau_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_architectualBureau_delta_new" t0;
        TRUNCATE TABLE "dbrdf_architectualBureau_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1082
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_innervates_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_innervates_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_innervates" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_innervates_delta_old" ON "dbrdf_innervates_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_innervates_delta_old" ON "dbrdf_innervates_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_innervates_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/innervates$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/innervates$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_innervates_delta_new"(s, o) SELECT t1.o, t0.o FROM "dbrdf_innervates_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.s = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_innervates" ex WHERE ex.s = t1.o AND ex.o = t0.o);


        -- <http://dbpedia.org/ontology/innervates$delta_new>(?X0,?Y) :- <http://dbpedia.org/ontology/innervates$delta_old>(?X0,?X1), owl:sameAs(?X1,?Y) .
        INSERT INTO "dbrdf_innervates_delta_new"(s, o) SELECT t0.s, t1.o FROM "dbrdf_innervates_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.o = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_innervates" ex WHERE ex.s = t0.s AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "dbrdf_innervates"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_innervates_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_innervates_delta_old";
        INSERT INTO "dbrdf_innervates_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_innervates_delta_new" t0;
        TRUNCATE TABLE "dbrdf_innervates_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1083
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_numberOfUndergraduateStudents_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_numberOfUndergraduateStudents_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_numberOfUndergraduateStudents" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_numberOfUndergraduateStudents_delta_old" ON "dbrdf_numberOfUndergraduateStudents_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_numberOfUndergraduateStudents_delta_old" ON "dbrdf_numberOfUndergraduateStudents_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_numberOfUndergraduateStudents_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/numberOfUndergraduateStudents$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/numberOfUndergraduateStudents$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_numberOfUndergraduateStudents_delta_new"(s, o) SELECT t1.o, t0.o FROM "dbrdf_numberOfUndergraduateStudents_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.s = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_numberOfUndergraduateStudents" ex WHERE ex.s = t1.o AND ex.o = t0.o);


        -- <http://dbpedia.org/ontology/numberOfUndergraduateStudents$delta_new>(?X0,?Y) :- <http://dbpedia.org/ontology/numberOfUndergraduateStudents$delta_old>(?X0,?X1), owl:sameAs(?X1,?Y) .
        INSERT INTO "dbrdf_numberOfUndergraduateStudents_delta_new"(s, o) SELECT t0.s, t1.o FROM "dbrdf_numberOfUndergraduateStudents_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.o = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_numberOfUndergraduateStudents" ex WHERE ex.s = t0.s AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "dbrdf_numberOfUndergraduateStudents"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_numberOfUndergraduateStudents_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_numberOfUndergraduateStudents_delta_old";
        INSERT INTO "dbrdf_numberOfUndergraduateStudents_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_numberOfUndergraduateStudents_delta_new" t0;
        TRUNCATE TABLE "dbrdf_numberOfUndergraduateStudents_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1084
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_budget_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_budget_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_budget" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_budget_delta_old" ON "dbrdf_budget_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_budget_delta_old" ON "dbrdf_budget_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_budget_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/budget$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/budget$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_budget_delta_new"(s, o) SELECT t1.o, t0.o FROM "dbrdf_budget_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.s = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_budget" ex WHERE ex.s = t1.o AND ex.o = t0.o);


        -- <http://dbpedia.org/ontology/budget$delta_new>(?X0,?Y) :- <http://dbpedia.org/ontology/budget$delta_old>(?X0,?X1), owl:sameAs(?X1,?Y) .
        INSERT INTO "dbrdf_budget_delta_new"(s, o) SELECT t0.s, t1.o FROM "dbrdf_budget_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.o = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_budget" ex WHERE ex.s = t0.s AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "dbrdf_budget"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_budget_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_budget_delta_old";
        INSERT INTO "dbrdf_budget_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_budget_delta_new" t0;
        TRUNCATE TABLE "dbrdf_budget_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1085
    ---- DEPENDS ON: 342, 0
    ----------------------------------------

    -- Nonrecursive rules

    -- [Rule] <http://dbpedia.org/ontology/ProtectedArea>(?X) :- <http://dbpedia.org/ontology/iucnCategory>(?X,?X1) .
    INSERT INTO "dbrdf_ProtectedArea"(s) SELECT DISTINCT t0.s FROM "dbrdf_iucnCategory" t0 WHERE NOT EXISTS (SELECT 1 FROM "dbrdf_ProtectedArea" ex WHERE ex.s = t0.s);
    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_ProtectedArea_delta_old"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_ProtectedArea_delta_old"(s) SELECT t0.s FROM "dbrdf_ProtectedArea" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_ProtectedArea_delta_old" ON "dbrdf_ProtectedArea_delta_old"(s);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_ProtectedArea_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/ProtectedArea$delta_new>(?Y) :- <http://dbpedia.org/ontology/ProtectedArea$delta_old>(?X0), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_ProtectedArea_delta_new"(s) SELECT t1.o FROM "dbrdf_ProtectedArea_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.s = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_ProtectedArea" ex WHERE ex.s = t1.o);


        -- Propagate $delta_new

        INSERT INTO "dbrdf_ProtectedArea"(s) SELECT DISTINCT t0.s FROM "dbrdf_ProtectedArea_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_ProtectedArea_delta_old";
        INSERT INTO "dbrdf_ProtectedArea_delta_old"(s) SELECT DISTINCT t0.s FROM "dbrdf_ProtectedArea_delta_new" t0;
        TRUNCATE TABLE "dbrdf_ProtectedArea_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1086
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_floodingDate_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_floodingDate_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_floodingDate" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_floodingDate_delta_old" ON "dbrdf_floodingDate_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_floodingDate_delta_old" ON "dbrdf_floodingDate_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_floodingDate_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/floodingDate$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/floodingDate$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_floodingDate_delta_new"(s, o) SELECT t1.o, t0.o FROM "dbrdf_floodingDate_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.s = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_floodingDate" ex WHERE ex.s = t1.o AND ex.o = t0.o);


        -- <http://dbpedia.org/ontology/floodingDate$delta_new>(?X0,?Y) :- <http://dbpedia.org/ontology/floodingDate$delta_old>(?X0,?X1), owl:sameAs(?X1,?Y) .
        INSERT INTO "dbrdf_floodingDate_delta_new"(s, o) SELECT t0.s, t1.o FROM "dbrdf_floodingDate_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.o = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_floodingDate" ex WHERE ex.s = t0.s AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "dbrdf_floodingDate"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_floodingDate_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_floodingDate_delta_old";
        INSERT INTO "dbrdf_floodingDate_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_floodingDate_delta_new" t0;
        TRUNCATE TABLE "dbrdf_floodingDate_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1087
    ---- 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 "dbrdf_dorlandsPrefix" t0;
    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, "dbrdf_sameAs" t1 WHERE t0.s = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_dorlandsPrefix" ex WHERE ex.s = t1.o 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, "dbrdf_sameAs" t1 WHERE t0.o = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_dorlandsPrefix" ex WHERE ex.s = t0.s AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "dbrdf_dorlandsPrefix"(s, o) SELECT DISTINCT t0.s, 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 1088
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_projectKeyword_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_projectKeyword_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_projectKeyword" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_projectKeyword_delta_old" ON "dbrdf_projectKeyword_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_projectKeyword_delta_old" ON "dbrdf_projectKeyword_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_projectKeyword_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/projectKeyword$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/projectKeyword$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_projectKeyword_delta_new"(s, o) SELECT t1.o, t0.o FROM "dbrdf_projectKeyword_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.s = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_projectKeyword" ex WHERE ex.s = t1.o AND ex.o = t0.o);


        -- <http://dbpedia.org/ontology/projectKeyword$delta_new>(?X0,?Y) :- <http://dbpedia.org/ontology/projectKeyword$delta_old>(?X0,?X1), owl:sameAs(?X1,?Y) .
        INSERT INTO "dbrdf_projectKeyword_delta_new"(s, o) SELECT t0.s, t1.o FROM "dbrdf_projectKeyword_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.o = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_projectKeyword" ex WHERE ex.s = t0.s AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "dbrdf_projectKeyword"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_projectKeyword_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_projectKeyword_delta_old";
        INSERT INTO "dbrdf_projectKeyword_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_projectKeyword_delta_new" t0;
        TRUNCATE TABLE "dbrdf_projectKeyword_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1089
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_aircraftTransport_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_aircraftTransport_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_aircraftTransport" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_aircraftTransport_delta_old" ON "dbrdf_aircraftTransport_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_aircraftTransport_delta_old" ON "dbrdf_aircraftTransport_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_aircraftTransport_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/aircraftTransport$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/aircraftTransport$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_aircraftTransport_delta_new"(s, o) SELECT t1.o, t0.o FROM "dbrdf_aircraftTransport_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.s = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_aircraftTransport" ex WHERE ex.s = t1.o AND ex.o = t0.o);


        -- <http://dbpedia.org/ontology/aircraftTransport$delta_new>(?X0,?Y) :- <http://dbpedia.org/ontology/aircraftTransport$delta_old>(?X0,?X1), owl:sameAs(?X1,?Y) .
        INSERT INTO "dbrdf_aircraftTransport_delta_new"(s, o) SELECT t0.s, t1.o FROM "dbrdf_aircraftTransport_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.o = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_aircraftTransport" ex WHERE ex.s = t0.s AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "dbrdf_aircraftTransport"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_aircraftTransport_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_aircraftTransport_delta_old";
        INSERT INTO "dbrdf_aircraftTransport_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_aircraftTransport_delta_new" t0;
        TRUNCATE TABLE "dbrdf_aircraftTransport_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1090
    ---- 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 "dbrdf_vicePresident" t0;
    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, "dbrdf_sameAs" t1 WHERE t0.s = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_vicePresident" ex WHERE ex.s = t1.o 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, "dbrdf_sameAs" t1 WHERE t0.o = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_vicePresident" ex WHERE ex.s = t0.s AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "dbrdf_vicePresident"(s, o) SELECT DISTINCT t0.s, 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 1091
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_sheading_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_sheading_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_sheading" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_sheading_delta_old" ON "dbrdf_sheading_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_sheading_delta_old" ON "dbrdf_sheading_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_sheading_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/sheading$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/sheading$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_sheading_delta_new"(s, o) SELECT t1.o, t0.o FROM "dbrdf_sheading_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.s = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_sheading" ex WHERE ex.s = t1.o AND ex.o = t0.o);


        -- <http://dbpedia.org/ontology/sheading$delta_new>(?X0,?Y) :- <http://dbpedia.org/ontology/sheading$delta_old>(?X0,?X1), owl:sameAs(?X1,?Y) .
        INSERT INTO "dbrdf_sheading_delta_new"(s, o) SELECT t0.s, t1.o FROM "dbrdf_sheading_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.o = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_sheading" ex WHERE ex.s = t0.s AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "dbrdf_sheading"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_sheading_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_sheading_delta_old";
        INSERT INTO "dbrdf_sheading_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_sheading_delta_new" t0;
        TRUNCATE TABLE "dbrdf_sheading_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1092
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_mouthMountain_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_mouthMountain_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_mouthMountain" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_mouthMountain_delta_old" ON "dbrdf_mouthMountain_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_mouthMountain_delta_old" ON "dbrdf_mouthMountain_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_mouthMountain_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/mouthMountain$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/mouthMountain$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_mouthMountain_delta_new"(s, o) SELECT t1.o, t0.o FROM "dbrdf_mouthMountain_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.s = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_mouthMountain" ex WHERE ex.s = t1.o AND ex.o = t0.o);


        -- <http://dbpedia.org/ontology/mouthMountain$delta_new>(?X0,?Y) :- <http://dbpedia.org/ontology/mouthMountain$delta_old>(?X0,?X1), owl:sameAs(?X1,?Y) .
        INSERT INTO "dbrdf_mouthMountain_delta_new"(s, o) SELECT t0.s, t1.o FROM "dbrdf_mouthMountain_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.o = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_mouthMountain" ex WHERE ex.s = t0.s AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "dbrdf_mouthMountain"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_mouthMountain_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_mouthMountain_delta_old";
        INSERT INTO "dbrdf_mouthMountain_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_mouthMountain_delta_new" t0;
        TRUNCATE TABLE "dbrdf_mouthMountain_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1093
    ---- 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 "dbrdf_WomensTennisAssociationTournament" t0;
    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, "dbrdf_sameAs" t1 WHERE t0.s = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_WomensTennisAssociationTournament" ex WHERE ex.s = t1.o);


        -- Propagate $delta_new

        INSERT INTO "dbrdf_WomensTennisAssociationTournament"(s) SELECT DISTINCT t0.s 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 1094
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_digitalChannel_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_digitalChannel_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_digitalChannel" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_digitalChannel_delta_old" ON "dbrdf_digitalChannel_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_digitalChannel_delta_old" ON "dbrdf_digitalChannel_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_digitalChannel_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/digitalChannel$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/digitalChannel$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_digitalChannel_delta_new"(s, o) SELECT t1.o, t0.o FROM "dbrdf_digitalChannel_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.s = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_digitalChannel" ex WHERE ex.s = t1.o AND ex.o = t0.o);


        -- <http://dbpedia.org/ontology/digitalChannel$delta_new>(?X0,?Y) :- <http://dbpedia.org/ontology/digitalChannel$delta_old>(?X0,?X1), owl:sameAs(?X1,?Y) .
        INSERT INTO "dbrdf_digitalChannel_delta_new"(s, o) SELECT t0.s, t1.o FROM "dbrdf_digitalChannel_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.o = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_digitalChannel" ex WHERE ex.s = t0.s AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "dbrdf_digitalChannel"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_digitalChannel_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_digitalChannel_delta_old";
        INSERT INTO "dbrdf_digitalChannel_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_digitalChannel_delta_new" t0;
        TRUNCATE TABLE "dbrdf_digitalChannel_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1095
    ---- 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 "dbrdf_meshId" t0;
    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, "dbrdf_sameAs" t1 WHERE t0.s = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_meshId" ex WHERE ex.s = t1.o 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, "dbrdf_sameAs" t1 WHERE t0.o = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_meshId" ex WHERE ex.s = t0.s AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "dbrdf_meshId"(s, o) SELECT DISTINCT t0.s, 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 1096
    ---- 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 "dbrdf_muteCharacterInPlay" t0;
    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, "dbrdf_sameAs" t1 WHERE t0.s = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_muteCharacterInPlay" ex WHERE ex.s = t1.o 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, "dbrdf_sameAs" t1 WHERE t0.o = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_muteCharacterInPlay" ex WHERE ex.s = t0.s AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "dbrdf_muteCharacterInPlay"(s, o) SELECT DISTINCT t0.s, 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 1097
    ---- 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 "dbrdf_populationTotalReference" t0;
    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, "dbrdf_sameAs" t1 WHERE t0.s = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_populationTotalReference" ex WHERE ex.s = t1.o 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, "dbrdf_sameAs" t1 WHERE t0.o = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_populationTotalReference" ex WHERE ex.s = t0.s AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "dbrdf_populationTotalReference"(s, o) SELECT DISTINCT t0.s, 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 1098
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_aircraftElectronic_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_aircraftElectronic_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_aircraftElectronic" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_aircraftElectronic_delta_old" ON "dbrdf_aircraftElectronic_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_aircraftElectronic_delta_old" ON "dbrdf_aircraftElectronic_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_aircraftElectronic_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/aircraftElectronic$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/aircraftElectronic$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_aircraftElectronic_delta_new"(s, o) SELECT t1.o, t0.o FROM "dbrdf_aircraftElectronic_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.s = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_aircraftElectronic" ex WHERE ex.s = t1.o AND ex.o = t0.o);


        -- <http://dbpedia.org/ontology/aircraftElectronic$delta_new>(?X0,?Y) :- <http://dbpedia.org/ontology/aircraftElectronic$delta_old>(?X0,?X1), owl:sameAs(?X1,?Y) .
        INSERT INTO "dbrdf_aircraftElectronic_delta_new"(s, o) SELECT t0.s, t1.o FROM "dbrdf_aircraftElectronic_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.o = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_aircraftElectronic" ex WHERE ex.s = t0.s AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "dbrdf_aircraftElectronic"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_aircraftElectronic_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_aircraftElectronic_delta_old";
        INSERT INTO "dbrdf_aircraftElectronic_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_aircraftElectronic_delta_new" t0;
        TRUNCATE TABLE "dbrdf_aircraftElectronic_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1099
    ---- 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 "dbrdf_voice" t0;
    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, "dbrdf_sameAs" t1 WHERE t0.s = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_voice" ex WHERE ex.s = t1.o 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, "dbrdf_sameAs" t1 WHERE t0.o = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_voice" ex WHERE ex.s = t0.s AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "dbrdf_voice"(s, o) SELECT DISTINCT t0.s, 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 1100
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_plays_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_plays_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_plays" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_plays_delta_old" ON "dbrdf_plays_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_plays_delta_old" ON "dbrdf_plays_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_plays_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/plays$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/plays$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_plays_delta_new"(s, o) SELECT t1.o, t0.o FROM "dbrdf_plays_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.s = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_plays" ex WHERE ex.s = t1.o AND ex.o = t0.o);


        -- <http://dbpedia.org/ontology/plays$delta_new>(?X0,?Y) :- <http://dbpedia.org/ontology/plays$delta_old>(?X0,?X1), owl:sameAs(?X1,?Y) .
        INSERT INTO "dbrdf_plays_delta_new"(s, o) SELECT t0.s, t1.o FROM "dbrdf_plays_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.o = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_plays" ex WHERE ex.s = t0.s AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "dbrdf_plays"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_plays_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_plays_delta_old";
        INSERT INTO "dbrdf_plays_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_plays_delta_new" t0;
        TRUNCATE TABLE "dbrdf_plays_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1101
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_functionEndDate_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_functionEndDate_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_functionEndDate" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_functionEndDate_delta_old" ON "dbrdf_functionEndDate_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_functionEndDate_delta_old" ON "dbrdf_functionEndDate_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_functionEndDate_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/functionEndDate$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/functionEndDate$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_functionEndDate_delta_new"(s, o) SELECT t1.o, t0.o FROM "dbrdf_functionEndDate_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.s = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_functionEndDate" ex WHERE ex.s = t1.o AND ex.o = t0.o);


        -- <http://dbpedia.org/ontology/functionEndDate$delta_new>(?X0,?Y) :- <http://dbpedia.org/ontology/functionEndDate$delta_old>(?X0,?X1), owl:sameAs(?X1,?Y) .
        INSERT INTO "dbrdf_functionEndDate_delta_new"(s, o) SELECT t0.s, t1.o FROM "dbrdf_functionEndDate_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.o = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_functionEndDate" ex WHERE ex.s = t0.s AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "dbrdf_functionEndDate"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_functionEndDate_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_functionEndDate_delta_old";
        INSERT INTO "dbrdf_functionEndDate_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_functionEndDate_delta_new" t0;
        TRUNCATE TABLE "dbrdf_functionEndDate_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1102
    ---- 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 "dbrdf_heightAboveAverageTerrain" t0;
    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, "dbrdf_sameAs" t1 WHERE t0.s = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_heightAboveAverageTerrain" ex WHERE ex.s = t1.o 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, "dbrdf_sameAs" t1 WHERE t0.o = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_heightAboveAverageTerrain" ex WHERE ex.s = t0.s AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "dbrdf_heightAboveAverageTerrain"(s, o) SELECT DISTINCT t0.s, 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 1103
    ---- 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 "dbrdf_sourceConfluenceElevation" t0;
    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, "dbrdf_sameAs" t1 WHERE t0.s = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_sourceConfluenceElevation" ex WHERE ex.s = t1.o 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, "dbrdf_sameAs" t1 WHERE t0.o = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_sourceConfluenceElevation" ex WHERE ex.s = t0.s AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "dbrdf_sourceConfluenceElevation"(s, o) SELECT DISTINCT t0.s, 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 1104
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_lieutenancyArea_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_lieutenancyArea_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_lieutenancyArea" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_lieutenancyArea_delta_old" ON "dbrdf_lieutenancyArea_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_lieutenancyArea_delta_old" ON "dbrdf_lieutenancyArea_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_lieutenancyArea_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/lieutenancyArea$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/lieutenancyArea$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_lieutenancyArea_delta_new"(s, o) SELECT t1.o, t0.o FROM "dbrdf_lieutenancyArea_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.s = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_lieutenancyArea" ex WHERE ex.s = t1.o AND ex.o = t0.o);


        -- <http://dbpedia.org/ontology/lieutenancyArea$delta_new>(?X0,?Y) :- <http://dbpedia.org/ontology/lieutenancyArea$delta_old>(?X0,?X1), owl:sameAs(?X1,?Y) .
        INSERT INTO "dbrdf_lieutenancyArea_delta_new"(s, o) SELECT t0.s, t1.o FROM "dbrdf_lieutenancyArea_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.o = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_lieutenancyArea" ex WHERE ex.s = t0.s AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "dbrdf_lieutenancyArea"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_lieutenancyArea_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_lieutenancyArea_delta_old";
        INSERT INTO "dbrdf_lieutenancyArea_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_lieutenancyArea_delta_new" t0;
        TRUNCATE TABLE "dbrdf_lieutenancyArea_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1105
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_totalPopulation_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_totalPopulation_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_totalPopulation" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_totalPopulation_delta_old" ON "dbrdf_totalPopulation_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_totalPopulation_delta_old" ON "dbrdf_totalPopulation_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_totalPopulation_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/totalPopulation$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/totalPopulation$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_totalPopulation_delta_new"(s, o) SELECT t1.o, t0.o FROM "dbrdf_totalPopulation_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.s = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_totalPopulation" ex WHERE ex.s = t1.o AND ex.o = t0.o);


        -- <http://dbpedia.org/ontology/totalPopulation$delta_new>(?X0,?Y) :- <http://dbpedia.org/ontology/totalPopulation$delta_old>(?X0,?X1), owl:sameAs(?X1,?Y) .
        INSERT INTO "dbrdf_totalPopulation_delta_new"(s, o) SELECT t0.s, t1.o FROM "dbrdf_totalPopulation_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.o = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_totalPopulation" ex WHERE ex.s = t0.s AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "dbrdf_totalPopulation"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_totalPopulation_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_totalPopulation_delta_old";
        INSERT INTO "dbrdf_totalPopulation_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_totalPopulation_delta_new" t0;
        TRUNCATE TABLE "dbrdf_totalPopulation_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1106
    ---- 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 "dbrdf_cylinderBore0" t0;
    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, "dbrdf_sameAs" t1 WHERE t0.s = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_cylinderBore0" ex WHERE ex.s = t1.o 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, "dbrdf_sameAs" t1 WHERE t0.o = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_cylinderBore0" ex WHERE ex.s = t0.s AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "dbrdf_cylinderBore0"(s, o) SELECT DISTINCT t0.s, 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 1107
    ---- 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 "dbrdf_Mayor" t0;
    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, "dbrdf_sameAs" t1 WHERE t0.s = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_Mayor" ex WHERE ex.s = t1.o);


        -- Propagate $delta_new

        INSERT INTO "dbrdf_Mayor"(s) SELECT DISTINCT t0.s 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 1108
    ---- 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 "dbrdf_currentStatus" t0;
    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, "dbrdf_sameAs" t1 WHERE t0.s = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_currentStatus" ex WHERE ex.s = t1.o 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, "dbrdf_sameAs" t1 WHERE t0.o = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_currentStatus" ex WHERE ex.s = t0.s AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "dbrdf_currentStatus"(s, o) SELECT DISTINCT t0.s, 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 1109
    ---- 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 "dbrdf_broadcastRepeater" t0;
    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, "dbrdf_sameAs" t1 WHERE t0.s = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_broadcastRepeater" ex WHERE ex.s = t1.o 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, "dbrdf_sameAs" t1 WHERE t0.o = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_broadcastRepeater" ex WHERE ex.s = t0.s AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "dbrdf_broadcastRepeater"(s, o) SELECT DISTINCT t0.s, 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 1110
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_popularVote_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_popularVote_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_popularVote" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_popularVote_delta_old" ON "dbrdf_popularVote_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_popularVote_delta_old" ON "dbrdf_popularVote_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_popularVote_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/popularVote$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/popularVote$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_popularVote_delta_new"(s, o) SELECT t1.o, t0.o FROM "dbrdf_popularVote_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.s = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_popularVote" ex WHERE ex.s = t1.o AND ex.o = t0.o);


        -- <http://dbpedia.org/ontology/popularVote$delta_new>(?X0,?Y) :- <http://dbpedia.org/ontology/popularVote$delta_old>(?X0,?X1), owl:sameAs(?X1,?Y) .
        INSERT INTO "dbrdf_popularVote_delta_new"(s, o) SELECT t0.s, t1.o FROM "dbrdf_popularVote_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.o = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_popularVote" ex WHERE ex.s = t0.s AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "dbrdf_popularVote"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_popularVote_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_popularVote_delta_old";
        INSERT INTO "dbrdf_popularVote_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_popularVote_delta_new" t0;
        TRUNCATE TABLE "dbrdf_popularVote_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1111
    ---- DEPENDS ON: 1110, 0
    ----------------------------------------

    -- Nonrecursive rules

    -- [Rule] <http://dbpedia.org/ontology/Election>(?X) :- <http://dbpedia.org/ontology/popularVote>(?X,?X1) .
    INSERT INTO "dbrdf_Election"(s) SELECT DISTINCT t0.s FROM "dbrdf_popularVote" t0 WHERE NOT EXISTS (SELECT 1 FROM "dbrdf_Election" ex WHERE ex.s = t0.s);
    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_Election_delta_old"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_Election_delta_old"(s) SELECT t0.s FROM "dbrdf_Election" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_Election_delta_old" ON "dbrdf_Election_delta_old"(s);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_Election_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/Election$delta_new>(?Y) :- <http://dbpedia.org/ontology/Election$delta_old>(?X0), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_Election_delta_new"(s) SELECT t1.o FROM "dbrdf_Election_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.s = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_Election" ex WHERE ex.s = t1.o);


        -- Propagate $delta_new

        INSERT INTO "dbrdf_Election"(s) SELECT DISTINCT t0.s FROM "dbrdf_Election_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_Election_delta_old";
        INSERT INTO "dbrdf_Election_delta_old"(s) SELECT DISTINCT t0.s FROM "dbrdf_Election_delta_new" t0;
        TRUNCATE TABLE "dbrdf_Election_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1112
    ---- 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 "dbrdf_runtime" t0;
    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, "dbrdf_sameAs" t1 WHERE t0.s = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_runtime" ex WHERE ex.s = t1.o 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, "dbrdf_sameAs" t1 WHERE t0.o = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_runtime" ex WHERE ex.s = t0.s AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "dbrdf_runtime"(s, o) SELECT DISTINCT t0.s, 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 1113
    ---- 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 "dbrdf_olympicOathSwornByJudge" t0;
    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, "dbrdf_sameAs" t1 WHERE t0.s = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_olympicOathSwornByJudge" ex WHERE ex.s = t1.o 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, "dbrdf_sameAs" t1 WHERE t0.o = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_olympicOathSwornByJudge" ex WHERE ex.s = t0.s AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "dbrdf_olympicOathSwornByJudge"(s, o) SELECT DISTINCT t0.s, 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 1114
    ---- 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 "dbrdf_podiums" t0;
    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, "dbrdf_sameAs" t1 WHERE t0.s = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_podiums" ex WHERE ex.s = t1.o 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, "dbrdf_sameAs" t1 WHERE t0.o = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_podiums" ex WHERE ex.s = t0.s AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "dbrdf_podiums"(s, o) SELECT DISTINCT t0.s, 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 1115
    ---- 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 "dbrdf_stylisticOrigin" t0;
    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, "dbrdf_sameAs" t1 WHERE t0.s = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_stylisticOrigin" ex WHERE ex.s = t1.o 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, "dbrdf_sameAs" t1 WHERE t0.o = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_stylisticOrigin" ex WHERE ex.s = t0.s AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "dbrdf_stylisticOrigin"(s, o) SELECT DISTINCT t0.s, 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 1116
    ---- DEPENDS ON: 1115, 863, 773, 459, 0
    ----------------------------------------

    -- Nonrecursive rules

    -- [Rule] <http://dbpedia.org/ontology/MusicGenre>(?X1) :- <http://dbpedia.org/ontology/stylisticOrigin>(?X,?X1) .
    INSERT INTO "dbrdf_MusicGenre"(s) SELECT DISTINCT t0.o FROM "dbrdf_stylisticOrigin" t0 WHERE NOT EXISTS (SELECT 1 FROM "dbrdf_MusicGenre" ex WHERE ex.s = t0.o);
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    total_tuples := total_tuples + rows_nr;

    -- [Rule] <http://dbpedia.org/ontology/MusicGenre>(?X) :- <http://dbpedia.org/ontology/stylisticOrigin>(?X,?X1) .
    INSERT INTO "dbrdf_MusicGenre"(s) SELECT DISTINCT t0.s FROM "dbrdf_stylisticOrigin" t0 WHERE NOT EXISTS (SELECT 1 FROM "dbrdf_MusicGenre" ex WHERE ex.s = t0.s);
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    total_tuples := total_tuples + rows_nr;

    -- [Rule] <http://dbpedia.org/ontology/MusicGenre>(?X1) :- <http://dbpedia.org/ontology/derivative>(?X,?X1) .
    INSERT INTO "dbrdf_MusicGenre"(s) SELECT DISTINCT t0.o FROM "dbrdf_derivative" t0 WHERE NOT EXISTS (SELECT 1 FROM "dbrdf_MusicGenre" ex WHERE ex.s = t0.o);
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    total_tuples := total_tuples + rows_nr;

    -- [Rule] <http://dbpedia.org/ontology/MusicGenre>(?X1) :- <http://dbpedia.org/ontology/musicSubgenre>(?X,?X1) .
    INSERT INTO "dbrdf_MusicGenre"(s) SELECT DISTINCT t0.o FROM "dbrdf_musicSubgenre" t0 WHERE NOT EXISTS (SELECT 1 FROM "dbrdf_MusicGenre" ex WHERE ex.s = t0.o);
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    total_tuples := total_tuples + rows_nr;

    -- [Rule] <http://dbpedia.org/ontology/MusicGenre>(?X1) :- <http://dbpedia.org/ontology/musicFusionGenre>(?X,?X1) .
    INSERT INTO "dbrdf_MusicGenre"(s) SELECT DISTINCT t0.o FROM "dbrdf_musicFusionGenre" t0 WHERE NOT EXISTS (SELECT 1 FROM "dbrdf_MusicGenre" ex WHERE ex.s = t0.o);
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    total_tuples := total_tuples + rows_nr;

    -- [Rule] <http://dbpedia.org/ontology/MusicGenre>(?X) :- <http://dbpedia.org/ontology/derivative>(?X,?X1) .
    INSERT INTO "dbrdf_MusicGenre"(s) SELECT DISTINCT t0.s FROM "dbrdf_derivative" t0 WHERE NOT EXISTS (SELECT 1 FROM "dbrdf_MusicGenre" ex WHERE ex.s = t0.s);
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    total_tuples := total_tuples + rows_nr;

    -- [Rule] <http://dbpedia.org/ontology/MusicGenre>(?X) :- <http://dbpedia.org/ontology/musicFusionGenre>(?X,?X1) .
    INSERT INTO "dbrdf_MusicGenre"(s) SELECT DISTINCT t0.s FROM "dbrdf_musicFusionGenre" t0 WHERE NOT EXISTS (SELECT 1 FROM "dbrdf_MusicGenre" ex WHERE ex.s = t0.s);
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    total_tuples := total_tuples + rows_nr;

    -- [Rule] <http://dbpedia.org/ontology/MusicGenre>(?X) :- <http://dbpedia.org/ontology/musicSubgenre>(?X,?X1) .
    INSERT INTO "dbrdf_MusicGenre"(s) SELECT DISTINCT t0.s FROM "dbrdf_musicSubgenre" t0 WHERE NOT EXISTS (SELECT 1 FROM "dbrdf_MusicGenre" ex WHERE ex.s = t0.s);
    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_MusicGenre_delta_old"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_MusicGenre_delta_old"(s) SELECT t0.s FROM "dbrdf_MusicGenre" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_MusicGenre_delta_old" ON "dbrdf_MusicGenre_delta_old"(s);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_MusicGenre_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/MusicGenre$delta_new>(?Y) :- <http://dbpedia.org/ontology/MusicGenre$delta_old>(?X0), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_MusicGenre_delta_new"(s) SELECT t1.o FROM "dbrdf_MusicGenre_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.s = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_MusicGenre" ex WHERE ex.s = t1.o);


        -- Propagate $delta_new

        INSERT INTO "dbrdf_MusicGenre"(s) SELECT DISTINCT t0.s FROM "dbrdf_MusicGenre_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_MusicGenre_delta_old";
        INSERT INTO "dbrdf_MusicGenre_delta_old"(s) SELECT DISTINCT t0.s FROM "dbrdf_MusicGenre_delta_new" t0;
        TRUNCATE TABLE "dbrdf_MusicGenre_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1117
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_billed_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_billed_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_billed" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_billed_delta_old" ON "dbrdf_billed_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_billed_delta_old" ON "dbrdf_billed_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_billed_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/billed$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/billed$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_billed_delta_new"(s, o) SELECT t1.o, t0.o FROM "dbrdf_billed_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.s = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_billed" ex WHERE ex.s = t1.o AND ex.o = t0.o);


        -- <http://dbpedia.org/ontology/billed$delta_new>(?X0,?Y) :- <http://dbpedia.org/ontology/billed$delta_old>(?X0,?X1), owl:sameAs(?X1,?Y) .
        INSERT INTO "dbrdf_billed_delta_new"(s, o) SELECT t0.s, t1.o FROM "dbrdf_billed_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.o = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_billed" ex WHERE ex.s = t0.s AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "dbrdf_billed"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_billed_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_billed_delta_old";
        INSERT INTO "dbrdf_billed_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_billed_delta_new" t0;
        TRUNCATE TABLE "dbrdf_billed_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1118
    ---- DEPENDS ON: 1117, 1003, 0
    ----------------------------------------

    -- Nonrecursive rules

    -- [Rule] <http://dbpedia.org/ontology/Wrestler>(?X) :- <http://dbpedia.org/ontology/debut>(?X,?X1) .
    INSERT INTO "dbrdf_Wrestler"(s) SELECT DISTINCT t0.s FROM "dbrdf_debut" t0 WHERE NOT EXISTS (SELECT 1 FROM "dbrdf_Wrestler" ex WHERE ex.s = t0.s);
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    total_tuples := total_tuples + rows_nr;

    -- [Rule] <http://dbpedia.org/ontology/Wrestler>(?X) :- <http://dbpedia.org/ontology/billed>(?X,?X1) .
    INSERT INTO "dbrdf_Wrestler"(s) SELECT DISTINCT t0.s FROM "dbrdf_billed" t0 WHERE NOT EXISTS (SELECT 1 FROM "dbrdf_Wrestler" ex WHERE ex.s = t0.s);
    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_Wrestler_delta_old"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_Wrestler_delta_old"(s) SELECT t0.s FROM "dbrdf_Wrestler" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_Wrestler_delta_old" ON "dbrdf_Wrestler_delta_old"(s);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_Wrestler_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/Wrestler$delta_new>(?Y) :- <http://dbpedia.org/ontology/Wrestler$delta_old>(?X0), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_Wrestler_delta_new"(s) SELECT t1.o FROM "dbrdf_Wrestler_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.s = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_Wrestler" ex WHERE ex.s = t1.o);


        -- Propagate $delta_new

        INSERT INTO "dbrdf_Wrestler"(s) SELECT DISTINCT t0.s FROM "dbrdf_Wrestler_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_Wrestler_delta_old";
        INSERT INTO "dbrdf_Wrestler_delta_old"(s) SELECT DISTINCT t0.s FROM "dbrdf_Wrestler_delta_new" t0;
        TRUNCATE TABLE "dbrdf_Wrestler_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1119
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_managingEditor_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_managingEditor_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_managingEditor" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_managingEditor_delta_old" ON "dbrdf_managingEditor_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_managingEditor_delta_old" ON "dbrdf_managingEditor_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_managingEditor_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/managingEditor$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/managingEditor$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_managingEditor_delta_new"(s, o) SELECT t1.o, t0.o FROM "dbrdf_managingEditor_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.s = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_managingEditor" ex WHERE ex.s = t1.o AND ex.o = t0.o);


        -- <http://dbpedia.org/ontology/managingEditor$delta_new>(?X0,?Y) :- <http://dbpedia.org/ontology/managingEditor$delta_old>(?X0,?X1), owl:sameAs(?X1,?Y) .
        INSERT INTO "dbrdf_managingEditor_delta_new"(s, o) SELECT t0.s, t1.o FROM "dbrdf_managingEditor_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.o = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_managingEditor" ex WHERE ex.s = t0.s AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "dbrdf_managingEditor"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_managingEditor_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_managingEditor_delta_old";
        INSERT INTO "dbrdf_managingEditor_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_managingEditor_delta_new" t0;
        TRUNCATE TABLE "dbrdf_managingEditor_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1120
    ---- 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 "dbrdf_mass0" t0;
    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, "dbrdf_sameAs" t1 WHERE t0.s = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_mass0" ex WHERE ex.s = t1.o 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, "dbrdf_sameAs" t1 WHERE t0.o = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_mass0" ex WHERE ex.s = t0.s AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "dbrdf_mass0"(s, o) SELECT DISTINCT t0.s, 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 1121
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_countryWithFirstSatellite_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_countryWithFirstSatellite_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_countryWithFirstSatellite" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_countryWithFirstSatellite_delta_old" ON "dbrdf_countryWithFirstSatellite_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_countryWithFirstSatellite_delta_old" ON "dbrdf_countryWithFirstSatellite_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_countryWithFirstSatellite_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/countryWithFirstSatellite$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/countryWithFirstSatellite$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_countryWithFirstSatellite_delta_new"(s, o) SELECT t1.o, t0.o FROM "dbrdf_countryWithFirstSatellite_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.s = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_countryWithFirstSatellite" ex WHERE ex.s = t1.o AND ex.o = t0.o);


        -- <http://dbpedia.org/ontology/countryWithFirstSatellite$delta_new>(?X0,?Y) :- <http://dbpedia.org/ontology/countryWithFirstSatellite$delta_old>(?X0,?X1), owl:sameAs(?X1,?Y) .
        INSERT INTO "dbrdf_countryWithFirstSatellite_delta_new"(s, o) SELECT t0.s, t1.o FROM "dbrdf_countryWithFirstSatellite_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.o = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_countryWithFirstSatellite" ex WHERE ex.s = t0.s AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "dbrdf_countryWithFirstSatellite"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_countryWithFirstSatellite_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_countryWithFirstSatellite_delta_old";
        INSERT INTO "dbrdf_countryWithFirstSatellite_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_countryWithFirstSatellite_delta_new" t0;
        TRUNCATE TABLE "dbrdf_countryWithFirstSatellite_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1122
    ---- 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 "dbrdf_cmykCoordinateCyanic" t0;
    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, "dbrdf_sameAs" t1 WHERE t0.s = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_cmykCoordinateCyanic" ex WHERE ex.s = t1.o 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, "dbrdf_sameAs" t1 WHERE t0.o = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_cmykCoordinateCyanic" ex WHERE ex.s = t0.s AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "dbrdf_cmykCoordinateCyanic"(s, o) SELECT DISTINCT t0.s, 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 1123
    ---- 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 "dbrdf_schoolNumber" t0;
    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, "dbrdf_sameAs" t1 WHERE t0.s = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_schoolNumber" ex WHERE ex.s = t1.o 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, "dbrdf_sameAs" t1 WHERE t0.o = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_schoolNumber" ex WHERE ex.s = t0.s AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "dbrdf_schoolNumber"(s, o) SELECT DISTINCT t0.s, 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 1124
    ---- 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 "dbrdf_decideDate" t0;
    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, "dbrdf_sameAs" t1 WHERE t0.s = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_decideDate" ex WHERE ex.s = t1.o 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, "dbrdf_sameAs" t1 WHERE t0.o = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_decideDate" ex WHERE ex.s = t0.s AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "dbrdf_decideDate"(s, o) SELECT DISTINCT t0.s, 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 1125
    ---- DEPENDS ON: 1124, 52, 0
    ----------------------------------------

    -- Nonrecursive rules

    -- [Rule] <http://dbpedia.org/ontology/SupremeCourtOfTheUnitedStatesCase>(?X) :- <http://dbpedia.org/ontology/decideDate>(?X,?X1) .
    INSERT INTO "dbrdf_SupremeCourtOfTheUnitedStatesCase"(s) SELECT DISTINCT t0.s FROM "dbrdf_decideDate" t0 WHERE NOT EXISTS (SELECT 1 FROM "dbrdf_SupremeCourtOfTheUnitedStatesCase" ex WHERE ex.s = t0.s);
    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 "dbrdf_SupremeCourtOfTheUnitedStatesCase"(s) SELECT DISTINCT t0.s FROM "dbrdf_argueDate" t0 WHERE NOT EXISTS (SELECT 1 FROM "dbrdf_SupremeCourtOfTheUnitedStatesCase" ex WHERE ex.s = t0.s);
    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 "dbrdf_SupremeCourtOfTheUnitedStatesCase" t0;
    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, "dbrdf_sameAs" t1 WHERE t0.s = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_SupremeCourtOfTheUnitedStatesCase" ex WHERE ex.s = t1.o);


        -- Propagate $delta_new

        INSERT INTO "dbrdf_SupremeCourtOfTheUnitedStatesCase"(s) SELECT DISTINCT t0.s 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 1126
    ---- DEPENDS ON: 1125, 0
    ----------------------------------------

    -- Nonrecursive rules

    -- [Rule] <http://dbpedia.org/ontology/LegalCase>(?X) :- <http://dbpedia.org/ontology/SupremeCourtOfTheUnitedStatesCase>(?X) .
    INSERT INTO "dbrdf_LegalCase"(s) SELECT t0.s FROM "dbrdf_SupremeCourtOfTheUnitedStatesCase" t0 WHERE NOT EXISTS (SELECT 1 FROM "dbrdf_LegalCase" ex WHERE ex.s = t0.s);
    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 "dbrdf_LegalCase" t0;
    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, "dbrdf_sameAs" t1 WHERE t0.s = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_LegalCase" ex WHERE ex.s = t1.o);


        -- Propagate $delta_new

        INSERT INTO "dbrdf_LegalCase"(s) SELECT DISTINCT t0.s 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 1127
    ---- 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 "dbrdf_creationYear" t0;
    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, "dbrdf_sameAs" t1 WHERE t0.s = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_creationYear" ex WHERE ex.s = t1.o 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, "dbrdf_sameAs" t1 WHERE t0.o = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_creationYear" ex WHERE ex.s = t0.s AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "dbrdf_creationYear"(s, o) SELECT DISTINCT t0.s, 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 1128
    ---- 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 "dbrdf_nextMission" t0;
    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, "dbrdf_sameAs" t1 WHERE t0.s = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_nextMission" ex WHERE ex.s = t1.o 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, "dbrdf_sameAs" t1 WHERE t0.o = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_nextMission" ex WHERE ex.s = t0.s AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "dbrdf_nextMission"(s, o) SELECT DISTINCT t0.s, 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 1129
    ---- 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 "dbrdf_MouseGene" t0;
    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, "dbrdf_sameAs" t1 WHERE t0.s = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_MouseGene" ex WHERE ex.s = t1.o);


        -- Propagate $delta_new

        INSERT INTO "dbrdf_MouseGene"(s) SELECT DISTINCT t0.s 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 1130
    ---- 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 "dbrdf_head" t0;
    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, "dbrdf_sameAs" t1 WHERE t0.s = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_head" ex WHERE ex.s = t1.o 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, "dbrdf_sameAs" t1 WHERE t0.o = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_head" ex WHERE ex.s = t0.s AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "dbrdf_head"(s, o) SELECT DISTINCT t0.s, 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 1131
    ---- 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 "dbrdf_coExecutiveProducer" t0;
    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, "dbrdf_sameAs" t1 WHERE t0.s = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_coExecutiveProducer" ex WHERE ex.s = t1.o 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, "dbrdf_sameAs" t1 WHERE t0.o = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_coExecutiveProducer" ex WHERE ex.s = t0.s AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "dbrdf_coExecutiveProducer"(s, o) SELECT DISTINCT t0.s, 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 1132
    ---- 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 "dbrdf_maximumBoatLength" t0;
    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, "dbrdf_sameAs" t1 WHERE t0.s = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_maximumBoatLength" ex WHERE ex.s = t1.o 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, "dbrdf_sameAs" t1 WHERE t0.o = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_maximumBoatLength" ex WHERE ex.s = t0.s AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "dbrdf_maximumBoatLength"(s, o) SELECT DISTINCT t0.s, 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 1133
    ---- 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 "dbrdf_pistonStroke0" t0;
    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, "dbrdf_sameAs" t1 WHERE t0.s = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_pistonStroke0" ex WHERE ex.s = t1.o 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, "dbrdf_sameAs" t1 WHERE t0.o = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_pistonStroke0" ex WHERE ex.s = t0.s AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "dbrdf_pistonStroke0"(s, o) SELECT DISTINCT t0.s, 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 1134
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_originalMaximumBoatBeam_delta_old0"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_originalMaximumBoatBeam_delta_old0"(s, o) SELECT t0.s, t0.o FROM "dbrdf_originalMaximumBoatBeam0" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_originalMaximumBoatBeam_delta_old0" ON "dbrdf_originalMaximumBoatBeam_delta_old0"(s, o); CREATE INDEX "IDX_1_dbrdf_originalMaximumBoatBeam_delta_old0" ON "dbrdf_originalMaximumBoatBeam_delta_old0"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_originalMaximumBoatBeam_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/originalMaximumBoatBeam$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/originalMaximumBoatBeam$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_originalMaximumBoatBeam_delta_new0"(s, o) SELECT t1.o, t0.o FROM "dbrdf_originalMaximumBoatBeam_delta_old0" t0, "dbrdf_sameAs" t1 WHERE t0.s = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_originalMaximumBoatBeam0" ex WHERE ex.s = t1.o AND ex.o = t0.o);


        -- <http://dbpedia.org/ontology/originalMaximumBoatBeam$delta_new>(?X0,?Y) :- <http://dbpedia.org/ontology/originalMaximumBoatBeam$delta_old>(?X0,?X1), owl:sameAs(?X1,?Y) .
        INSERT INTO "dbrdf_originalMaximumBoatBeam_delta_new0"(s, o) SELECT t0.s, t1.o FROM "dbrdf_originalMaximumBoatBeam_delta_old0" t0, "dbrdf_sameAs" t1 WHERE t0.o = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_originalMaximumBoatBeam0" ex WHERE ex.s = t0.s AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "dbrdf_originalMaximumBoatBeam0"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_originalMaximumBoatBeam_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_originalMaximumBoatBeam_delta_old0";
        INSERT INTO "dbrdf_originalMaximumBoatBeam_delta_old0"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_originalMaximumBoatBeam_delta_new0" t0;
        TRUNCATE TABLE "dbrdf_originalMaximumBoatBeam_delta_new0";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1135
    ---- 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 "dbrdf_broadcastStationClass" t0;
    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, "dbrdf_sameAs" t1 WHERE t0.s = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_broadcastStationClass" ex WHERE ex.s = t1.o 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, "dbrdf_sameAs" t1 WHERE t0.o = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_broadcastStationClass" ex WHERE ex.s = t0.s AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "dbrdf_broadcastStationClass"(s, o) SELECT DISTINCT t0.s, 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 1136
    ---- 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 "dbrdf_numberOfBronzeMedalsWon" t0;
    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, "dbrdf_sameAs" t1 WHERE t0.s = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_numberOfBronzeMedalsWon" ex WHERE ex.s = t1.o 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, "dbrdf_sameAs" t1 WHERE t0.o = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_numberOfBronzeMedalsWon" ex WHERE ex.s = t0.s AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "dbrdf_numberOfBronzeMedalsWon"(s, o) SELECT DISTINCT t0.s, 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 1137
    ---- 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 "dbrdf_summerTemperature" t0;
    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, "dbrdf_sameAs" t1 WHERE t0.s = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_summerTemperature" ex WHERE ex.s = t1.o 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, "dbrdf_sameAs" t1 WHERE t0.o = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_summerTemperature" ex WHERE ex.s = t0.s AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "dbrdf_summerTemperature"(s, o) SELECT DISTINCT t0.s, 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 1138
    ---- 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 "dbrdf_projectStartDate" t0;
    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, "dbrdf_sameAs" t1 WHERE t0.s = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_projectStartDate" ex WHERE ex.s = t1.o 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, "dbrdf_sameAs" t1 WHERE t0.o = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_projectStartDate" ex WHERE ex.s = t0.s AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "dbrdf_projectStartDate"(s, o) SELECT DISTINCT t0.s, 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 1139
    ---- 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 "dbrdf_firstGame" t0;
    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, "dbrdf_sameAs" t1 WHERE t0.s = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_firstGame" ex WHERE ex.s = t1.o 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, "dbrdf_sameAs" t1 WHERE t0.o = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_firstGame" ex WHERE ex.s = t0.s AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "dbrdf_firstGame"(s, o) SELECT DISTINCT t0.s, 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 1140
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_firstPublicationDate_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_firstPublicationDate_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_firstPublicationDate" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_firstPublicationDate_delta_old" ON "dbrdf_firstPublicationDate_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_firstPublicationDate_delta_old" ON "dbrdf_firstPublicationDate_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_firstPublicationDate_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/firstPublicationDate$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/firstPublicationDate$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_firstPublicationDate_delta_new"(s, o) SELECT t1.o, t0.o FROM "dbrdf_firstPublicationDate_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.s = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_firstPublicationDate" ex WHERE ex.s = t1.o AND ex.o = t0.o);


        -- <http://dbpedia.org/ontology/firstPublicationDate$delta_new>(?X0,?Y) :- <http://dbpedia.org/ontology/firstPublicationDate$delta_old>(?X0,?X1), owl:sameAs(?X1,?Y) .
        INSERT INTO "dbrdf_firstPublicationDate_delta_new"(s, o) SELECT t0.s, t1.o FROM "dbrdf_firstPublicationDate_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.o = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_firstPublicationDate" ex WHERE ex.s = t0.s AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "dbrdf_firstPublicationDate"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_firstPublicationDate_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_firstPublicationDate_delta_old";
        INSERT INTO "dbrdf_firstPublicationDate_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_firstPublicationDate_delta_new" t0;
        TRUNCATE TABLE "dbrdf_firstPublicationDate_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1141
    ---- 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 "dbrdf_supplies" t0;
    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, "dbrdf_sameAs" t1 WHERE t0.s = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_supplies" ex WHERE ex.s = t1.o 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, "dbrdf_sameAs" t1 WHERE t0.o = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_supplies" ex WHERE ex.s = t0.s AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "dbrdf_supplies"(s, o) SELECT DISTINCT t0.s, 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 1142
    ---- DEPENDS ON: 1141, 922, 0
    ----------------------------------------

    -- Nonrecursive rules

    -- [Rule] <http://dbpedia.org/ontology/Artery>(?X1) :- <http://dbpedia.org/ontology/artery>(?X,?X1) .
    INSERT INTO "dbrdf_Artery"(s) SELECT DISTINCT t0.o FROM "dbrdf_artery" t0 WHERE NOT EXISTS (SELECT 1 FROM "dbrdf_Artery" ex WHERE ex.s = t0.o);
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    total_tuples := total_tuples + rows_nr;

    -- [Rule] <http://dbpedia.org/ontology/Artery>(?X) :- <http://dbpedia.org/ontology/supplies>(?X,?X1) .
    INSERT INTO "dbrdf_Artery"(s) SELECT DISTINCT t0.s FROM "dbrdf_supplies" t0 WHERE NOT EXISTS (SELECT 1 FROM "dbrdf_Artery" ex WHERE ex.s = t0.s);
    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_Artery_delta_old"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_Artery_delta_old"(s) SELECT t0.s FROM "dbrdf_Artery" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_Artery_delta_old" ON "dbrdf_Artery_delta_old"(s);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_Artery_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/Artery$delta_new>(?Y) :- <http://dbpedia.org/ontology/Artery$delta_old>(?X0), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_Artery_delta_new"(s) SELECT t1.o FROM "dbrdf_Artery_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.s = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_Artery" ex WHERE ex.s = t1.o);


        -- Propagate $delta_new

        INSERT INTO "dbrdf_Artery"(s) SELECT DISTINCT t0.s FROM "dbrdf_Artery_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_Artery_delta_old";
        INSERT INTO "dbrdf_Artery_delta_old"(s) SELECT DISTINCT t0.s FROM "dbrdf_Artery_delta_new" t0;
        TRUNCATE TABLE "dbrdf_Artery_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1143
    ---- 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 "dbrdf_PowerStation" t0;
    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, "dbrdf_sameAs" t1 WHERE t0.s = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_PowerStation" ex WHERE ex.s = t1.o);


        -- Propagate $delta_new

        INSERT INTO "dbrdf_PowerStation"(s) SELECT DISTINCT t0.s 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 1144
    ---- 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 "dbrdf_transmission" t0;
    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, "dbrdf_sameAs" t1 WHERE t0.s = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_transmission" ex WHERE ex.s = t1.o 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, "dbrdf_sameAs" t1 WHERE t0.o = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_transmission" ex WHERE ex.s = t0.s AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "dbrdf_transmission"(s, o) SELECT DISTINCT t0.s, 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 1145
    ---- 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 "dbrdf_headAlloy" t0;
    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, "dbrdf_sameAs" t1 WHERE t0.s = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_headAlloy" ex WHERE ex.s = t1.o 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, "dbrdf_sameAs" t1 WHERE t0.o = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_headAlloy" ex WHERE ex.s = t0.s AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "dbrdf_headAlloy"(s, o) SELECT DISTINCT t0.s, 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 1146
    ---- 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 "dbrdf_numberOfMinistries" t0;
    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, "dbrdf_sameAs" t1 WHERE t0.s = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_numberOfMinistries" ex WHERE ex.s = t1.o 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, "dbrdf_sameAs" t1 WHERE t0.o = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_numberOfMinistries" ex WHERE ex.s = t0.s AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "dbrdf_numberOfMinistries"(s, o) SELECT DISTINCT t0.s, 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 1147
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_actingHeadteacher_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_actingHeadteacher_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_actingHeadteacher" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_actingHeadteacher_delta_old" ON "dbrdf_actingHeadteacher_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_actingHeadteacher_delta_old" ON "dbrdf_actingHeadteacher_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_actingHeadteacher_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/actingHeadteacher$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/actingHeadteacher$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_actingHeadteacher_delta_new"(s, o) SELECT t1.o, t0.o FROM "dbrdf_actingHeadteacher_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.s = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_actingHeadteacher" ex WHERE ex.s = t1.o AND ex.o = t0.o);


        -- <http://dbpedia.org/ontology/actingHeadteacher$delta_new>(?X0,?Y) :- <http://dbpedia.org/ontology/actingHeadteacher$delta_old>(?X0,?X1), owl:sameAs(?X1,?Y) .
        INSERT INTO "dbrdf_actingHeadteacher_delta_new"(s, o) SELECT t0.s, t1.o FROM "dbrdf_actingHeadteacher_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.o = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_actingHeadteacher" ex WHERE ex.s = t0.s AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "dbrdf_actingHeadteacher"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_actingHeadteacher_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_actingHeadteacher_delta_old";
        INSERT INTO "dbrdf_actingHeadteacher_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_actingHeadteacher_delta_new" t0;
        TRUNCATE TABLE "dbrdf_actingHeadteacher_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1148
    ---- 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 "dbrdf_giniCoefficientRanking" t0;
    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, "dbrdf_sameAs" t1 WHERE t0.s = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_giniCoefficientRanking" ex WHERE ex.s = t1.o 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, "dbrdf_sameAs" t1 WHERE t0.o = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_giniCoefficientRanking" ex WHERE ex.s = t0.s AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "dbrdf_giniCoefficientRanking"(s, o) SELECT DISTINCT t0.s, 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 1149
    ---- 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 "dbrdf_passengersPerYear" t0;
    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, "dbrdf_sameAs" t1 WHERE t0.s = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_passengersPerYear" ex WHERE ex.s = t1.o 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, "dbrdf_sameAs" t1 WHERE t0.o = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_passengersPerYear" ex WHERE ex.s = t0.s AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "dbrdf_passengersPerYear"(s, o) SELECT DISTINCT t0.s, 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 1150
    ---- 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 "dbrdf_shoeNumber" t0;
    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, "dbrdf_sameAs" t1 WHERE t0.s = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_shoeNumber" ex WHERE ex.s = t1.o 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, "dbrdf_sameAs" t1 WHERE t0.o = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_shoeNumber" ex WHERE ex.s = t0.s AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "dbrdf_shoeNumber"(s, o) SELECT DISTINCT t0.s, 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 1151
    ---- 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 "dbrdf_numberOfRooms" t0;
    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, "dbrdf_sameAs" t1 WHERE t0.s = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_numberOfRooms" ex WHERE ex.s = t1.o 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, "dbrdf_sameAs" t1 WHERE t0.o = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_numberOfRooms" ex WHERE ex.s = t0.s AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "dbrdf_numberOfRooms"(s, o) SELECT DISTINCT t0.s, 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 1152
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_buildingStartYear_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_buildingStartYear_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_buildingStartYear" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_buildingStartYear_delta_old" ON "dbrdf_buildingStartYear_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_buildingStartYear_delta_old" ON "dbrdf_buildingStartYear_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_buildingStartYear_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/buildingStartYear$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/buildingStartYear$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_buildingStartYear_delta_new"(s, o) SELECT t1.o, t0.o FROM "dbrdf_buildingStartYear_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.s = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_buildingStartYear" ex WHERE ex.s = t1.o AND ex.o = t0.o);


        -- <http://dbpedia.org/ontology/buildingStartYear$delta_new>(?X0,?Y) :- <http://dbpedia.org/ontology/buildingStartYear$delta_old>(?X0,?X1), owl:sameAs(?X1,?Y) .
        INSERT INTO "dbrdf_buildingStartYear_delta_new"(s, o) SELECT t0.s, t1.o FROM "dbrdf_buildingStartYear_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.o = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_buildingStartYear" ex WHERE ex.s = t0.s AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "dbrdf_buildingStartYear"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_buildingStartYear_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_buildingStartYear_delta_old";
        INSERT INTO "dbrdf_buildingStartYear_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_buildingStartYear_delta_new" t0;
        TRUNCATE TABLE "dbrdf_buildingStartYear_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1153
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_previousWork_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_previousWork_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_previousWork" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_previousWork_delta_old" ON "dbrdf_previousWork_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_previousWork_delta_old" ON "dbrdf_previousWork_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_previousWork_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/previousWork$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/previousWork$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_previousWork_delta_new"(s, o) SELECT t1.o, t0.o FROM "dbrdf_previousWork_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.s = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_previousWork" ex WHERE ex.s = t1.o AND ex.o = t0.o);


        -- <http://dbpedia.org/ontology/previousWork$delta_new>(?X0,?Y) :- <http://dbpedia.org/ontology/previousWork$delta_old>(?X0,?X1), owl:sameAs(?X1,?Y) .
        INSERT INTO "dbrdf_previousWork_delta_new"(s, o) SELECT t0.s, t1.o FROM "dbrdf_previousWork_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.o = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_previousWork" ex WHERE ex.s = t0.s AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "dbrdf_previousWork"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_previousWork_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_previousWork_delta_old";
        INSERT INTO "dbrdf_previousWork_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_previousWork_delta_new" t0;
        TRUNCATE TABLE "dbrdf_previousWork_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1154
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_lymph_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_lymph_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_lymph" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_lymph_delta_old" ON "dbrdf_lymph_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_lymph_delta_old" ON "dbrdf_lymph_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_lymph_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/lymph$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/lymph$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_lymph_delta_new"(s, o) SELECT t1.o, t0.o FROM "dbrdf_lymph_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.s = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_lymph" ex WHERE ex.s = t1.o AND ex.o = t0.o);


        -- <http://dbpedia.org/ontology/lymph$delta_new>(?X0,?Y) :- <http://dbpedia.org/ontology/lymph$delta_old>(?X0,?X1), owl:sameAs(?X1,?Y) .
        INSERT INTO "dbrdf_lymph_delta_new"(s, o) SELECT t0.s, t1.o FROM "dbrdf_lymph_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.o = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_lymph" ex WHERE ex.s = t0.s AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "dbrdf_lymph"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_lymph_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_lymph_delta_old";
        INSERT INTO "dbrdf_lymph_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_lymph_delta_new" t0;
        TRUNCATE TABLE "dbrdf_lymph_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1155
    ---- DEPENDS ON: 1154, 0
    ----------------------------------------

    -- Nonrecursive rules

    -- [Rule] <http://dbpedia.org/ontology/Lymph>(?X1) :- <http://dbpedia.org/ontology/lymph>(?X,?X1) .
    INSERT INTO "dbrdf_Lymph"(s) SELECT DISTINCT t0.o FROM "dbrdf_lymph" t0 WHERE NOT EXISTS (SELECT 1 FROM "dbrdf_Lymph" ex WHERE ex.s = t0.o);
    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_Lymph_delta_old"(s integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_Lymph_delta_old"(s) SELECT t0.s FROM "dbrdf_Lymph" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_Lymph_delta_old" ON "dbrdf_Lymph_delta_old"(s);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_Lymph_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/Lymph$delta_new>(?Y) :- <http://dbpedia.org/ontology/Lymph$delta_old>(?X0), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_Lymph_delta_new"(s) SELECT t1.o FROM "dbrdf_Lymph_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.s = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_Lymph" ex WHERE ex.s = t1.o);


        -- Propagate $delta_new

        INSERT INTO "dbrdf_Lymph"(s) SELECT DISTINCT t0.s FROM "dbrdf_Lymph_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_Lymph_delta_old";
        INSERT INTO "dbrdf_Lymph_delta_old"(s) SELECT DISTINCT t0.s FROM "dbrdf_Lymph_delta_new" t0;
        TRUNCATE TABLE "dbrdf_Lymph_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1156
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_illustrator_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_illustrator_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_illustrator" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_illustrator_delta_old" ON "dbrdf_illustrator_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_illustrator_delta_old" ON "dbrdf_illustrator_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_illustrator_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/illustrator$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/illustrator$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_illustrator_delta_new"(s, o) SELECT t1.o, t0.o FROM "dbrdf_illustrator_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.s = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_illustrator" ex WHERE ex.s = t1.o AND ex.o = t0.o);


        -- <http://dbpedia.org/ontology/illustrator$delta_new>(?X0,?Y) :- <http://dbpedia.org/ontology/illustrator$delta_old>(?X0,?X1), owl:sameAs(?X1,?Y) .
        INSERT INTO "dbrdf_illustrator_delta_new"(s, o) SELECT t0.s, t1.o FROM "dbrdf_illustrator_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.o = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_illustrator" ex WHERE ex.s = t0.s AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "dbrdf_illustrator"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_illustrator_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_illustrator_delta_old";
        INSERT INTO "dbrdf_illustrator_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_illustrator_delta_new" t0;
        TRUNCATE TABLE "dbrdf_illustrator_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1157
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_firstWinner_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_firstWinner_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_firstWinner" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_firstWinner_delta_old" ON "dbrdf_firstWinner_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_firstWinner_delta_old" ON "dbrdf_firstWinner_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_firstWinner_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/firstWinner$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/firstWinner$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_firstWinner_delta_new"(s, o) SELECT t1.o, t0.o FROM "dbrdf_firstWinner_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.s = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_firstWinner" ex WHERE ex.s = t1.o AND ex.o = t0.o);


        -- <http://dbpedia.org/ontology/firstWinner$delta_new>(?X0,?Y) :- <http://dbpedia.org/ontology/firstWinner$delta_old>(?X0,?X1), owl:sameAs(?X1,?Y) .
        INSERT INTO "dbrdf_firstWinner_delta_new"(s, o) SELECT t0.s, t1.o FROM "dbrdf_firstWinner_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.o = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_firstWinner" ex WHERE ex.s = t0.s AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "dbrdf_firstWinner"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_firstWinner_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_firstWinner_delta_old";
        INSERT INTO "dbrdf_firstWinner_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_firstWinner_delta_new" t0;
        TRUNCATE TABLE "dbrdf_firstWinner_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1158
    ---- 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 "dbrdf_buildingStartDate" t0;
    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, "dbrdf_sameAs" t1 WHERE t0.s = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_buildingStartDate" ex WHERE ex.s = t1.o 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, "dbrdf_sameAs" t1 WHERE t0.o = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_buildingStartDate" ex WHERE ex.s = t0.s AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "dbrdf_buildingStartDate"(s, o) SELECT DISTINCT t0.s, 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 1159
    ---- 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 "dbrdf_length2" t0;
    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, "dbrdf_sameAs" t1 WHERE t0.s = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_length2" ex WHERE ex.s = t1.o 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, "dbrdf_sameAs" t1 WHERE t0.o = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_length2" ex WHERE ex.s = t0.s AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "dbrdf_length2"(s, o) SELECT DISTINCT t0.s, 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 1160
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_currentPartner_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_currentPartner_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_currentPartner" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_currentPartner_delta_old" ON "dbrdf_currentPartner_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_currentPartner_delta_old" ON "dbrdf_currentPartner_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_currentPartner_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/currentPartner$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/currentPartner$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_currentPartner_delta_new"(s, o) SELECT t1.o, t0.o FROM "dbrdf_currentPartner_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.s = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_currentPartner" ex WHERE ex.s = t1.o AND ex.o = t0.o);


        -- <http://dbpedia.org/ontology/currentPartner$delta_new>(?X0,?Y) :- <http://dbpedia.org/ontology/currentPartner$delta_old>(?X0,?X1), owl:sameAs(?X1,?Y) .
        INSERT INTO "dbrdf_currentPartner_delta_new"(s, o) SELECT t0.s, t1.o FROM "dbrdf_currentPartner_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.o = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_currentPartner" ex WHERE ex.s = t0.s AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "dbrdf_currentPartner"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_currentPartner_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_currentPartner_delta_old";
        INSERT INTO "dbrdf_currentPartner_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_currentPartner_delta_new" t0;
        TRUNCATE TABLE "dbrdf_currentPartner_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1161
    ---- 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 "dbrdf_routeStartDirection" t0;
    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, "dbrdf_sameAs" t1 WHERE t0.s = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_routeStartDirection" ex WHERE ex.s = t1.o 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, "dbrdf_sameAs" t1 WHERE t0.o = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_routeStartDirection" ex WHERE ex.s = t0.s AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "dbrdf_routeStartDirection"(s, o) SELECT DISTINCT t0.s, 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 1162
    ---- 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 "dbrdf_mass1" t0;
    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, "dbrdf_sameAs" t1 WHERE t0.s = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_mass1" ex WHERE ex.s = t1.o 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, "dbrdf_sameAs" t1 WHERE t0.o = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_mass1" ex WHERE ex.s = t0.s AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "dbrdf_mass1"(s, o) SELECT DISTINCT t0.s, 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 1163
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_currentlyUsedFor_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_currentlyUsedFor_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_currentlyUsedFor" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_currentlyUsedFor_delta_old" ON "dbrdf_currentlyUsedFor_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_currentlyUsedFor_delta_old" ON "dbrdf_currentlyUsedFor_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_currentlyUsedFor_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/currentlyUsedFor$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/currentlyUsedFor$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_currentlyUsedFor_delta_new"(s, o) SELECT t1.o, t0.o FROM "dbrdf_currentlyUsedFor_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.s = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_currentlyUsedFor" ex WHERE ex.s = t1.o AND ex.o = t0.o);


        -- <http://dbpedia.org/ontology/currentlyUsedFor$delta_new>(?X0,?Y) :- <http://dbpedia.org/ontology/currentlyUsedFor$delta_old>(?X0,?X1), owl:sameAs(?X1,?Y) .
        INSERT INTO "dbrdf_currentlyUsedFor_delta_new"(s, o) SELECT t0.s, t1.o FROM "dbrdf_currentlyUsedFor_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.o = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_currentlyUsedFor" ex WHERE ex.s = t0.s AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "dbrdf_currentlyUsedFor"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_currentlyUsedFor_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_currentlyUsedFor_delta_old";
        INSERT INTO "dbrdf_currentlyUsedFor_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_currentlyUsedFor_delta_new" t0;
        TRUNCATE TABLE "dbrdf_currentlyUsedFor_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1164
    ---- 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 "dbrdf_numberOfLawyers" t0;
    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, "dbrdf_sameAs" t1 WHERE t0.s = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_numberOfLawyers" ex WHERE ex.s = t1.o 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, "dbrdf_sameAs" t1 WHERE t0.o = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_numberOfLawyers" ex WHERE ex.s = t0.s AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "dbrdf_numberOfLawyers"(s, o) SELECT DISTINCT t0.s, 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 1165
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_populationMetroDensity_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_populationMetroDensity_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_populationMetroDensity" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_populationMetroDensity_delta_old" ON "dbrdf_populationMetroDensity_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_populationMetroDensity_delta_old" ON "dbrdf_populationMetroDensity_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_populationMetroDensity_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/populationMetroDensity$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/populationMetroDensity$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_populationMetroDensity_delta_new"(s, o) SELECT t1.o, t0.o FROM "dbrdf_populationMetroDensity_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.s = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_populationMetroDensity" ex WHERE ex.s = t1.o AND ex.o = t0.o);


        -- <http://dbpedia.org/ontology/populationMetroDensity$delta_new>(?X0,?Y) :- <http://dbpedia.org/ontology/populationMetroDensity$delta_old>(?X0,?X1), owl:sameAs(?X1,?Y) .
        INSERT INTO "dbrdf_populationMetroDensity_delta_new"(s, o) SELECT t0.s, t1.o FROM "dbrdf_populationMetroDensity_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.o = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_populationMetroDensity" ex WHERE ex.s = t0.s AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "dbrdf_populationMetroDensity"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_populationMetroDensity_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_populationMetroDensity_delta_old";
        INSERT INTO "dbrdf_populationMetroDensity_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_populationMetroDensity_delta_new" t0;
        TRUNCATE TABLE "dbrdf_populationMetroDensity_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1166
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_creatorOfDish_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_creatorOfDish_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_creatorOfDish" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_creatorOfDish_delta_old" ON "dbrdf_creatorOfDish_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_creatorOfDish_delta_old" ON "dbrdf_creatorOfDish_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_creatorOfDish_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/creatorOfDish$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/creatorOfDish$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_creatorOfDish_delta_new"(s, o) SELECT t1.o, t0.o FROM "dbrdf_creatorOfDish_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.s = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_creatorOfDish" ex WHERE ex.s = t1.o AND ex.o = t0.o);


        -- <http://dbpedia.org/ontology/creatorOfDish$delta_new>(?X0,?Y) :- <http://dbpedia.org/ontology/creatorOfDish$delta_old>(?X0,?X1), owl:sameAs(?X1,?Y) .
        INSERT INTO "dbrdf_creatorOfDish_delta_new"(s, o) SELECT t0.s, t1.o FROM "dbrdf_creatorOfDish_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.o = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_creatorOfDish" ex WHERE ex.s = t0.s AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "dbrdf_creatorOfDish"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_creatorOfDish_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_creatorOfDish_delta_old";
        INSERT INTO "dbrdf_creatorOfDish_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_creatorOfDish_delta_new" t0;
        TRUNCATE TABLE "dbrdf_creatorOfDish_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1167
    ---- 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 "dbrdf_usingCountry" t0;
    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, "dbrdf_sameAs" t1 WHERE t0.s = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_usingCountry" ex WHERE ex.s = t1.o 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, "dbrdf_sameAs" t1 WHERE t0.o = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_usingCountry" ex WHERE ex.s = t0.s AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "dbrdf_usingCountry"(s, o) SELECT DISTINCT t0.s, 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 1168
    ---- 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 "dbrdf_undraftedYear" t0;
    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, "dbrdf_sameAs" t1 WHERE t0.s = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_undraftedYear" ex WHERE ex.s = t1.o 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, "dbrdf_sameAs" t1 WHERE t0.o = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_undraftedYear" ex WHERE ex.s = t0.s AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "dbrdf_undraftedYear"(s, o) SELECT DISTINCT t0.s, 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 1169
    ---- 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 "dbrdf_territory" t0;
    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, "dbrdf_sameAs" t1 WHERE t0.s = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_territory" ex WHERE ex.s = t1.o 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, "dbrdf_sameAs" t1 WHERE t0.o = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_territory" ex WHERE ex.s = t0.s AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "dbrdf_territory"(s, o) SELECT DISTINCT t0.s, 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 1170
    ---- DEPENDS ON: 0
    ----------------------------------------

    -- Prepare temporary tables for recursive rules

    delta_old_size := 0;

    CREATE LOCAL TEMPORARY TABLE "dbrdf_bgafdId_delta_old"(s integer, o integer) ON COMMIT DROP;
    INSERT INTO "dbrdf_bgafdId_delta_old"(s, o) SELECT t0.s, t0.o FROM "dbrdf_bgafdId" t0;
    GET DIAGNOSTICS rows_nr = ROW_COUNT;
    delta_old_size := delta_old_size + rows_nr;
    CREATE INDEX "IDX_0_dbrdf_bgafdId_delta_old" ON "dbrdf_bgafdId_delta_old"(s, o); CREATE INDEX "IDX_1_dbrdf_bgafdId_delta_old" ON "dbrdf_bgafdId_delta_old"(o);
    CREATE LOCAL TEMPORARY TABLE "dbrdf_bgafdId_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/bgafdId$delta_new>(?Y,?X1) :- <http://dbpedia.org/ontology/bgafdId$delta_old>(?X0,?X1), owl:sameAs(?X0,?Y) .
        INSERT INTO "dbrdf_bgafdId_delta_new"(s, o) SELECT t1.o, t0.o FROM "dbrdf_bgafdId_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.s = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_bgafdId" ex WHERE ex.s = t1.o AND ex.o = t0.o);


        -- <http://dbpedia.org/ontology/bgafdId$delta_new>(?X0,?Y) :- <http://dbpedia.org/ontology/bgafdId$delta_old>(?X0,?X1), owl:sameAs(?X1,?Y) .
        INSERT INTO "dbrdf_bgafdId_delta_new"(s, o) SELECT t0.s, t1.o FROM "dbrdf_bgafdId_delta_old" t0, "dbrdf_sameAs" t1 WHERE t0.o = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_bgafdId" ex WHERE ex.s = t0.s AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "dbrdf_bgafdId"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_bgafdId_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_bgafdId_delta_old";
        INSERT INTO "dbrdf_bgafdId_delta_old"(s, o) SELECT DISTINCT t0.s, t0.o FROM "dbrdf_bgafdId_delta_new" t0;
        TRUNCATE TABLE "dbrdf_bgafdId_delta_new";

    END LOOP;

    -- END Recursive rules

    ----------------------------------------
    ---- COMPONENT 1171
    ---- 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 "dbrdf_governor" t0;
    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, "dbrdf_sameAs" t1 WHERE t0.s = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_governor" ex WHERE ex.s = t1.o 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, "dbrdf_sameAs" t1 WHERE t0.o = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_governor" ex WHERE ex.s = t0.s AND ex.o = t1.o);


        -- Propagate $delta_new

        INSERT INTO "dbrdf_governor"(s, o) SELECT DISTINCT t0.s, 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 1172
    ---- 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 "dbrdf_discoverer" t0;
    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, "dbrdf_sameAs" t1 WHERE t0.s = t1.s AND NOT EXISTS (SELECT 1 FROM "dbrdf_discoverer" ex WHERE ex.s = t1.o 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) .
